Count Any inside type aliases for overload ambiguity

Alias targets store a written Any as TypeOfAny.special_form, so
has_any_type ignored Nested = Sequence[Any] and picked the first
overload. That contradicted the new docs and the spec (aliases are
transparent). Count special-form Any only while expanding aliases.

Docs now include an alias example. Tests cover nested and bare Any
aliases, including the #15630 identity-check repro.

Author: hasancankeles

CHANGELOG.md

@@ -10,6 +10,10 @@
 
 - Clarify that nested `Any` in an overload argument is ambiguous, the same as a top-level `Any` (PR [21897](https://github.com/python/mypy/pull/21897))
 
+### Other Notable Fixes and Improvements
+
+- Treat type aliases that expand to `Any` (or a type containing `Any`) as ambiguous in overload matching, matching a written `Any` (PR [21897](https://github.com/python/mypy/pull/21897))
+
 ## Mypy 2.3
 
 We've just uploaded mypy 2.3.0 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).

docs/source/more_types.rst

@@ -395,8 +395,9 @@ for making sure ``summarize`` breaks ties in the same way at runtime.
 
 However, there are two exceptions to the "pick the first match" rule.
 First, if multiple variants match because an argument has type ``Any``
-or *contains* ``Any`` (for example ``list[Any]`` or ``Sequence[Any]``),
-mypy will make the inferred type also be ``Any``:
+or *contains* ``Any`` (for example ``list[Any]`` or ``Sequence[Any]``,
+including via a type alias), mypy will make the inferred type also be
+``Any``:
 
 .. code-block:: python
 
@@ -412,6 +413,11 @@ mypy will make the inferred type also be ``Any``:
     # call is therefore ambiguous in the same way as a top-level Any.
     output2_nested = summarize(nested_any)
 
+    Nested = list[Any]
+    aliased: Nested = some_dynamic_function()
+    # output2_alias is also 'Any': a type alias does not hide the nested Any.
+    output2_alias = summarize(aliased)
+
 Second, if multiple variants match due to one or more of the arguments
 being a union, mypy will make the inferred type be the union of the
 matching variant returns:

mypy/checkexpr.py

@@ -6638,9 +6638,23 @@ class HasAnyType(types.BoolTypeQuery):
     def __init__(self, ignore_in_type_obj: bool) -> None:
         super().__init__(types.ANY_STRATEGY)
         self.ignore_in_type_obj = ignore_in_type_obj
+        # Alias targets store a written `Any` as TypeOfAny.special_form.
+        # Count those as real Any while expanding aliases, so Nested = Sequence[Any]
+        # matches a direct Sequence[Any] for overload ambiguity.
+        self.count_alias_special_form_any = False
 
     def visit_any(self, t: AnyType) -> bool:
-        return t.type_of_any != TypeOfAny.special_form  # special forms are not real Any types
+        if t.type_of_any == TypeOfAny.special_form:
+            return self.count_alias_special_form_any
+        return True
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> bool:
+        old = self.count_alias_special_form_any
+        self.count_alias_special_form_any = True
+        try:
+            return super().visit_type_alias_type(t)
+        finally:
+            self.count_alias_special_form_any = old
 
     def visit_callable_type(self, t: CallableType) -> bool:
         if self.ignore_in_type_obj and t.is_type_obj():
@@ -6856,8 +6870,9 @@ def any_causes_overload_ambiguity(
     """May an argument containing 'Any' cause ambiguous result type on call to overloaded function?
 
     This includes nested Any, such as Sequence[Any] or list[Any], not just a
-    top-level Any. A nested Any can materialize as different concrete types, so
-    if several overloads remain and their return types differ, the result is Any.
+    top-level Any, and the same types reached through a type alias. A nested
+    Any can materialize as different concrete types, so if several overloads
+    remain and their return types differ, the result is Any.
     (If every materialization matched an earlier overload, the spec would drop
     later ones; this helper over-approximates that case as ambiguous.)
 

test-data/unit/check-overloading.test

@@ -2086,10 +2086,9 @@ class Box:
 nested_any: Sequence[Any]
 reveal_type(Box().get(nested_any))  # N: Revealed type is "Any"
 
-[case testOverloadNestedAnyViaTypeAliasStillFirstMatch]
-# Type aliases currently hide Any from the overload-ambiguity check because
-# alias targets store Any as a special form (#15630). This is not the #21768
-# rule and is left unchanged; do not "fix" #21768 by assuming aliases agree.
+[case testOverloadNestedAnyViaTypeAliasIsAmbiguous]
+# A type alias must not hide nested Any from overload matching. Alias targets
+# store written Any as a special form; that is still Any (#15630, #21768).
 from typing import Any, Sequence, overload
 
 Nested = Sequence[Any]
@@ -2103,7 +2102,43 @@ def f(s): pass
 direct: Sequence[Any]
 aliased: Nested
 reveal_type(f(direct))  # N: Revealed type is "Any"
-reveal_type(f(aliased))  # N: Revealed type is "builtins.int"
+reveal_type(f(aliased))  # N: Revealed type is "Any"
+
+[case testOverloadBareAnyTypeAliasIsAmbiguous]
+# https://github.com/python/mypy/issues/15630
+from typing import Any, overload
+
+TypeSpec = Any
+
+@overload
+def f(x: int) -> int: ...
+@overload
+def f(x: object) -> object: ...
+def f(x): pass
+
+a: Any
+b: TypeSpec
+reveal_type(f(a))  # N: Revealed type is "Any"
+reveal_type(f(b))  # N: Revealed type is "Any"
+
+[case testOverloadBareAnyTypeAliasDoesNotPickFirstForIdentity]
+# The #15630 reproducer: an alias to Any must not pick the first overload.
+from typing import Any, Union, overload
+
+@overload
+def my_origin(x: type) -> type: ...
+@overload
+def my_origin(x: Any) -> Any: ...
+def my_origin(x):
+    return x
+
+TypeSpec = Any
+
+def call_any(spec: Any) -> bool:
+    return my_origin(spec) is Union
+
+def call_alias(spec: TypeSpec) -> bool:
+    return my_origin(spec) is Union
 
 [case testOverloadOnOverloadWithType]
 from typing import Any, Type, TypeVar, overload