Don't flounder on int/float vars in recursive solver either

To achieve this, we pass the binders. It's slightly hacky; it would be nicer if
we could just pass the `Canonical`, but that would require the SLG solver to
pass a canonicalized goal, which it doesn't currently. So passing the binders
separately feels slightly less bad.

Author: flodiebold

chalk-engine/src/slg.rs

@@ -98,7 +98,12 @@ impl<'me, I: Interner> context::ContextOps<I, SlgContext<I>> for SlgContextOps<'
         goal: &DomainGoal<I>,
         _infer: &mut TruncatingInferenceTable<I>,
     ) -> Result<Vec<ProgramClause<I>>, Floundered> {
-        let clauses: Vec<_> = program_clauses_for_goal(self.program, environment, goal)?;
+        let clauses: Vec<_> = program_clauses_for_goal(
+            self.program,
+            environment,
+            goal,
+            &CanonicalVarKinds::empty(self.program.interner()),
+        )?;
 
         Ok(clauses)
     }

chalk-ir/src/lib.rs

@@ -395,9 +395,15 @@ impl<I: Interner> Ty<I> {
     }
 
     /// Returns true if this is a `BoundVar` or an `InferenceVar` of `TyKind::General`.
-    pub fn is_general_var(&self, interner: &I) -> bool {
+    pub fn is_general_var(&self, interner: &I, binders: &CanonicalVarKinds<I>) -> bool {
         match self.data(interner) {
-            TyData::BoundVar(_) | TyData::InferenceVar(_, TyKind::General) => true,
+            TyData::BoundVar(bv)
+                if bv.debruijn == DebruijnIndex::INNERMOST
+                    && binders.at(interner, bv.index).kind == VariableKind::Ty(TyKind::General) =>
+            {
+                true
+            }
+            TyData::InferenceVar(_, TyKind::General) => true,
             _ => false,
         }
     }

chalk-recursive/src/solve.rs

@@ -69,12 +69,10 @@ pub(super) trait SolveIteration<I: Interner>: SolveDatabase<I> {
                 // or from the lowered program, which includes fallback
                 // clauses. We try each approach in turn:
 
-                let InEnvironment { environment, goal } = &canonical_goal.canonical.value;
-
                 let (prog_solution, prog_prio) = {
                     debug_span!("prog_clauses");
 
-                    let prog_clauses = self.program_clauses_for_goal(environment, &goal);
+                    let prog_clauses = self.program_clauses_for_goal(&canonical_goal);
                     match prog_clauses {
                         Ok(clauses) => self.solve_from_clauses(&canonical_goal, clauses, minimums),
                         Err(Floundered) => {
@@ -202,10 +200,14 @@ trait SolveIterationHelpers<I: Interner>: SolveDatabase<I> {
 
     fn program_clauses_for_goal(
         &self,
-        environment: &Environment<I>,
-        goal: &DomainGoal<I>,
+        canonical_goal: &UCanonical<InEnvironment<DomainGoal<I>>>,
     ) -> Result<Vec<ProgramClause<I>>, Floundered> {
-        program_clauses_for_goal(self.db(), environment, goal)
+        program_clauses_for_goal(
+            self.db(),
+            &canonical_goal.canonical.value.environment,
+            &canonical_goal.canonical.value.goal,
+            &canonical_goal.canonical.binders,
+        )
     }
 }
 

chalk-solve/src/clauses.rs

@@ -176,12 +176,13 @@ pub fn program_clauses_for_goal<'db, I: Interner>(
     db: &'db dyn RustIrDatabase<I>,
     environment: &Environment<I>,
     goal: &DomainGoal<I>,
+    binders: &CanonicalVarKinds<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).map(|cl| cl.into_iter())?;
+    let clauses_that_could_match = program_clauses_that_could_match(db, environment, goal, binders)
+        .map(|cl| cl.into_iter())?;
 
     let clauses: Vec<ProgramClause<I>> = custom_clauses
         .chain(clauses_that_could_match)
@@ -207,6 +208,7 @@ fn program_clauses_that_could_match<I: Interner>(
     db: &dyn RustIrDatabase<I>,
     environment: &Environment<I>,
     goal: &DomainGoal<I>,
+    binders: &CanonicalVarKinds<I>,
 ) -> Result<Vec<ProgramClause<I>>, Floundered> {
     let interner = db.interner();
     let mut clauses: Vec<ProgramClause<I>> = vec![];
@@ -225,7 +227,7 @@ fn program_clauses_that_could_match<I: Interner>(
                     if trait_datum.is_auto_trait() {
                         push_auto_trait_impls_opaque(builder, trait_id, opaque_ty.opaque_ty_id)
                     }
-                } else if self_ty.is_general_var(interner) {
+                } else if self_ty.is_general_var(interner, binders) {
                     return Err(Floundered);
                 }
             }
@@ -386,7 +388,9 @@ fn program_clauses_that_could_match<I: Interner>(
                 // Flounder if the self-type is unknown and the trait is non-enumerable.
                 //
                 // e.g., Normalize(<?X as Iterator>::Item = u32)
-                if (self_ty.is_general_var(interner)) && trait_datum.is_non_enumerable_trait() {
+                if (self_ty.is_general_var(interner, binders))
+                    && trait_datum.is_non_enumerable_trait()
+                {
                     return Err(Floundered);
                 }