Some tweaks to use implicit caching

Author: ilevkivskyi

mypy/indirection.py

@@ -37,15 +37,15 @@ def find_modules(self, typs: Iterable[types.Type]) -> set[str]:
         return self.modules
 
     def _visit(self, typ: types.Type) -> None:
-        if isinstance(typ, types.TypeAliasType) and typ.is_recursive:
+        if isinstance(typ, types.TypeAliasType):
             # Avoid infinite recursion for recursive type aliases.
             self.seen_aliases.add(typ)
         typ.accept(self)
 
     def _visit_type_tuple(self, typs: tuple[types.Type, ...]) -> None:
         # Micro-optimization: Specialized version of _visit for lists
         for typ in typs:
-            if isinstance(typ, types.TypeAliasType) and typ.is_recursive:
+            if isinstance(typ, types.TypeAliasType):
                 # Avoid infinite recursion for recursive type aliases.
                 if typ in self.seen_aliases:
                     continue
@@ -55,7 +55,7 @@ def _visit_type_tuple(self, typs: tuple[types.Type, ...]) -> None:
     def _visit_type_list(self, typs: list[types.Type]) -> None:
         # Micro-optimization: Specialized version of _visit for tuples
         for typ in typs:
-            if isinstance(typ, types.TypeAliasType) and typ.is_recursive:
+            if isinstance(typ, types.TypeAliasType):
                 # Avoid infinite recursion for recursive type aliases.
                 if typ in self.seen_aliases:
                     continue

mypy/semanal_typeargs.py

@@ -100,9 +100,14 @@ def visit_type_alias_type(self, t: TypeAliasType) -> None:
         if not is_error:
             # If there was already an error for the alias itself, there is no point in checking
             # the expansion, most likely it will result in the same kind of error.
-            get_proper_type(t).accept(self)
             if t.alias is not None:
                 t.alias.accept(self)
+            if t.args:
+                # Since we always allow unbounded type variables in alias definitions, we need
+                # 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)
 
     def visit_tuple_type(self, t: TupleType) -> None:
         t.items = flatten_nested_tuples(t.items)

mypy/type_visitor.py

@@ -445,13 +445,13 @@ def visit_placeholder_type(self, t: PlaceholderType, /) -> T:
     def visit_type_alias_type(self, t: TypeAliasType, /) -> T:
         if self.skip_alias_target:
             return self.query_types(t.args)
-        # Skip type aliases already visited types to avoid infinite recursion.
-        if t.is_recursive:
-            if self.seen_aliases is None:
-                self.seen_aliases = set()
-            elif t in self.seen_aliases:
-                return self.strategy([])
-            self.seen_aliases.add(t)
+        # Skip type aliases already visited types to avoid infinite recursion
+        # (also use this as a simple-minded cache).
+        if self.seen_aliases is None:
+            self.seen_aliases = set()
+        elif t in self.seen_aliases:
+            return self.strategy([])
+        self.seen_aliases.add(t)
         return get_proper_type(t).accept(self)
 
     def query_types(self, types: Iterable[Type]) -> T:
@@ -586,13 +586,13 @@ def visit_placeholder_type(self, t: PlaceholderType, /) -> bool:
     def visit_type_alias_type(self, t: TypeAliasType, /) -> bool:
         if self.skip_alias_target:
             return self.query_types(t.args)
-        # Skip type aliases already visited types to avoid infinite recursion.
-        if t.is_recursive:
-            if self.seen_aliases is None:
-                self.seen_aliases = set()
-            elif t in self.seen_aliases:
-                return self.default
-            self.seen_aliases.add(t)
+        # Skip type aliases already visited types to avoid infinite recursion
+        # (also use this as a simple-minded cache).
+        if self.seen_aliases is None:
+            self.seen_aliases = set()
+        elif t in self.seen_aliases:
+            return self.default
+        self.seen_aliases.add(t)
         return get_proper_type(t).accept(self)
 
     def query_types(self, types: list[Type] | tuple[Type, ...]) -> bool:

test-data/unit/check-recursive-types.test

@@ -189,7 +189,7 @@ class A(NamedTuple('A', [('attr', List[Exp])])): pass
 class B(NamedTuple('B', [('val', object)])): pass
 
 def my_eval(exp: Exp) -> int:
-    reveal_type(exp) # N: Revealed type is "Union[tuple[builtins.list[Union[..., tuple[builtins.object, fallback=__main__.B]]], fallback=__main__.A], tuple[builtins.object, fallback=__main__.B]]"
+    reveal_type(exp) # N: Revealed type is "Union[tuple[builtins.list[...], fallback=__main__.A], tuple[builtins.object, fallback=__main__.B]]"
     if isinstance(exp, A):
         my_eval(exp[0][0])
         return my_eval(exp.attr[0])
@@ -578,7 +578,7 @@ B = NamedTuple('B', [('x', A), ('y', int)])
 A = NamedTuple('A', [('x', str), ('y', 'B')])
 n: A
 def f(m: B) -> None: pass
-reveal_type(n) # N: Revealed type is "tuple[builtins.str, tuple[tuple[builtins.str, ..., fallback=__main__.A], builtins.int, fallback=__main__.B], fallback=__main__.A]"
+reveal_type(n) # N: Revealed type is "tuple[builtins.str, tuple[..., builtins.int, fallback=__main__.B], fallback=__main__.A]"
 reveal_type(f) # N: Revealed type is "def (m: tuple[tuple[builtins.str, ..., fallback=__main__.A], builtins.int, fallback=__main__.B])"
 f(n)  # E: Argument 1 to "f" has incompatible type "A"; expected "B"
 [builtins fixtures/tuple.pyi]
@@ -1013,4 +1013,4 @@ from typing import Callable
 from bogus import Foo  # type: ignore
 
 A = Callable[[Foo, "B"], Foo]  # E: Type alias target becomes "Callable[[Any, B], Any]" due to an unfollowed import
-B = Callable[[Foo, A], Foo]  # E: Type alias target becomes "Callable[[Any, Callable[[Any, B], Any]], Any]" due to an unfollowed import
+B = Callable[[Foo, A], Foo]  # E: Type alias target becomes "Callable[[Any, A], Any]" due to an unfollowed import