Tracks seen aliases by TypeAlias node instead of TypeAliasType instance in semanal_typeargs.py and

  server/deps.py, consistent with the fix applied to type_visitor.py.

Author: newmoooon

mypy/semanal_typeargs.py

@@ -15,7 +15,7 @@
 from mypy.message_registry import INVALID_PARAM_SPEC_LOCATION, INVALID_PARAM_SPEC_LOCATION_NOTE
 from mypy.messages import format_type
 from mypy.mixedtraverser import MixedTraverserVisitor
-from mypy.nodes import Block, ClassDef, Context, FakeInfo, FuncItem, MypyFile
+from mypy.nodes import Block, ClassDef, Context, FakeInfo, FuncItem, MypyFile, TypeAlias
 from mypy.options import Options
 from mypy.scope import Scope
 from mypy.subtypes import is_same_type, is_subtype
@@ -58,9 +58,11 @@ def __init__(
         self.scope = Scope()
         # Should we also analyze function definitions, or only module top-levels?
         self.recurse_into_functions = True
-        # Keep track of the type aliases already visited. This is needed to avoid
-        # infinite recursion on types like A = Union[int, List[A]].
-        self.seen_aliases: set[TypeAliasType] = set()
+        # Keep track of the type alias definitions already visited. This is needed
+        # to avoid infinite recursion on recursive type aliases. We track by the
+        # underlying TypeAlias node (not TypeAliasType) so that recursive aliases
+        # with varying type arguments are still caught.
+        self.seen_aliases: set[TypeAlias] = set()
 
     def visit_mypy_file(self, o: MypyFile) -> None:
         self.errors.set_file(o.path, o.fullname, scope=self.scope, options=self.options)
@@ -84,10 +86,10 @@ def visit_block(self, o: Block) -> None:
     def visit_type_alias_type(self, t: TypeAliasType) -> None:
         super().visit_type_alias_type(t)
         if t.is_recursive:
-            if t in self.seen_aliases:
+            if t.alias in self.seen_aliases:
                 # Avoid infinite recursion on recursive type aliases.
                 return
-            self.seen_aliases.add(t)
+            self.seen_aliases.add(t.alias)
         assert t.alias is not None, f"Unfixed type alias {t.type_ref}"
         is_error, is_invalid = self.validate_args(
             t.alias.name, tuple(t.args), t.alias.alias_tvars, t
@@ -105,7 +107,7 @@ def visit_type_alias_type(self, t: TypeAliasType) -> None:
                 # to verify the arguments satisfy the upper bounds of the expansion as well.
                 get_proper_type(t).accept(self)
         if t.is_recursive:
-            self.seen_aliases.discard(t)
+            self.seen_aliases.discard(t.alias)
 
     def visit_tuple_type(self, t: TupleType) -> None:
         t.items = flatten_nested_tuples(t.items)

mypy/server/deps.py

@@ -122,6 +122,7 @@ class 'mod.Cls'. This can also refer to an attribute inherited from a
     StarExpr,
     SuperExpr,
     TupleExpr,
+    TypeAlias,
     TypeAliasExpr,
     TypeApplication,
     TypedDictExpr,
@@ -949,18 +950,18 @@ def get_type_triggers(self, typ: Type) -> list[str]:
 
 
 def get_type_triggers(
-    typ: Type, use_logical_deps: bool, seen_aliases: set[TypeAliasType] | None = None
+    typ: Type, use_logical_deps: bool, seen_aliases: set[TypeAlias] | None = None
 ) -> list[str]:
     """Return all triggers that correspond to a type becoming stale."""
     return typ.accept(TypeTriggersVisitor(use_logical_deps, seen_aliases))
 
 
 class TypeTriggersVisitor(TypeVisitor[list[str]]):
     def __init__(
-        self, use_logical_deps: bool, seen_aliases: set[TypeAliasType] | None = None
+        self, use_logical_deps: bool, seen_aliases: set[TypeAlias] | None = None
     ) -> None:
         self.deps: list[str] = []
-        self.seen_aliases: set[TypeAliasType] = seen_aliases or set()
+        self.seen_aliases: set[TypeAlias] = seen_aliases or set()
         self.use_logical_deps = use_logical_deps
 
     def get_type_triggers(self, typ: Type) -> list[str]:
@@ -979,9 +980,9 @@ def visit_instance(self, typ: Instance) -> list[str]:
         return triggers
 
     def visit_type_alias_type(self, typ: TypeAliasType) -> list[str]:
-        if typ in self.seen_aliases:
+        if typ.alias in self.seen_aliases:
             return []
-        self.seen_aliases.add(typ)
+        self.seen_aliases.add(typ.alias)
         assert typ.alias is not None
         trigger = make_trigger(typ.alias.fullname)
         triggers = [trigger]