From 14f554b453851a289966d1be81c44d4ffc6f18f9 Mon Sep 17 00:00:00 2001 From: Ibraheem Ahmed Date: Wed, 17 Dec 2025 21:05:54 -0500 Subject: [PATCH] clean up --- crates/ty_python_semantic/src/types.rs | 70 ++++++------------- crates/ty_python_semantic/src/types/cyclic.rs | 10 +-- .../ty_python_semantic/src/types/generics.rs | 4 +- 3 files changed, 27 insertions(+), 57 deletions(-) diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs index dfb47d921e..856ed3c4a5 100644 --- a/crates/ty_python_semantic/src/types.rs +++ b/crates/ty_python_semantic/src/types.rs @@ -3921,82 +3921,54 @@ impl<'db> Type<'db> { where F: FnMut(BoundTypeVarInstance<'db>, Type<'db>, TypeVarVariance, TypeContext<'db>), { - let try_visit = &mut |type_var, ty, variance, tcx| -> Result<(), ()> { - f(type_var, ty, variance, tcx); - Ok(()) - }; - - let _ = self.try_visit_specialization(db, tcx, try_visit); - } - - pub(crate) fn try_visit_specialization( - self, - db: &'db dyn Db, - tcx: TypeContext<'db>, - mut f: F, - ) -> Result<(), E> - where - F: FnMut( - BoundTypeVarInstance<'db>, - Type<'db>, - TypeVarVariance, - TypeContext<'db>, - ) -> Result<(), E>, - { - self.try_visit_specialization_impl( + self.visit_specialization_impl( db, tcx, TypeVarVariance::Covariant, &mut f, &SpecializationVisitor::default(), - ) + ); } - fn try_visit_specialization_impl( + fn visit_specialization_impl( self, db: &'db dyn Db, tcx: TypeContext<'db>, polarity: TypeVarVariance, - f: &mut dyn FnMut( - BoundTypeVarInstance<'db>, - Type<'db>, - TypeVarVariance, - TypeContext<'db>, - ) -> Result<(), E>, + f: &mut dyn FnMut(BoundTypeVarInstance<'db>, Type<'db>, TypeVarVariance, TypeContext<'db>), visitor: &SpecializationVisitor<'db>, - ) -> Result<(), E> { + ) { let instance = match self { Type::Union(union) => { for element in union.elements(db) { - element.try_visit_specialization_impl(db, tcx, polarity, f, visitor)?; + element.visit_specialization_impl(db, tcx, polarity, f, visitor); } - return Ok(()); + return; } Type::Intersection(intersection) => { for element in intersection.positive(db) { - element.try_visit_specialization_impl(db, tcx, polarity, f, visitor)?; + element.visit_specialization_impl(db, tcx, polarity, f, visitor); } - return Ok(()); + return; } Type::TypeAlias(alias) => { - visitor.try_visit(self, || { + visitor.visit(self, || { alias .value_type(db) - .try_visit_specialization_impl(db, tcx, polarity, f, visitor) - })?; - - return Ok(()); + .visit_specialization_impl(db, tcx, polarity, f, visitor); + }); + return; } Type::NominalInstance(instance) => instance, Type::ProtocolInstance(protocol) => match protocol.to_nominal_instance() { Some(instance) => instance, - None => return Ok(()), + None => return, }, - _ => return Ok(()), + _ => return, }; let (class_literal, Some(specialization)) = instance.class(db).class_literal(db) else { - return Ok(()); + return; }; let generic_context = specialization.generic_context(db); @@ -4017,14 +3989,12 @@ impl<'db> Type<'db> { let variance = type_var.variance_with_polarity(db, polarity); let narrowed_tcx = TypeContext::new(tcx_mappings.get(&type_var.identity(db)).copied()); - f(type_var, *ty, variance, narrowed_tcx)?; + f(type_var, *ty, variance, narrowed_tcx); - visitor.try_visit(*ty, || { - ty.try_visit_specialization_impl(db, narrowed_tcx, variance, f, visitor) - })?; + visitor.visit(*ty, || { + ty.visit_specialization_impl(db, narrowed_tcx, variance, f, visitor); + }); } - - Ok(()) } /// Return true if there is just a single inhabitant for this type. diff --git a/crates/ty_python_semantic/src/types/cyclic.rs b/crates/ty_python_semantic/src/types/cyclic.rs index 151222c721..6f179b1a72 100644 --- a/crates/ty_python_semantic/src/types/cyclic.rs +++ b/crates/ty_python_semantic/src/types/cyclic.rs @@ -122,14 +122,14 @@ impl CycleDetector { ret } - pub fn try_visit(&self, item: T, func: impl FnOnce() -> Result) -> Result { + pub fn try_visit(&self, item: T, func: impl FnOnce() -> Option) -> Option { if let Some(val) = self.cache.borrow().get(&item) { - return Ok(val.clone()); + return Some(val.clone()); } // We hit a cycle if !self.seen.borrow_mut().insert(item.clone()) { - return Ok(self.fallback.clone()); + return Some(self.fallback.clone()); } // Check depth limit to prevent stack overflow from recursive generic protocols @@ -137,7 +137,7 @@ impl CycleDetector { let current_depth = self.depth.get(); if current_depth >= MAX_RECURSION_DEPTH { self.seen.borrow_mut().pop(); - return Ok(self.fallback.clone()); + return Some(self.fallback.clone()); } self.depth.set(current_depth + 1); @@ -147,7 +147,7 @@ impl CycleDetector { self.seen.borrow_mut().pop(); self.cache.borrow_mut().insert(item, ret.clone()); - Ok(ret) + Some(ret) } } diff --git a/crates/ty_python_semantic/src/types/generics.rs b/crates/ty_python_semantic/src/types/generics.rs index 2c552c7e83..35eccd0dfe 100644 --- a/crates/ty_python_semantic/src/types/generics.rs +++ b/crates/ty_python_semantic/src/types/generics.rs @@ -1926,14 +1926,14 @@ impl<'db> SpecializationBuilder<'db> { builder.infer(formal_identity, formal)?; } - builder.type_mappings().clone() + builder.into_type_mappings() }; // Collect the actual type to which each formal type variable is mapped. let forward_type_mappings = { let mut builder = SpecializationBuilder::new(self.db, inferable); builder.infer(formal_identity, actual)?; - builder.type_mappings().clone() + builder.into_type_mappings() }; // If there are no forward type mappings, try the other direction.