Make program_clauses_for_env add the actual env clauses as well

The `program_clauses_for_env` function only added elaborated clauses, not the
actual clauses from the environment. Instead, both solvers added the clauses
afterwards. It seems easier to just add the direct clauses as well.

Author: flodiebold

chalk-solve/src/clauses.rs

@@ -415,6 +415,8 @@ fn program_clauses_for_env<'db, I: Interner>(
     environment: &Environment<I>,
     clauses: &mut Vec<ProgramClause<I>>,
 ) {
+    clauses.extend(environment.clauses.iter().cloned());
+
     let mut last_round = FxHashSet::default();
     elaborate_env_clauses(
         db,

chalk-solve/src/recursive/mod.rs

@@ -11,7 +11,6 @@ use chalk_engine::{
     context::Floundered,
     fallible::{Fallible, NoSolution},
 };
-use chalk_ir::could_match::CouldMatch;
 use clauses::program_clauses_for_goal;
 use rustc_hash::FxHashMap;
 
@@ -253,19 +252,6 @@ impl<'me, I: Interner> Solver<'me, I> {
                     // clauses. We try each approach in turn:
 
                     let InEnvironment { environment, goal } = &canonical_goal.canonical.value;
-                    let (env_solution, env_prio) = {
-                        debug_heading!("env_clauses");
-
-                        // TODO use code from clauses module
-                        let env_clauses: Vec<_> = environment
-                            .clauses
-                            .iter()
-                            .filter(|&clause| clause.could_match(self.program.interner(), goal))
-                            .cloned()
-                            .collect();
-                        self.solve_from_clauses(&canonical_goal, env_clauses, minimums)
-                    };
-                    debug!("env_solution={:?}", env_solution);
 
                     let (prog_solution, prog_prio) = {
                         debug_heading!("prog_clauses");
@@ -282,18 +268,7 @@ impl<'me, I: Interner> Solver<'me, I> {
                     };
                     debug!("prog_solution={:?}", prog_solution);
 
-                    // Now that we have all the outcomes, we attempt to combine
-                    // them. Here, we apply a heuristic (also found in rustc): if we
-                    // have possible solutions via both the environment *and* the
-                    // program, we favor the environment; this only impacts type
-                    // inference. The idea is that the assumptions you've explicitly
-                    // made in a given context are more likely to be relevant than
-                    // general `impl`s.
-                    // TODO can we combine this logic with the priorization logic?
-                    (
-                        env_solution.merge_with(prog_solution, |env, prog| env.favor_over(prog)),
-                        prog_prio & env_prio, // FIXME
-                    )
+                    (prog_solution, prog_prio)
                 }
 
                 _ => {

chalk-solve/src/solve.rs

@@ -92,32 +92,6 @@ impl<I: Interner> Solution<I> {
         Solution::Ambig(guidance)
     }
 
-    /// There are multiple candidate solutions, which may or may not agree on
-    /// the values for existential variables; attempt to combine them, while
-    /// favoring `self` for the purposes of giving suggestions to type
-    /// inference. This is used in particular to favor the `where` clause
-    /// environment over `impl`s in guiding inference in ambiguous situations.
-    ///
-    /// It should always be the case that `x.favor_over(y)` is at least as
-    /// informative as `x.combine(y)`, in terms of guidance to type inference.
-    pub(crate) fn favor_over(self, other: Solution<I>) -> Solution<I> {
-        use self::Guidance::*;
-
-        if self == other {
-            return self;
-        }
-
-        debug!("favor_over {} with {}", self, other);
-
-        // Otherwise, always downgrade to Ambig:
-
-        let guidance = match (self.into_guidance(), other.into_guidance()) {
-            (Definite(subst), _) | (Suggested(subst), _) => Suggested(subst),
-            _ => Unknown,
-        };
-        Solution::Ambig(guidance)
-    }
-
     /// View this solution purely in terms of type inference guidance
     pub(crate) fn into_guidance(self) -> Guidance<I> {
         match self {

chalk-solve/src/solve/slg.rs

@@ -15,7 +15,7 @@ use chalk_engine::{CompleteAnswer, ExClause, Literal};
 use chalk_ir::cast::Cast;
 use chalk_ir::cast::Caster;
 use chalk_ir::could_match::CouldMatch;
-use chalk_ir::interner::Interner;
+use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::*;
 
 use std::fmt::Debug;
@@ -177,18 +177,9 @@ impl<'me, I: Interner> context::ContextOps<SlgContext<I>> for SlgContextOps<'me,
         goal: &DomainGoal<I>,
         _infer: &mut TruncatingInferenceTable<I>,
     ) -> Result<Vec<ProgramClause<I>>, Floundered> {
-        let interner = self.program.interner();
-        let mut clauses: Vec<_> =
+        let clauses: Vec<_> =
             program_clauses_for_goal(self.program, environment, goal).ok_or(Floundered)?;
 
-        clauses.extend(
-            environment
-                .clauses
-                .iter(interner)
-                .filter(|&env_clause| env_clause.could_match(interner, goal))
-                .cloned(),
-        );
-
         Ok(clauses)
     }