Some cleanup

Author: ilevkivskyi

mypy/checkexpr.py

@@ -4983,17 +4983,16 @@ class LongName(Generic[T]): ...
         #     A = List[Tuple[T, T]]
         #     x = A() <- same as List[Tuple[Any, Any]], see PEP 484.
         disallow_any = self.chk.options.disallow_any_generics and self.is_callee
-        item = get_proper_type(
-            set_any_tvars(
-                alias,
-                [],
-                ctx.line,
-                ctx.column,
-                self.chk.options,
-                disallow_any=disallow_any,
-                fail=self.msg.fail,
-            )[0]
+        item, _ = set_any_tvars(
+            alias,
+            [],
+            ctx.line,
+            ctx.column,
+            self.chk.options,
+            disallow_any=disallow_any,
+            fail=self.msg.fail,
         )
+        item = get_proper_type(item)
         if isinstance(item, Instance):
             # Normally we get a callable type (or overloaded) with .is_type_obj() true
             # representing the class's constructor

mypy/nodes.py

@@ -3168,6 +3168,9 @@ class TypeVarLikeExpr(SymbolNode, Expression):
     # TypeVar(..., contravariant=True) defines a contravariant type
     # variable.
     variance: int
+    # Record instances and type aliases that appear bare/implicit in the default value
+    # of this type variable. This is needed to detect recursive type variable defaults.
+    default_depends: set[TypeInfo | TypeAlias] | None
 
     def __init__(
         self,
@@ -3186,7 +3189,7 @@ def __init__(
         self.default = default
         self.variance = variance
         self.is_new_style = is_new_style
-        self.default_depends: set[TypeInfo | TypeAlias] | None = None
+        self.default_depends = None
 
     @property
     def name(self) -> str:
@@ -3826,6 +3829,16 @@ class is generic then it will be a type constructor of higher kind.
     # appears in runtime context.
     type_object_type: mypy.types.FunctionLike | None
 
+    # Type variables whose defaults depend on defaults of type variables in other classes
+    # and type aliases. We keep track of this to safely handle situations like this one:
+    #     class C[T = D]: ...
+    #     class D[S = C]: ...
+    #     x: C
+    # Since we apply fix_instance() eagerly, inferring a precise type is quite tricky.
+    # Therefore, we infer the type of `x` as `C[D[Any]]` to avoid infinite recursion.
+    # Keys are type variable full names.
+    default_depends: dict[str, set[TypeAlias | TypeInfo]]
+
     FLAGS: Final = [
         "is_abstract",
         "is_enum",
@@ -3887,7 +3900,7 @@ def __init__(self, names: SymbolTable, defn: ClassDef, module_name: str) -> None
         self.is_type_check_only = False
         self.deprecated = None
         self.type_object_type = None
-        self.default_depends: dict[str, set[TypeAlias | TypeInfo]] = {}
+        self.default_depends = {}
 
     def add_type_vars(self) -> None:
         self.has_type_var_tuple_type = False
@@ -4586,6 +4599,7 @@ def __init__(
         self.eager = eager
         self.python_3_12_type_alias = python_3_12_type_alias
         self.tvar_tuple_index = None
+        # This plays the same role as TypeInfo.default_depends attribute.
         self.default_depends: dict[str, set[TypeAlias | TypeInfo]] = {}
         for i, t in enumerate(alias_tvars):
             if isinstance(t, mypy.types.TypeVarTupleType):

mypy/semanal.py

@@ -538,6 +538,10 @@ def __init__(
         #   [b.py]
         #     import foo.bar
         self.transitive_submodule_imports: dict[str, set[str]] = {}
+
+        # Instances and type aliases that were fixed using default valuers of type
+        # variables. This can be used on-demand by type analyzer. Use record_fixed_type()
+        # to create the set lazily.
         self.types_fixed: set[TypeInfo | TypeAlias] | None = None
 
     # mypyc doesn't properly handle implementing an abstractproperty
@@ -1990,8 +1994,10 @@ def analyze_class(self, defn: ClassDef) -> None:
                 default_depends[tv.fullname] = tv.default_depends
 
         if any(has_placeholder(tvd) for tvd in tvar_defs):
-            # Some type variable bounds or values are not ready, we need
-            # to re-analyze this class.
+            # Some type variable bounds or values are not ready, we need to
+            # re-analyze this class. Note we force progress to handle cases like
+            # class C[T = C], this matches logic in process_typevar_parameters()
+            # for "old style" type variables.
             self.defer(force_progress=tvar_defs != defn.type_vars)
 
         self.analyze_class_keywords(defn)
@@ -2283,7 +2289,8 @@ class Foo(Bar, Generic[T]): ...
 
         Note that this is performed *before* semantic analysis.
 
-        Returns (remaining base expressions, inferred type variables, is protocol).
+        Returns a tuple:
+            (remaining base expressions, type variables, is protocol, type variable expressions).
         """
         removed: list[int] = []
         declared_tvars: TypeVarLikeList = []
@@ -3993,7 +4000,8 @@ def analyze_alias(
         """Check if 'rvalue' is a valid type allowed for aliasing (e.g. not a type variable).
 
         If yes, return the corresponding type, a list of type variables for generic aliases,
-        a set of names the alias depends on, and True if the original type has empty tuple index.
+        a set of names the alias depends on, whether the original type has empty tuple index,
+        and any type variables whose defaults depend on other classes or type aliases.
         An example for the dependencies:
             A = int
             B = str
@@ -4179,9 +4187,6 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
                 self.mark_incomplete(lvalue.name, rvalue, becomes_typeinfo=True)
                 return True
 
-            if any(has_placeholder(tv) for tv in alias_tvars):
-                self.defer()
-
         self.add_type_alias_deps(depends_on)
         check_for_explicit_any(res, self.options, self.is_typeshed_stub_file, self.msg, context=s)
         # When this type alias gets "inlined", the Any is not explicit anymore,
@@ -4236,7 +4241,7 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
             # An alias gets updated.
             updated = False
             if isinstance(existing.node, TypeAlias):
-                if existing.node.target != res or existing.node.alias_tvars != alias_tvars:
+                if existing.node.target != res:
                     # Copy expansion to the existing alias, this matches how we update base classes
                     # for a TypeInfo _in place_ if there are nested placeholders.
                     existing.node.target = res
@@ -4250,6 +4255,8 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
                 # Otherwise just replace existing placeholder with type alias *in place*.
                 existing._node = alias_node
                 updated = True
+            # TODO: switch type aliases to if has_placeholder(): process_placeholder() pattern.
+            # Type aliases are last notable exception from this logic.
             if updated:
                 if self.final_iteration:
                     self.cannot_resolve_name(lvalue.name, "name", s)
@@ -4773,6 +4780,7 @@ def process_typevar_declaration(self, s: AssignmentStmt) -> bool:
         n_values = call.arg_kinds[1:].count(ARG_POS)
         values = self.analyze_value_types(call.args[1 : 1 + n_values])
 
+        # Reset fixed types both before and after each collection just in case.
         self.types_fixed = None
         res = self.process_typevar_parameters(
             call.args[1 + n_values :],
@@ -5027,18 +5035,16 @@ def get_typevarlike_argument(
                 #     class Custom(Generic[T]):
                 #         ...
                 analyzed = PlaceholderType(None, [], context.line)
-            if report_invalid_typevar_arg:
-                if (
-                    isinstance(analyzed, ProperType)
-                    and isinstance(analyzed, AnyType)
-                    and analyzed.is_from_error
-                ):
-                    self.fail(
-                        message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format(
-                            typevarlike_name, param_name
-                        ),
-                        param_value,
-                    )
+            if (
+                report_invalid_typevar_arg
+                and isinstance(analyzed, ProperType)
+                and isinstance(analyzed, AnyType)
+                and analyzed.is_from_error
+            ):
+                self.fail(
+                    message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format(typevarlike_name, param_name),
+                    param_value,
+                )
                 # Note: we do not return 'None' here -- we want to continue
                 # using the AnyType.
             return analyzed
@@ -5757,10 +5763,9 @@ def visit_type_alias_stmt(self, s: TypeAliasStmt) -> None:
                 self.mark_incomplete(s.name.name, s.value, becomes_typeinfo=True)
                 return
 
-            # Now go through all new variables and temporary replace all tvars that still
-            # refer to some placeholders. We defer the whole alias and will revisit it again,
-            # as well as all its dependents.
             if any(has_placeholder(tv) for tv in alias_tvars):
+                # Defer the alias if some type variables are not ready, same as for classes.
+                # Note: progress is forced below (if needed).
                 self.defer()
 
             self.add_type_alias_deps(depends_on)

mypy/type_visitor.py

@@ -595,7 +595,15 @@ def visit_type_alias_type(self, t: TypeAliasType, /) -> bool:
         elif t in self.seen_aliases:
             return self.default
         self.seen_aliases.add(t)
-        return get_proper_type(t).accept(self) or self.query_types(t.args)
+        res = get_proper_type(t).accept(self)
+        # This is a weird edge case: if a type alias has unused type variables, we
+        # should visit arguments even if we didn't find anything in the expansion.
+        # As an optimization, do this only for new style type aliases.
+        assert t.alias is not None
+        if self.strategy == ANY_STRATEGY:
+            return res or (t.alias.python_3_12_type_alias and self.query_types(t.args))
+        else:
+            return res and (not t.alias.python_3_12_type_alias or self.query_types(t.args))
 
     def query_types(self, types: list[Type] | tuple[Type, ...]) -> bool:
         """Perform a query for a sequence of types using the strategy to combine the results."""

mypy/typeanal.py

@@ -269,6 +269,7 @@ def __init__(
         self.allow_type_any = allow_type_any
         self.allow_type_var_tuple = False
         self.allow_unpack = allow_unpack
+        # Set when we are analyzing a default of a type variable.
         self.analyzing_tvar_def = analyzing_tvar_def
 
     def lookup_qualified(
@@ -914,6 +915,8 @@ def analyze_type_with_type_info(
                     analyzing_tvar_def=self.analyzing_tvar_def,
                 )
                 if self.analyzing_tvar_def and used_default:
+                    # For convenience, we make default depend on the original TypeInfo,
+                    # *not* on the special alias.
                     self.api.record_fixed_type(info)
                 return res
             return tup.copy_modified(
@@ -936,6 +939,8 @@ def analyze_type_with_type_info(
                     analyzing_tvar_def=self.analyzing_tvar_def,
                 )
                 if self.analyzing_tvar_def and used_default:
+                    # For convenience, we make default depend on the original TypeInfo,
+                    # *not* on the special alias.
                     self.api.record_fixed_type(info)
                 return res
             # Create a named TypedDictType
@@ -2114,8 +2119,10 @@ def fix_instance(
             if tv.has_default():
                 arg = tv.default
                 if analyzing_tvar_def:
+                    # Record the use of default only when analyzing another default.
                     used_default = True
                     if is_typevar_default_recursive(tv.fullname, t.type):
+                        # If this results in infinite recursion, use Any instead.
                         use_any = True
             else:
                 use_any = True
@@ -2362,6 +2369,7 @@ def set_any_tvars(
         if arg is None:
             if tv.has_default():
                 arg = tv.default
+                # Same as for instances, record and avoid infinite recursion.
                 if analyzing_tvar_def:
                     used_default = True
                     if is_typevar_default_recursive(tv.fullname, node):
@@ -2401,16 +2409,19 @@ def set_any_tvars(
     return t, used_default
 
 
-def is_typevar_default_recursive(tv: str, start: TypeInfo | TypeAlias) -> bool:
-    if tv not in start.default_depends:
+def is_typevar_default_recursive(tv_fname: str, start: TypeInfo | TypeAlias) -> bool:
+    """Check if the type variable can lead to infinite recursion via defaults."""
+    if tv_fname not in start.default_depends:
         return False
-    todo = start.default_depends[tv].copy()
+    todo = start.default_depends[tv_fname].copy()
     seen: set[TypeAlias | TypeInfo] = set()
     while todo:
         node = todo.pop()
         if node is start:
             return True
         if node in seen:
+            # We don't return True here, since we are interested only in
+            # recursion via the original type variable.
             continue
         seen.add(node)
         for dep_nodes in node.default_depends.values():

mypy/types.py

@@ -855,7 +855,12 @@ def __eq__(self, other: object) -> bool:
         if not isinstance(other, ParamSpecType):
             return NotImplemented
         # Upper bound can be ignored, since it's determined by flavor.
-        return self.id == other.id and self.flavor == other.flavor and self.prefix == other.prefix
+        return (
+            self.id == other.id
+            and self.flavor == other.flavor
+            and self.prefix == other.prefix
+            and self.default == other.default
+        )
 
     def serialize(self) -> JsonDict:
         assert not self.id.is_meta_var()
@@ -1004,7 +1009,9 @@ def __hash__(self) -> int:
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, TypeVarTupleType):
             return NotImplemented
-        return self.id == other.id and self.min_len == other.min_len
+        return (
+            self.id == other.id and self.min_len == other.min_len and self.default == other.default
+        )
 
     def copy_modified(
         self,