Fix crash on typevar with forward ref used in other module (#20334)

Fixes #20326

Type variables with forward references in upper bound are known to be
problematic. Existing mechanisms to work with them implicitly assumed
that they are used in the same module where they are defined, which is
not necessarily the case for "old-style" type variables that can be
imported.

Note that the simplification I made in `semanal_typeargs.py` would be
probably sufficient to fix this, but that would be papering over the
real issue, so I am making a bit more principled fix.

Author: ilevkivskyi

mypy/plugins/proper_plugin.py

@@ -108,6 +108,7 @@ def is_special_target(right: ProperType) -> bool:
             "mypy.types.RequiredType",
             "mypy.types.ReadOnlyType",
             "mypy.types.TypeGuardedType",
+            "mypy.types.PlaceholderType",
         ):
             # Special case: these are not valid targets for a type alias and thus safe.
             # TODO: introduce a SyntheticType base to simplify this?

mypy/semanal.py

@@ -4945,7 +4945,7 @@ def get_typevarlike_argument(
             )
             if analyzed is None:
                 # Type variables are special: we need to place them in the symbol table
-                # soon, even if upper bound is not ready yet. Otherwise avoiding
+                # soon, even if upper bound is not ready yet. Otherwise, avoiding
                 # a "deadlock" in this common pattern would be tricky:
                 #     T = TypeVar('T', bound=Custom[Any])
                 #     class Custom(Generic[T]):

mypy/semanal_typeargs.py

@@ -176,12 +176,12 @@ def validate_args(
                         code=codes.VALID_TYPE,
                     )
                     continue
+                if self.in_type_alias_expr and isinstance(arg, TypeVarType):
+                    # Type aliases are allowed to use unconstrained type variables
+                    # error will be checked at substitution point.
+                    continue
                 if tvar.values:
                     if isinstance(arg, TypeVarType):
-                        if self.in_type_alias_expr:
-                            # Type aliases are allowed to use unconstrained type variables
-                            # error will be checked at substitution point.
-                            continue
                         arg_values = arg.values
                         if not arg_values:
                             is_error = True
@@ -205,10 +205,6 @@ def validate_args(
                     and upper_bound.type.fullname == "builtins.object"
                 )
                 if not object_upper_bound and not is_subtype(arg, upper_bound):
-                    if self.in_type_alias_expr and isinstance(arg, TypeVarType):
-                        # Type aliases are allowed to use unconstrained type variables
-                        # error will be checked at substitution point.
-                        continue
                     is_error = True
                     self.fail(
                         message_registry.INVALID_TYPEVAR_ARG_BOUND.format(

mypy/typeanal.py

@@ -346,6 +346,15 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
             if hook is not None:
                 return hook(AnalyzeTypeContext(t, t, self))
             tvar_def = self.tvar_scope.get_binding(sym)
+            if tvar_def is not None:
+                # We need to cover special-case explained in get_typevarlike_argument() here,
+                # since otherwise the deferral will not be triggered if the type variable is
+                # used in a different module. Using isinstance() should be safe for this purpose.
+                tvar_params = [tvar_def.upper_bound, tvar_def.default]
+                if isinstance(tvar_def, TypeVarType):
+                    tvar_params += tvar_def.values
+                if any(isinstance(tp, PlaceholderType) for tp in tvar_params):
+                    self.api.defer()
             if isinstance(sym.node, ParamSpecExpr):
                 if tvar_def is None:
                     if self.allow_unbound_tvars:

test-data/unit/check-type-aliases.test

@@ -1351,3 +1351,93 @@ reveal_type(D(x="asdf"))  # E: No overload variant of "dict" matches argument ty
                           # N:     def __init__(self, arg: Iterable[tuple[str, int]], **kwargs: int) -> dict[str, int] \
                           # N: Revealed type is "Any"
 [builtins fixtures/dict.pyi]
+
+[case testTypeAliasesInCyclicImport1]
+import p.aliases
+
+[file p/__init__.py]
+[file p/aliases.py]
+from typing_extensions import TypeAlias
+from .defs import C, Alias1
+
+Alias2: TypeAlias = Alias1[C]
+
+[file p/defs.py]
+from typing import TypeVar
+from typing_extensions import TypeAlias
+import p.aliases
+
+C = TypeVar("C", bound="SomeClass")
+Alias1: TypeAlias = C
+
+class SomeClass:
+    pass
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypeAliasesInCyclicImport2]
+import p.aliases
+
+[file p/__init__.py]
+[file p/aliases.py]
+from typing_extensions import TypeAlias
+from .defs import C, Alias1
+
+Alias2: TypeAlias = Alias1[C]
+
+[file p/defs.py]
+from typing import TypeVar, Union
+from typing_extensions import TypeAlias
+import p.aliases
+
+C = TypeVar("C", bound="SomeClass")
+Alias1: TypeAlias = Union[C, int]
+
+class SomeClass:
+    pass
+[builtins fixtures/tuple.pyi]
+
+[case testTypeAliasesInCyclicImport3]
+import p.aliases
+
+[file p/__init__.py]
+[file p/aliases.py]
+from typing_extensions import TypeAlias
+from .defs import C, Alias1
+
+Alias2: TypeAlias = Alias1[C]
+
+[file p/defs.py]
+from typing import TypeVar
+from typing_extensions import TypeAlias
+import p.aliases
+
+C = TypeVar("C", bound="list[SomeClass]")
+Alias1: TypeAlias = C
+
+class SomeClass:
+    pass
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypeAliasesInCyclicImport4]
+import p.aliases
+
+[file p/__init__.py]
+[file p/aliases.py]
+from typing_extensions import TypeAlias
+from .defs import C, Alias1
+
+Alias2: TypeAlias = Alias1[C]
+
+[file p/defs.py]
+from typing import TypeVar, Union
+from typing_extensions import TypeAlias
+import p.aliases
+
+C = TypeVar("C", bound="list[SomeClass]")
+Alias1: TypeAlias = Union[C, int]
+
+class SomeClass:
+    pass
+[builtins fixtures/tuple.pyi]