Only prefer param-env candidates if they remain non-global after norm

Author: compiler-errors

compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs

@@ -19,7 +19,7 @@ use crate::delegate::SolverDelegate;
 use crate::solve::inspect::ProbeKind;
 use crate::solve::{
     BuiltinImplSource, CandidateSource, CanonicalResponse, Certainty, EvalCtxt, Goal, GoalSource,
-    MaybeCause, NoSolution, QueryResult,
+    MaybeCause, NoSolution, ParamEnvSource, QueryResult,
 };
 
 enum AliasBoundKind {
@@ -114,7 +114,6 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         assumption: I::Clause,
-        idx: usize,
     ) -> Result<Candidate<I>, NoSolution> {
         Self::fast_reject_assumption(ecx, goal, assumption)?;
 
@@ -130,7 +129,7 @@ where
         })
         .enter(|ecx| {
             Self::match_assumption(ecx, goal, assumption)?;
-            let source = ecx.characterize_param_env_assumption(goal.param_env, assumption, idx)?;
+            let source = ecx.characterize_param_env_assumption(goal.param_env, assumption)?;
             Ok(Candidate {
                 source,
                 result: ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)?,
@@ -553,8 +552,8 @@ where
         goal: Goal<I, G>,
         candidates: &mut Vec<Candidate<I>>,
     ) {
-        for (i, assumption) in goal.param_env.caller_bounds().iter().enumerate() {
-            candidates.extend(G::probe_and_consider_param_env_candidate(self, goal, assumption, i));
+        for assumption in goal.param_env.caller_bounds().iter() {
+            candidates.extend(G::probe_and_consider_param_env_candidate(self, goal, assumption));
         }
     }
 
@@ -934,20 +933,11 @@ where
                 // See `tests/ui/winnowing/norm-where-bound-gt-alias-bound.rs`.
                 let mut considered_candidates: Vec<_> = if candidates_from_env_and_bounds
                     .iter()
-                    .any(|c| {
-                        matches!(
-                            c.source,
-                            CandidateSource::ParamEnv(_) | CandidateSource::GlobalParamEnv(_)
-                        )
-                    }) {
+                    .any(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
+                {
                     candidates_from_env_and_bounds
                         .into_iter()
-                        .filter(|c| {
-                            matches!(
-                                c.source,
-                                CandidateSource::ParamEnv(_) | CandidateSource::GlobalParamEnv(_)
-                            )
-                        })
+                        .filter(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
                         .map(|c| c.result)
                         .collect()
                 } else {
@@ -976,12 +966,7 @@ where
                 // (for example, and ideally only) when proving item bounds for an impl.
                 let candidates_from_env: Vec<_> = candidates
                     .iter()
-                    .filter(|c| {
-                        matches!(
-                            c.source,
-                            CandidateSource::ParamEnv(_) | CandidateSource::GlobalParamEnv(_)
-                        )
-                    })
+                    .filter(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
                     .map(|c| c.result)
                     .collect();
                 if let Some(response) = self.try_merge_responses(&candidates_from_env) {
@@ -1009,17 +994,16 @@ where
         &mut self,
         param_env: I::ParamEnv,
         assumption: I::Clause,
-        idx: usize,
     ) -> Result<CandidateSource<I>, NoSolution> {
         // FIXME:
         if assumption.has_bound_vars() {
-            return Ok(CandidateSource::ParamEnv(idx));
+            return Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal));
         }
 
         match assumption.visit_with(&mut FindParamInClause { ecx: self, param_env }) {
             ControlFlow::Break(Err(NoSolution)) => Err(NoSolution),
-            ControlFlow::Break(Ok(())) => Ok(CandidateSource::ParamEnv(idx)),
-            ControlFlow::Continue(()) => Ok(CandidateSource::GlobalParamEnv(idx)),
+            ControlFlow::Break(Ok(())) => Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)),
+            ControlFlow::Continue(()) => Ok(CandidateSource::ParamEnv(ParamEnvSource::Global)),
         }
     }
 }

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -17,7 +17,7 @@ use crate::solve::assembly::{self, AllowInferenceConstraints, AssembleCandidates
 use crate::solve::inspect::ProbeKind;
 use crate::solve::{
     BuiltinImplSource, CandidateSource, Certainty, EvalCtxt, Goal, GoalSource, MaybeCause,
-    NoSolution,
+    NoSolution, ParamEnvSource,
 };
 
 impl<D, I> assembly::GoalKind<D> for TraitPredicate<I>
@@ -1284,17 +1284,13 @@ where
 
         // If there are non-global where-bounds, prefer where-bounds
         // (including global ones) over everything else.
-        let has_non_global_where_bounds =
-            candidates.iter().any(|c| matches!(c.source, CandidateSource::ParamEnv(_)));
+        let has_non_global_where_bounds = candidates
+            .iter()
+            .any(|c| matches!(c.source, CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)));
         if has_non_global_where_bounds {
             let where_bounds: Vec<_> = candidates
                 .iter()
-                .filter(|c| {
-                    matches!(
-                        c.source,
-                        CandidateSource::ParamEnv(_) | CandidateSource::GlobalParamEnv(_)
-                    )
-                })
+                .filter(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
                 .map(|c| c.result)
                 .collect();
             return if let Some(response) = self.try_merge_responses(&where_bounds) {
@@ -1323,13 +1319,16 @@ where
         // is still reported as being proven-via the param-env so that rigid projections
         // operate correctly. Otherwise, drop all global where-bounds before merging the
         // remaining candidates.
-        let proven_via =
-            if candidates.iter().all(|c| matches!(c.source, CandidateSource::GlobalParamEnv(_))) {
-                TraitGoalProvenVia::ParamEnv
-            } else {
-                candidates.retain(|c| !matches!(c.source, CandidateSource::GlobalParamEnv(_)));
-                TraitGoalProvenVia::Misc
-            };
+        let proven_via = if candidates
+            .iter()
+            .all(|c| matches!(c.source, CandidateSource::ParamEnv(ParamEnvSource::Global)))
+        {
+            TraitGoalProvenVia::ParamEnv
+        } else {
+            candidates
+                .retain(|c| !matches!(c.source, CandidateSource::ParamEnv(ParamEnvSource::Global)));
+            TraitGoalProvenVia::Misc
+        };
 
         let all_candidates: Vec<_> = candidates.into_iter().map(|c| c.result).collect();
         if let Some(response) = self.try_merge_responses(&all_candidates) {

compiler/rustc_trait_selection/src/solve/select.rs

@@ -171,7 +171,6 @@ fn to_selection<'tcx>(
             }
             CandidateSource::BuiltinImpl(builtin) => ImplSource::Builtin(builtin, nested),
             CandidateSource::ParamEnv(_) | CandidateSource::AliasBound => ImplSource::Param(nested),
-            CandidateSource::GlobalParamEnv(_) => ImplSource::Param(nested),
             CandidateSource::CoherenceUnknowable => {
                 span_bug!(span, "didn't expect to select an unknowable candidate")
             }

compiler/rustc_type_ir/src/solve/mod.rs

@@ -160,9 +160,7 @@ pub enum CandidateSource<I: Interner> {
     ///     (x.clone(), x)
     /// }
     /// ```
-    ParamEnv(usize),
-    /// UWU
-    GlobalParamEnv(usize),
+    ParamEnv(ParamEnvSource),
     /// If the self type is an alias type, e.g. an opaque type or a projection,
     /// we know the bounds on that alias to hold even without knowing its concrete
     /// underlying type.
@@ -191,6 +189,14 @@ pub enum CandidateSource<I: Interner> {
     CoherenceUnknowable,
 }
 
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
+pub enum ParamEnvSource {
+    /// Preferred eagerly.
+    NonGlobal,
+    // Not considered unless there are non-global param-env candidates too.
+    Global,
+}
+
 #[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
 #[cfg_attr(
     feature = "nightly",

tests/ui/traits/next-solver/global-param-env-after-norm.rs

@@ -0,0 +1,15 @@
+//@ check-pass
+//@ compile-flags: -Znext-solver
+
+struct NewSolver;
+struct OldSolver;
+
+fn foo<T>()
+where
+    T: Iterator<Item = NewSolver>,
+    OldSolver: Into<T::Item>,
+{
+    let x: OldSolver = OldSolver.into();
+}
+
+fn main() {}