fix recursive typevar display

Author: carljm

crates/ty_python_semantic/src/semantic_index/definition.rs

@@ -702,7 +702,7 @@ impl DefinitionKind<'_> {
         )
     }
 
-    pub(crate) fn into_typevar(&self) -> Option<&AstNodeRef<ast::TypeParamTypeVar>> {
+    pub(crate) fn as_typevar(&self) -> Option<&AstNodeRef<ast::TypeParamTypeVar>> {
         match self {
             DefinitionKind::TypeVar(type_var) => Some(type_var),
             _ => None,

crates/ty_python_semantic/src/types.rs

@@ -7004,7 +7004,7 @@ impl<'db> TypeVarInstance<'db> {
     fn lazy_bound(self, db: &'db dyn Db) -> Option<TypeVarBoundOrConstraints<'db>> {
         let definition = self.definition(db)?;
         let module = parsed_module(db, definition.file(db)).load(db);
-        let typevar_node = definition.kind(db).into_typevar()?.node(&module);
+        let typevar_node = definition.kind(db).as_typevar()?.node(&module);
         let ty = definition_expression_type(db, definition, typevar_node.bound.as_ref()?);
         Some(TypeVarBoundOrConstraints::UpperBound(ty))
     }
@@ -7013,7 +7013,7 @@ impl<'db> TypeVarInstance<'db> {
     fn lazy_constraints(self, db: &'db dyn Db) -> Option<TypeVarBoundOrConstraints<'db>> {
         let definition = self.definition(db)?;
         let module = parsed_module(db, definition.file(db)).load(db);
-        let typevar_node = definition.kind(db).into_typevar()?.node(&module);
+        let typevar_node = definition.kind(db).as_typevar()?.node(&module);
         let ty = definition_expression_type(db, definition, typevar_node.bound.as_ref()?)
             .into_union()?;
         Some(TypeVarBoundOrConstraints::Constraints(ty))
@@ -7023,7 +7023,7 @@ impl<'db> TypeVarInstance<'db> {
     fn lazy_default(self, db: &'db dyn Db) -> Option<Type<'db>> {
         let definition = self.definition(db)?;
         let module = parsed_module(db, definition.file(db)).load(db);
-        let typevar_node = definition.kind(db).into_typevar()?.node(&module);
+        let typevar_node = definition.kind(db).as_typevar()?.node(&module);
         Some(definition_expression_type(
             db,
             definition,

crates/ty_python_semantic/src/types/class.rs

@@ -4558,7 +4558,7 @@ impl KnownClass {
                         Some(containing_assignment),
                         bound_or_constraint,
                         variance,
-                        default.map(|ty| TypeVarDefault::Eager(ty)),
+                        default.map(TypeVarDefault::Eager),
                         TypeVarKind::Legacy,
                     ),
                 )));

crates/ty_python_semantic/src/types/cyclic.rs

@@ -38,7 +38,6 @@ impl Default for TypeTransformer<'_> {
     }
 }
 
-pub(crate) type TypeVisitor<'db> = CycleDetector<Type<'db>, bool>;
 pub(crate) type PairVisitor<'db> = CycleDetector<(Type<'db>, Type<'db>), bool>;
 
 #[derive(Debug)]

crates/ty_python_semantic/src/types/display.rs

@@ -433,17 +433,21 @@ impl Display for DisplayTypeVarInstance<'_> {
         display_quoted_string(self.typevar.name(self.db)).fmt(f)?;
         match self.typevar.bound_or_constraints(self.db) {
             Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
-                write!(f, ", bound={}", bound.display(self.db))?;
+                write!(f, ", bound={}", bound.normalized(self.db).display(self.db))?;
             }
             Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
                 for constraint in constraints.iter(self.db) {
-                    write!(f, ", {}", constraint.display(self.db))?;
+                    write!(f, ", {}", constraint.normalized(self.db).display(self.db))?;
                 }
             }
             None => {}
         }
         if let Some(default_type) = self.typevar.default_type(self.db) {
-            write!(f, ", default={}", default_type.display(self.db))?;
+            write!(
+                f,
+                ", default={}",
+                default_type.normalized(self.db).display(self.db)
+            )?;
         }
         Ok(())
     }
@@ -473,22 +477,26 @@ impl Display for DisplayBoundTypeVarInstance<'_> {
         f.write_str(typevar.name(self.db))?;
         match typevar.bound_or_constraints(self.db) {
             Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
-                write!(f, ": {}", bound.display(self.db))?;
+                write!(f, ": {}", bound.normalized(self.db).display(self.db))?;
             }
             Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
                 f.write_str(": (")?;
                 for (idx, constraint) in constraints.iter(self.db).enumerate() {
                     if idx > 0 {
                         f.write_str(", ")?;
                     }
-                    constraint.display(self.db).fmt(f)?;
+                    constraint.normalized(self.db).display(self.db).fmt(f)?;
                 }
                 f.write_char(')')?;
             }
             None => {}
         }
         if let Some(default_type) = self.bound_typevar.default_type(self.db) {
-            write!(f, " = {}", default_type.display(self.db))?;
+            write!(
+                f,
+                " = {}",
+                default_type.normalized(self.db).display(self.db)
+            )?;
         }
         Ok(())
     }

crates/ty_python_semantic/src/types/infer.rs

@@ -3464,7 +3464,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 self.infer_type_expression(expr);
             }
             None => {}
-        };
+        }
         self.infer_optional_type_expression(default.as_deref());
     }