Fix overload resolution for type aliases to Any

Aliases like `Incomplete: TypeAlias = Any` were being downgraded to
TypeOfAny.special_form, the same flavor used for NewType-style
higher-kinded types. has_any_type ignores special_form Anys when
checking for overload ambiguity, which meant a 2-arg call to
os.environ.get with an alias-Any default would silently match the
`default: None = None` overload and return `str | None` instead of
Any.

Add a dedicated TypeOfAny.from_alias_target flavor that suppresses
--disallow-any-explicit at use sites (the original reason for the
downgrade) but still counts as a real Any everywhere else. Stats
reporting and the Literal[...] arg check are extended to keep their
existing behavior for the new flavor.

Author: Pablo Galindo Salgado

mypy/semanal.py

@@ -8269,7 +8269,7 @@ def make_any_non_explicit(t: Type) -> Type:
 class MakeAnyNonExplicit(TrivialSyntheticTypeTranslator):
     def visit_any(self, t: AnyType) -> Type:
         if t.type_of_any == TypeOfAny.explicit:
-            return t.copy_modified(TypeOfAny.special_form)
+            return t.copy_modified(TypeOfAny.from_alias_target)
         return t
 
     def visit_type_alias_type(self, t: TypeAliasType) -> Type:

mypy/stats.py

@@ -483,7 +483,10 @@ def is_complex(t: Type) -> bool:
 
 
 def is_special_form_any(t: AnyType) -> bool:
-    return get_original_any(t).type_of_any == TypeOfAny.special_form
+    return get_original_any(t).type_of_any in (
+        TypeOfAny.special_form,
+        TypeOfAny.from_alias_target,
+    )
 
 
 def get_original_any(t: AnyType) -> AnyType:

mypy/typeanal.py

@@ -1760,7 +1760,11 @@ def analyze_literal_param(self, idx: int, arg: Type, ctx: Context) -> list[Type]
             #
             # TODO: Once we start adding support for enums, make sure we report a custom
             # error for case 2 as well.
-            if arg.type_of_any not in (TypeOfAny.from_error, TypeOfAny.special_form):
+            if arg.type_of_any not in (
+                TypeOfAny.from_error,
+                TypeOfAny.special_form,
+                TypeOfAny.from_alias_target,
+            ):
                 self.fail(
                     f'Parameter {idx} of Literal[...] cannot be of type "Any"',
                     ctx,

mypy/types.py

@@ -237,6 +237,10 @@ class TypeOfAny:
     # used to ignore Anys inserted by the suggestion engine when
     # generating constraints.
     suggestion_engine: Final = 9
+    # Does this Any come from a type alias whose target is Any (e.g.
+    # `Incomplete: TypeAlias = Any`)? It is a real Any (unlike special_form),
+    # but tagged separately so use sites don't trigger --disallow-any-explicit.
+    from_alias_target: Final = 10
 
 
 def deserialize_type(data: JsonDict | str) -> Type:

test-data/unit/check-literal.test

@@ -562,6 +562,20 @@ reveal_type(b)                          # N: Revealed type is "Any"
 [builtins fixtures/tuple.pyi]
 [out]
 
+[case testLiteralAliasToAnyAllowed]
+# Aliases to Any (e.g. typeshed's `Incomplete: TypeAlias = Any`) must not
+# trigger the Literal[...] cannot-be-Any error, matching the behavior of
+# unfollowed-import aliases.
+from typing import Any, Literal
+from typing_extensions import TypeAlias
+
+Incomplete: TypeAlias = Any
+
+a: Literal[Incomplete]
+reveal_type(a)                          # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+[out]
+
 [case testLiteralDisallowActualTypes]
 from typing import Literal
 

test-data/unit/check-overloading.test

@@ -6856,3 +6856,145 @@ if isinstance(headers, dict):
 
 reveal_type(headers)  # N: Revealed type is "__main__.Headers | typing.Iterable[tuple[builtins.bytes, builtins.bytes]]"
 [builtins fixtures/isinstancelist.pyi]
+
+[case testOverloadAliasToAnyArgWithNoneDefault]
+# An alias `Incomplete = Any` used as an overload arg must not silently match
+# the `default: None = None` overload. It should be treated as Any like a bare
+# Any value, triggering the overload-ambiguity fallback.
+from typing import Any, TypeVar, overload
+from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+Incomplete: TypeAlias = Any
+
+class M:
+    @overload
+    def get(self, key: str, default: None = None) -> str | None: ...
+    @overload
+    def get(self, key: str, default: str) -> str: ...
+    @overload
+    def get(self, key: str, default: T) -> str | T: ...
+    def get(self, key, default=None): ...
+
+a: Incomplete
+b: Any
+reveal_type(M().get("k", a))  # N: Revealed type is "Any"
+reveal_type(M().get("k", b))  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadAliasToAnyArgEquivalentToBareAny]
+# Alias-to-Any and bare Any should produce the same overload results.
+from typing import Any, overload
+from typing_extensions import TypeAlias
+
+Incomplete: TypeAlias = Any
+
+@overload
+def f(x: int) -> int: ...
+@overload
+def f(x: str) -> str: ...
+def f(x): ...
+
+a: Incomplete
+b: Any
+reveal_type(f(a))  # N: Revealed type is "Any"
+reveal_type(f(b))  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadAliasToAnyArgChainedAlias]
+# A chained alias `Outer = Inner` where `Inner = Any` should still behave
+# like Any, both at the inner and outer level.
+from typing import Any, overload
+from typing_extensions import TypeAlias
+
+Inner: TypeAlias = Any
+Outer: TypeAlias = Inner
+
+@overload
+def f(x: int) -> int: ...
+@overload
+def f(x: str) -> str: ...
+def f(x): ...
+
+inner: Inner
+outer: Outer
+reveal_type(f(inner))  # N: Revealed type is "Any"
+reveal_type(f(outer))  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadAliasToAnyArgImplicitAlias]
+# `MyAlias = Any` without an explicit TypeAlias annotation also gets the
+# alias-Any treatment and must engage the overload-ambiguity check.
+from typing import Any, overload
+
+MyAlias = Any
+
+@overload
+def f(x: int) -> int: ...
+@overload
+def f(x: str) -> str: ...
+def f(x): ...
+
+a: MyAlias
+reveal_type(f(a))  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadAliasToAnyArgImported]
+# Alias-to-Any imported from another module must behave the same way.
+from typing import overload
+from other import Incomplete
+
+@overload
+def f(x: int) -> int: ...
+@overload
+def f(x: str) -> str: ...
+def f(x): ...
+
+a: Incomplete
+reveal_type(f(a))  # N: Revealed type is "Any"
+
+[file other.py]
+from typing import Any
+from typing_extensions import TypeAlias
+Incomplete: TypeAlias = Any
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadAliasToAnyArgUnambiguous]
+# When overloads are unambiguous, alias-to-Any should pick that overload's
+# return type just like bare Any does (no false ambiguity).
+from typing import Any, overload
+from typing_extensions import TypeAlias
+
+Incomplete: TypeAlias = Any
+
+@overload
+def f(x: int, y: int, z: str) -> int: ...
+@overload
+def f(x: object, y: int, z: str) -> object: ...
+def f(x, y, z): ...
+
+a: Incomplete
+b: Any
+# Ambiguous on x: returns Any
+reveal_type(f(a, 1, ''))  # N: Revealed type is "Any"
+reveal_type(f(b, 1, ''))  # N: Revealed type is "Any"
+# Unambiguous: x is concrete, only y/z are Any
+reveal_type(f(1, a, ''))  # N: Revealed type is "builtins.int"
+reveal_type(f(1, b, ''))  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testAliasToAnyDoesNotTriggerDisallowAnyExplicitAtUseSite]
+# --disallow-any-explicit must NOT fire at use sites of an `Alias = Any`
+# (the original purpose of make_any_non_explicit).
+# flags: --disallow-any-explicit --show-error-codes
+from typing import Any
+from typing_extensions import TypeAlias
+
+Incomplete: TypeAlias = Any  # E: Explicit "Any" is not allowed  [explicit-any]
+
+def f(x: Incomplete) -> Incomplete:  # no error
+    return x
+
+a: Incomplete = 1  # no error
+[builtins fixtures/tuple.pyi]
+

test-data/unit/check-python312.test

@@ -2242,3 +2242,20 @@ class D[*Ts](Generic[Unpack[Us]]):  # E: Generic[...] base class is redundant \
                                     # E: Can only use one type var tuple in a class def
     pass
 [builtins fixtures/tuple.pyi]
+
+[case testPEP695AliasToAnyOverloadAmbiguity]
+# A PEP 695 `type Incomplete = Any` alias used as an overload arg should
+# engage the overload-ambiguity fallback, just like a bare Any value.
+from typing import Any, overload
+
+type Incomplete = Any
+
+@overload
+def f(x: int) -> int: ...
+@overload
+def f(x: str) -> str: ...
+def f(x): ...
+
+a: Incomplete
+reveal_type(f(a))  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]