Simplify program clause methods

chalk-engine/src/logic.rs

@@ -264,12 +264,7 @@ impl<I: Interner> Forest<I> {
                     },
                     universes: goal.universes,
                 };
-                let clauses = program_clauses_for_goal(
-                    program,
-                    &canon_domain_goal.canonical.value.environment,
-                    &canon_domain_goal.canonical.value.goal,
-                    &canon_domain_goal.canonical.binders,
-                );
+                let clauses = program_clauses_for_goal(program, &canon_domain_goal);
                 let (infer, subst, InEnvironment { environment, goal }) =
                     chalk_solve::infer::InferenceTable::from_canonical(
                         context.program().interner(),

chalk-recursive/src/solve.rs

@@ -202,12 +202,7 @@ trait SolveIterationHelpers<I: Interner>: SolveDatabase<I> {
         &self,
         canonical_goal: &UCanonical<InEnvironment<DomainGoal<I>>>,
     ) -> Result<Vec<ProgramClause<I>>, Floundered> {
-        program_clauses_for_goal(
-            self.db(),
-            &canonical_goal.canonical.value.environment,
-            &canonical_goal.canonical.value.goal,
-            &canonical_goal.canonical.binders,
-        )
+        program_clauses_for_goal(self.db(), &canonical_goal)
     }
 }
 

chalk-solve/src/clauses.rs

@@ -329,24 +329,22 @@ pub fn push_auto_trait_impls_generator_witness<I: Interner>(
 #[instrument(level = "debug", skip(db))]
 pub fn program_clauses_for_goal<'db, I: Interner>(
     db: &'db dyn RustIrDatabase<I>,
-    environment: &Environment<I>,
-    goal: &DomainGoal<I>,
-    binders: &CanonicalVarKinds<I>,
+    goal: &UCanonical<InEnvironment<DomainGoal<I>>>,
 ) -> Result<Vec<ProgramClause<I>>, Floundered> {
     let interner = db.interner();
 
     let custom_clauses = db.custom_clauses().into_iter();
-    let clauses_that_could_match = program_clauses_that_could_match(db, environment, goal, binders)
-        .map(|cl| cl.into_iter())?;
+    let clauses_that_could_match =
+        program_clauses_that_could_match(db, goal).map(|cl| cl.into_iter())?;
 
     let clauses: Vec<ProgramClause<I>> = custom_clauses
         .chain(clauses_that_could_match)
         .chain(
-            db.program_clauses_for_env(environment)
+            db.program_clauses_for_env(&goal.canonical.value.environment)
                 .iter(interner)
                 .cloned(),
         )
-        .filter(|c| c.could_match(interner, goal))
+        .filter(|c| c.could_match(interner, &goal.canonical.value.goal))
         .collect();
 
     debug!(?clauses);
@@ -358,21 +356,24 @@ pub fn program_clauses_for_goal<'db, I: Interner>(
 /// `goal`. This can be any superset of the correct set, but the
 /// more precise you can make it, the more efficient solving will
 /// be.
-#[instrument(level = "debug", skip(db, environment))]
+#[instrument(level = "debug", skip(db))]
 fn program_clauses_that_could_match<I: Interner>(
     db: &dyn RustIrDatabase<I>,
-    environment: &Environment<I>,
-    goal: &DomainGoal<I>,
-    // FIXME: These are the binders for `goal`. We're passing them separately
-    // because `goal` is not necessarily canonicalized: The recursive solver
-    // passes the canonical goal; the SLG solver instantiates the goal first.
-    // (See #568.)
-    binders: &CanonicalVarKinds<I>,
+    goal: &UCanonical<InEnvironment<DomainGoal<I>>>,
 ) -> Result<Vec<ProgramClause<I>>, Floundered> {
     let interner = db.interner();
     let mut clauses: Vec<ProgramClause<I>> = vec![];
     let builder = &mut ClauseBuilder::new(db, &mut clauses);
 
+    let UCanonical {
+        canonical:
+            Canonical {
+                value: InEnvironment { environment, goal },
+                binders,
+            },
+        universes: _,
+    } = goal;
+
     match goal {
         DomainGoal::Holds(WhereClause::Implemented(trait_ref)) => {
             let trait_id = trait_ref.trait_id;