[ty] Normalize recursive types using Any (#19003)

## Summary

This just replaces one temporary solution to recursive protocols (the
`SelfReference` mechanism) with another one (track seen types when
recursively descending in `normalize` and replace recursive references
with `Any`). But this temporary solution can handle mutually-recursive
types, not just self-referential ones, and it's sufficient for the
primer ecosystem and some other projects we are testing on to no longer
stack overflow.

The follow-up here will be to properly handle these self-references
instead of replacing them with `Any`.

We will also eventually need cycle detection on more recursive-descent
type transformations and tests.

## Test Plan

Existing tests (including recursive-protocol tests) and primer.

Added mdtest for mutually-recursive protocols that stack-overflowed
before this PR.

Author: carljm

crates/ty_python_semantic/resources/mdtest/protocols.md

@@ -1729,6 +1729,21 @@ def _(r: Recursive):
     reveal_type(r.method(r).callable1(1).direct.t[1][1])  # revealed: Recursive
 ```
 
+### Mutually-recursive protocols
+
+```py
+from typing import Protocol
+from ty_extensions import is_equivalent_to, static_assert
+
+class Foo(Protocol):
+    x: "Bar"
+
+class Bar(Protocol):
+    x: Foo
+
+static_assert(is_equivalent_to(Foo, Bar))
+```
+
 ### Regression test: narrowing with self-referential protocols
 
 This snippet caused us to panic on an early version of the implementation for protocols.

crates/ty_python_semantic/resources/primer/bad.txt

@@ -10,7 +10,7 @@ jax  # too many iterations
 mypy # too many iterations (self-recursive type alias)
 packaging  # too many iterations
 pandas  # slow (9s)
-pandera  # stack overflow
+pandera  # too many iterations
 pip  # vendors packaging, see above
 pylint  # cycle panics (self-recursive type alias)
 pyodide  # too many cycle iterations
@@ -19,5 +19,4 @@ setuptools  # vendors packaging, see above
 spack  # slow, success, but mypy-primer hangs processing the output
 spark  # too many iterations
 steam.py  # hangs (single threaded)
-tornado # bad use-def map (https://github.com/astral-sh/ty/issues/365)
 xarray  # too many iterations

crates/ty_python_semantic/resources/primer/good.txt

@@ -110,6 +110,7 @@ strawberry
 streamlit
 svcs
 sympy
+tornado
 trio
 twine
 typeshed-stats

crates/ty_python_semantic/src/types.rs

@@ -22,7 +22,7 @@ use crate::types::tuple::TupleType;
 use crate::types::{
     BareTypeAliasType, Binding, BoundSuperError, BoundSuperType, CallableType, DataclassParams,
     KnownInstanceType, TypeAliasType, TypeMapping, TypeRelation, TypeVarBoundOrConstraints,
-    TypeVarInstance, TypeVarKind, infer_definition_types,
+    TypeVarInstance, TypeVarKind, TypeVisitor, infer_definition_types,
 };
 use crate::{
     Db, FxOrderSet, KnownModule, Program,
@@ -182,8 +182,12 @@ pub struct GenericAlias<'db> {
 impl get_size2::GetSize for GenericAlias<'_> {}
 
 impl<'db> GenericAlias<'db> {
-    pub(super) fn normalized(self, db: &'db dyn Db) -> Self {
-        Self::new(db, self.origin(db), self.specialization(db).normalized(db))
+    pub(super) fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
+        Self::new(
+            db,
+            self.origin(db),
+            self.specialization(db).normalized_impl(db, visitor),
+        )
     }
 
     pub(super) fn materialize(self, db: &'db dyn Db, variance: TypeVarVariance) -> Self {
@@ -249,10 +253,10 @@ pub enum ClassType<'db> {
 
 #[salsa::tracked]
 impl<'db> ClassType<'db> {
-    pub(super) fn normalized(self, db: &'db dyn Db) -> Self {
+    pub(super) fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
         match self {
             Self::NonGeneric(_) => self,
-            Self::Generic(generic) => Self::Generic(generic.normalized(db)),
+            Self::Generic(generic) => Self::Generic(generic.normalized_impl(db, visitor)),
         }
     }
 

crates/ty_python_semantic/src/types/class.rs

@@ -2,7 +2,7 @@ use crate::Db;
 use crate::types::generics::Specialization;
 use crate::types::{
     ClassType, DynamicType, KnownClass, KnownInstanceType, MroError, MroIterator, SpecialFormType,
-    Type, TypeMapping, todo_type,
+    Type, TypeMapping, TypeVisitor, todo_type,
 };
 
 /// Enumeration of the possible kinds of types we allow in class bases.
@@ -31,10 +31,10 @@ impl<'db> ClassBase<'db> {
         Self::Dynamic(DynamicType::Unknown)
     }
 
-    pub(crate) fn normalized(self, db: &'db dyn Db) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
         match self {
             Self::Dynamic(dynamic) => Self::Dynamic(dynamic.normalized()),
-            Self::Class(class) => Self::Class(class.normalized(db)),
+            Self::Class(class) => Self::Class(class.normalized_impl(db, visitor)),
             Self::Protocol | Self::Generic => self,
         }
     }

crates/ty_python_semantic/src/types/class_base.rs

@@ -0,0 +1,26 @@
+use crate::FxOrderSet;
+use crate::types::Type;
+
+#[derive(Debug, Default)]
+pub(crate) struct TypeVisitor<'db> {
+    seen: FxOrderSet<Type<'db>>,
+}
+
+impl<'db> TypeVisitor<'db> {
+    pub(crate) fn visit(
+        &mut self,
+        ty: Type<'db>,
+        func: impl FnOnce(&mut Self) -> Type<'db>,
+    ) -> Type<'db> {
+        if !self.seen.insert(ty) {
+            // TODO: proper recursive type handling
+
+            // This must be Any, not e.g. a todo type, because Any is the normalized form of the
+            // dynamic type (that is, todo types are normalized to Any).
+            return Type::any();
+        }
+        let ret = func(self);
+        self.seen.pop();
+        ret
+    }
+}

crates/ty_python_semantic/src/types/cyclic.rs

@@ -75,7 +75,7 @@ use crate::types::narrow::ClassInfoConstraintFunction;
 use crate::types::signatures::{CallableSignature, Signature};
 use crate::types::{
     BoundMethodType, CallableType, DynamicType, KnownClass, Type, TypeMapping, TypeRelation,
-    TypeVarInstance,
+    TypeVarInstance, TypeVisitor,
 };
 use crate::{Db, FxOrderSet, ModuleName, resolve_module};
 
@@ -545,10 +545,10 @@ impl<'db> FunctionLiteral<'db> {
         }))
     }
 
-    fn normalized(self, db: &'db dyn Db) -> Self {
+    fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
         let context = self
             .inherited_generic_context(db)
-            .map(|ctx| ctx.normalized(db));
+            .map(|ctx| ctx.normalized_impl(db, visitor));
         Self::new(db, self.last_definition(db), context)
     }
 }
@@ -819,12 +819,17 @@ impl<'db> FunctionType<'db> {
     }
 
     pub(crate) fn normalized(self, db: &'db dyn Db) -> Self {
+        let mut visitor = TypeVisitor::default();
+        self.normalized_impl(db, &mut visitor)
+    }
+
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
         let mappings: Box<_> = self
             .type_mappings(db)
             .iter()
-            .map(|mapping| mapping.normalized(db))
+            .map(|mapping| mapping.normalized_impl(db, visitor))
             .collect();
-        Self::new(db, self.literal(db).normalized(db), mappings)
+        Self::new(db, self.literal(db).normalized_impl(db, visitor), mappings)
     }
 }
 

crates/ty_python_semantic/src/types/function.rs

@@ -11,7 +11,7 @@ use crate::types::signatures::{Parameter, Parameters, Signature};
 use crate::types::tuple::{TupleSpec, TupleType};
 use crate::types::{
     KnownInstanceType, Type, TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarInstance,
-    TypeVarVariance, UnionType, declaration_type,
+    TypeVarVariance, TypeVisitor, UnionType, declaration_type,
 };
 use crate::{Db, FxOrderSet};
 
@@ -233,11 +233,11 @@ impl<'db> GenericContext<'db> {
         Specialization::new(db, self, expanded.into_boxed_slice(), None)
     }
 
-    pub(crate) fn normalized(self, db: &'db dyn Db) -> Self {
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
         let variables: FxOrderSet<_> = self
             .variables(db)
             .iter()
-            .map(|ty| ty.normalized(db))
+            .map(|ty| ty.normalized_impl(db, visitor))
             .collect();
         Self::new(db, variables)
     }
@@ -376,9 +376,15 @@ impl<'db> Specialization<'db> {
         Specialization::new(db, self.generic_context(db), types, None)
     }
 
-    pub(crate) fn normalized(self, db: &'db dyn Db) -> Self {
-        let types: Box<[_]> = self.types(db).iter().map(|ty| ty.normalized(db)).collect();
-        let tuple_inner = self.tuple_inner(db).and_then(|tuple| tuple.normalized(db));
+    pub(crate) fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
+        let types: Box<[_]> = self
+            .types(db)
+            .iter()
+            .map(|ty| ty.normalized_impl(db, visitor))
+            .collect();
+        let tuple_inner = self
+            .tuple_inner(db)
+            .and_then(|tuple| tuple.normalized_impl(db, visitor));
         Self::new(db, self.generic_context(db), types, tuple_inner)
     }
 
@@ -526,9 +532,17 @@ impl<'db> PartialSpecialization<'_, 'db> {
         }
     }
 
-    pub(crate) fn normalized(&self, db: &'db dyn Db) -> PartialSpecialization<'db, 'db> {
-        let generic_context = self.generic_context.normalized(db);
-        let types: Cow<_> = self.types.iter().map(|ty| ty.normalized(db)).collect();
+    pub(crate) fn normalized_impl(
+        &self,
+        db: &'db dyn Db,
+        visitor: &mut TypeVisitor<'db>,
+    ) -> PartialSpecialization<'db, 'db> {
+        let generic_context = self.generic_context.normalized_impl(db, visitor);
+        let types: Cow<_> = self
+            .types
+            .iter()
+            .map(|ty| ty.normalized_impl(db, visitor))
+            .collect();
 
         PartialSpecialization {
             generic_context,

crates/ty_python_semantic/src/types/generics.rs

@@ -6,7 +6,7 @@ use super::protocol_class::ProtocolInterface;
 use super::{ClassType, KnownClass, SubclassOfType, Type, TypeVarVariance};
 use crate::place::{Place, PlaceAndQualifiers};
 use crate::types::tuple::TupleType;
-use crate::types::{ClassLiteral, DynamicType, TypeMapping, TypeRelation, TypeVarInstance};
+use crate::types::{DynamicType, TypeMapping, TypeRelation, TypeVarInstance, TypeVisitor};
 use crate::{Db, FxOrderSet};
 
 pub(super) use synthesized_protocol::SynthesizedProtocolType;
@@ -41,7 +41,11 @@ impl<'db> Type<'db> {
         M: IntoIterator<Item = (&'a str, Type<'db>)>,
     {
         Self::ProtocolInstance(ProtocolInstanceType::synthesized(
-            SynthesizedProtocolType::new(db, ProtocolInterface::with_property_members(db, members)),
+            SynthesizedProtocolType::new(
+                db,
+                ProtocolInterface::with_property_members(db, members),
+                &mut TypeVisitor::default(),
+            ),
         ))
     }
 
@@ -80,8 +84,8 @@ impl<'db> NominalInstanceType<'db> {
         }
     }
 
-    pub(super) fn normalized(self, db: &'db dyn Db) -> Self {
-        Self::from_class(self.class.normalized(db))
+    pub(super) fn normalized_impl(self, db: &'db dyn Db, visitor: &mut TypeVisitor<'db>) -> Self {
+        Self::from_class(self.class.normalized_impl(db, visitor))
     }
 
     pub(super) fn materialize(self, db: &'db dyn Db, variance: TypeVarVariance) -> Self {
@@ -201,31 +205,30 @@ impl<'db> ProtocolInstanceType<'db> {
     ///
     /// See [`Type::normalized`] for more details.
     pub(super) fn normalized(self, db: &'db dyn Db) -> Type<'db> {
+        let mut visitor = TypeVisitor::default();
+        self.normalized_impl(db, &mut visitor)
+    }
+
+    /// Return a "normalized" version of this `Protocol` type.
+    ///
+    /// See [`Type::normalized`] for more details.
+    pub(super) fn normalized_impl(
+        self,
+        db: &'db dyn Db,
+        visitor: &mut TypeVisitor<'db>,
+    ) -> Type<'db> {
         let object = KnownClass::Object.to_instance(db);
         if object.satisfies_protocol(db, self, TypeRelation::Subtyping) {
             return object;
         }
         match self.inner {
             Protocol::FromClass(_) => Type::ProtocolInstance(Self::synthesized(
-                SynthesizedProtocolType::new(db, self.inner.interface(db)),
+                SynthesizedProtocolType::new(db, self.inner.interface(db), visitor),
             )),
             Protocol::Synthesized(_) => Type::ProtocolInstance(self),
         }
     }
 
-    /// Replace references to `class` with a self-reference marker
-    pub(super) fn replace_self_reference(self, db: &'db dyn Db, class: ClassLiteral<'db>) -> Self {
-        match self.inner {
-            Protocol::FromClass(class_type) if class_type.class_literal(db).0 == class => {
-                ProtocolInstanceType::synthesized(SynthesizedProtocolType::new(
-                    db,
-                    ProtocolInterface::SelfReference,
-                ))
-            }
-            _ => self,
-        }
-    }
-
     /// Return `true` if the types of any of the members match the closure passed in.
     pub(super) fn any_over_type(
         self,
@@ -352,7 +355,7 @@ impl<'db> Protocol<'db> {
 
 mod synthesized_protocol {
     use crate::types::protocol_class::ProtocolInterface;
-    use crate::types::{TypeMapping, TypeVarInstance, TypeVarVariance};
+    use crate::types::{TypeMapping, TypeVarInstance, TypeVarVariance, TypeVisitor};
     use crate::{Db, FxOrderSet};
 
     /// A "synthesized" protocol type that is dissociated from a class definition in source code.
@@ -370,8 +373,12 @@ mod synthesized_protocol {
     pub(in crate::types) struct SynthesizedProtocolType<'db>(ProtocolInterface<'db>);
 
     impl<'db> SynthesizedProtocolType<'db> {
-        pub(super) fn new(db: &'db dyn Db, interface: ProtocolInterface<'db>) -> Self {
-            Self(interface.normalized(db))
+        pub(super) fn new(
+            db: &'db dyn Db,
+            interface: ProtocolInterface<'db>,
+            visitor: &mut TypeVisitor<'db>,
+        ) -> Self {
+            Self(interface.normalized_impl(db, visitor))
         }
 
         pub(super) fn materialize(self, db: &'db dyn Db, variance: TypeVarVariance) -> Self {