Add associated_ty_matches to Chalk db to avoid computing RPITIT associated types eagerly

Author: compiler-errors

chalk-integration/src/db.rs

@@ -99,6 +99,14 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
         self.program_ir().unwrap().impl_datum(id)
     }
 
+    fn associated_ty_matches(
+        &self,
+        trait_item: AssocTypeId<ChalkIr>,
+        impl_item: AssociatedTyValueId<ChalkIr>,
+    ) -> bool {
+        self.program_ir().unwrap().associated_ty_values[&impl_item].associated_ty_id == trait_item
+    }
+
     fn associated_ty_value(
         &self,
         id: AssociatedTyValueId<ChalkIr>,

chalk-integration/src/program.rs

@@ -398,6 +398,14 @@ impl RustIrDatabase<ChalkIr> for Program {
         self.impl_data[&id].clone()
     }
 
+    fn associated_ty_matches(
+        &self,
+        trait_item: AssocTypeId<ChalkIr>,
+        impl_item: AssociatedTyValueId<ChalkIr>,
+    ) -> bool {
+        self.associated_ty_values[&impl_item].associated_ty_id == trait_item
+    }
+
     fn associated_ty_value(
         &self,
         id: AssociatedTyValueId<ChalkIr>,

chalk-solve/src/clauses.rs

@@ -639,6 +639,7 @@ pub fn program_clauses_that_could_match<I: Interner>(
                     builder,
                     environment,
                     trait_id,
+                    proj.associated_ty_id,
                     trait_parameters,
                     binders,
                 );
@@ -749,6 +750,7 @@ fn push_program_clauses_for_associated_type_values_in_impls_of<I: Interner>(
     builder: &mut ClauseBuilder<'_, I>,
     environment: &Environment<I>,
     trait_id: TraitId<I>,
+    assoc_id: AssocTypeId<I>,
     trait_parameters: &[GenericArg<I>],
     binders: &CanonicalVarKinds<I>,
 ) {
@@ -764,9 +766,14 @@ fn push_program_clauses_for_associated_type_values_in_impls_of<I: Interner>(
         debug!(?impl_id);
 
         for &atv_id in &impl_datum.associated_ty_value_ids {
-            let atv = builder.db.associated_ty_value(atv_id);
-            debug!(?atv_id, ?atv);
-            atv.to_program_clauses(builder, environment);
+            // Avoid unnecessarily computing the type of associated types that do not
+            // match this goal. This is to ensure that we have no cycles when normalizing
+            // in RPITIT inference.
+            if builder.db.associated_ty_matches(assoc_id, atv_id) {
+                let atv = builder.db.associated_ty_value(atv_id);
+                debug!(?atv_id, ?atv);
+                atv.to_program_clauses(builder, environment);
+            }
         }
     }
 }

chalk-solve/src/display/stub.rs

@@ -116,6 +116,14 @@ impl<I: Interner, DB: RustIrDatabase<I>> RustIrDatabase<I> for StubWrapper<'_, D
         unreachable!("impl items should never be stubbed")
     }
 
+    fn associated_ty_matches(
+        &self,
+        _trait_item: chalk_ir::AssocTypeId<I>,
+        _impl_item: crate::rust_ir::AssociatedTyValueId<I>,
+    ) -> bool {
+        unreachable!("associated type values should never be stubbed")
+    }
+
     fn associated_ty_value(
         &self,
         _id: crate::rust_ir::AssociatedTyValueId<I>,

chalk-solve/src/lib.rs

@@ -76,6 +76,14 @@ pub trait RustIrDatabase<I: Interner>: Debug {
     /// Returns the datum for the impl with the given id.
     fn impl_datum(&self, impl_id: ImplId<I>) -> Arc<ImplDatum<I>>;
 
+    /// Returns if the trait item for `AssocTypeId` matches the impl item for
+    /// `AssociatedTyValueId`.
+    fn associated_ty_matches(
+        &self,
+        trait_item: AssocTypeId<I>,
+        impl_item: AssociatedTyValueId<I>,
+    ) -> bool;
+
     /// Returns the `AssociatedTyValue` with the given id.
     fn associated_ty_value(&self, id: AssociatedTyValueId<I>) -> Arc<AssociatedTyValue<I>>;
 

chalk-solve/src/logging_db.rs

@@ -171,6 +171,14 @@ where
         self.ws.db().hidden_opaque_type(id)
     }
 
+    fn associated_ty_matches(
+        &self,
+        trait_item: AssocTypeId<I>,
+        impl_item: AssociatedTyValueId<I>,
+    ) -> bool {
+        self.ws.db().associated_ty_matches(trait_item, impl_item)
+    }
+
     fn associated_ty_value(
         &self,
         id: crate::rust_ir::AssociatedTyValueId<I>,
@@ -434,6 +442,14 @@ where
         self.db.impl_datum(impl_id)
     }
 
+    fn associated_ty_matches(
+        &self,
+        trait_item: AssocTypeId<I>,
+        impl_item: AssociatedTyValueId<I>,
+    ) -> bool {
+        self.db.associated_ty_matches(trait_item, impl_item)
+    }
+
     fn associated_ty_value(
         &self,
         id: crate::rust_ir::AssociatedTyValueId<I>,

tests/display/unique_names.rs

@@ -94,6 +94,13 @@ where
     ) -> std::sync::Arc<chalk_solve::rust_ir::ImplDatum<I>> {
         self.db.impl_datum(impl_id)
     }
+    fn associated_ty_matches(
+        &self,
+        trait_item: chalk_ir::AssocTypeId<I>,
+        impl_item: chalk_solve::rust_ir::AssociatedTyValueId<I>,
+    ) -> bool {
+        self.db.associated_ty_matches(trait_item, impl_item)
+    }
     fn associated_ty_value(
         &self,
         id: chalk_solve::rust_ir::AssociatedTyValueId<I>,

tests/integration/panic.rs

@@ -118,6 +118,14 @@ impl RustIrDatabase<ChalkIr> for MockDatabase {
         })
     }
 
+    fn associated_ty_matches(
+        &self,
+        _trait_item: AssocTypeId<ChalkIr>,
+        _impl_item: AssociatedTyValueId<ChalkIr>,
+    ) -> bool {
+        unimplemented!()
+    }
+
     fn associated_ty_value(
         &self,
         id: AssociatedTyValueId<ChalkIr>,