Fix special form in nested

Author: pablogsal

mypy/semanal.py

@@ -8263,13 +8263,19 @@ def remove_imported_names_from_symtable(names: SymbolTable, module: str) -> None
 
 def make_any_non_explicit(t: Type) -> Type:
     """Replace all Any types within in with Any that has attribute 'explicit' set to False"""
+    # An alias whose target is exactly Any should still behave like a real Any when used.
+    # Explicit Any nested inside a larger alias target is kept as the historical
+    # non-real Any flavor to avoid making large generic aliases overload-ambiguous.
+    proper_t = get_proper_type(t)
+    if isinstance(proper_t, AnyType) and proper_t.type_of_any == TypeOfAny.explicit:
+        return proper_t.copy_modified(TypeOfAny.from_alias_target)
     return t.accept(MakeAnyNonExplicit())
 
 
 class MakeAnyNonExplicit(TrivialSyntheticTypeTranslator):
     def visit_any(self, t: AnyType) -> Type:
         if t.type_of_any == TypeOfAny.explicit:
-            return t.copy_modified(TypeOfAny.from_alias_target)
+            return t.copy_modified(TypeOfAny.special_form)
         return t
 
     def visit_type_alias_type(self, t: TypeAliasType) -> Type:

test-data/unit/check-overloading.test

@@ -6997,3 +6997,35 @@ def f(x: Incomplete) -> Incomplete:  # no error
 
 a: Incomplete = 1  # no error
 [builtins fixtures/tuple.pyi]
+
+[case testOverloadNestedAliasAnyDoesNotTriggerAmbiguity]
+# Explicit Any nested inside a larger type alias should not trigger the
+# overload-ambiguity fallback. This matches numpy/pandas-style aliases such as
+# `ndarray[tuple[Any, ...], dtype[T]]`.
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import Never, TypeAlias
+
+S = TypeVar("S")
+Sh = TypeVar("Sh")
+
+class Array(Generic[Sh, S]): pass
+
+Shape: TypeAlias = tuple[Any, ...]
+BoolArray: TypeAlias = Array[Shape, bool]
+
+class Series(Generic[S]):
+    @overload
+    def __add__(self: Series[Never], other: object) -> Series[Any]: ...  # type: ignore[overload-overlap]
+    @overload
+    def __add__(self: Series[S], other: Array[Any, S]) -> Series[S]: ...
+    @overload
+    def __add__(self: Series[S], other: Array[Any, bool]) -> Series[S]: ...
+    @overload
+    def __add__(self: Series[bool], other: Array[Any, bool]) -> Series[bool]: ...
+    @overload
+    def __add__(self: Series[str], other: Array[Any, bool]) -> Never: ...
+    def __add__(self, other): ...
+
+def f(x: Series[Any], y: BoolArray) -> None:
+    reveal_type(x + y)  # N: Revealed type is "__main__.Series[Any]"
+[builtins fixtures/tuple.pyi]