tis but a yeeet

Author: lcnr

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

@@ -8,6 +8,7 @@ use std::ops::ControlFlow;
 use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::TraitSolverLangItem;
+use rustc_type_ir::search_graph::CandidateUsages;
 use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::{
     self as ty, Interner, TypeFlags, TypeFoldable, TypeSuperVisitable, TypeVisitable,
@@ -33,10 +34,11 @@ enum AliasBoundKind {
 ///
 /// It consists of both the `source`, which describes how that goal would be proven,
 /// and the `result` when using the given `source`.
-#[derive_where(Clone, Debug; I: Interner)]
+#[derive_where(Debug; I: Interner)]
 pub(super) struct Candidate<I: Interner> {
     pub(super) source: CandidateSource<I>,
     pub(super) result: CanonicalResponse<I>,
+    pub(super) candidate_usages: CandidateUsages,
 }
 
 /// Methods used to assemble candidates for either trait or projection goals.
@@ -116,8 +118,11 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         assumption: I::Clause,
-    ) -> Result<Candidate<I>, NoSolution> {
-        Self::fast_reject_assumption(ecx, goal, assumption)?;
+    ) -> Result<Candidate<I>, CandidateUsages> {
+        match Self::fast_reject_assumption(ecx, goal, assumption) {
+            Ok(()) => {}
+            Err(NoSolution) => return Err(CandidateUsages::default()),
+        }
 
         // Dealing with `ParamEnv` candidates is a bit of a mess as we need to lazily
         // check whether the candidate is global while considering normalization.
@@ -126,18 +131,23 @@ where
         // in `probe` even if the candidate does not apply before we get there. We handle this
         // by using a `Cell` here. We only ever write into it inside of `match_assumption`.
         let source = Cell::new(CandidateSource::ParamEnv(ParamEnvSource::Global));
-        ecx.probe(|result: &QueryResult<I>| inspect::ProbeKind::TraitCandidate {
-            source: source.get(),
-            result: *result,
-        })
-        .enter(|ecx| {
-            Self::match_assumption(ecx, goal, assumption, |ecx| {
-                ecx.try_evaluate_added_goals()?;
-                source.set(ecx.characterize_param_env_assumption(goal.param_env, assumption)?);
-                ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+        let (result, candidate_usages) = ecx
+            .probe(|result: &QueryResult<I>| inspect::ProbeKind::TraitCandidate {
+                source: source.get(),
+                result: *result,
             })
-        })
-        .map(|result| Candidate { source: source.get(), result })
+            .enter_unique_candidate(|ecx| {
+                Self::match_assumption(ecx, goal, assumption, |ecx| {
+                    ecx.try_evaluate_added_goals()?;
+                    source.set(ecx.characterize_param_env_assumption(goal.param_env, assumption)?);
+                    ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+                })
+            });
+
+        match result {
+            Ok(result) => Ok(Candidate { source: source.get(), result, candidate_usages }),
+            Err(NoSolution) => Err(candidate_usages),
+        }
     }
 
     /// Try equating an assumption predicate against a goal's predicate. If it
@@ -355,6 +365,12 @@ pub(super) enum AssembleCandidatesFrom {
     EnvAndBounds,
 }
 
+#[derive_where(Debug, Default; I: Interner)]
+pub(super) struct Candidates<I: Interner> {
+    pub applicable: Vec<Candidate<I>>,
+    pub not_applicable_param_env: Vec<CandidateUsages>,
+}
+
 impl<D, I> EvalCtxt<'_, D>
 where
     D: SolverDelegate<Interner = I>,
@@ -364,16 +380,18 @@ where
         &mut self,
         goal: Goal<I, G>,
         assemble_from: AssembleCandidatesFrom,
-    ) -> Vec<Candidate<I>> {
+    ) -> Candidates<I> {
+        let mut candidates = Candidates::default();
         let Ok(normalized_self_ty) =
             self.structurally_normalize_ty(goal.param_env, goal.predicate.self_ty())
         else {
-            return vec![];
+            return candidates;
         };
 
         if normalized_self_ty.is_ty_var() {
             debug!("self type has been normalized to infer");
-            return self.forced_ambiguity(MaybeCause::Ambiguity).into_iter().collect();
+            candidates.applicable.extend(self.forced_ambiguity(MaybeCause::Ambiguity));
+            return candidates;
         }
 
         let goal: Goal<I, G> = goal
@@ -382,12 +400,11 @@ where
         // normalizing the self type as well, since type variables are not uniquified.
         let goal = self.resolve_vars_if_possible(goal);
 
-        let mut candidates = vec![];
-
         if let TypingMode::Coherence = self.typing_mode()
             && let Ok(candidate) = self.consider_coherence_unknowable_candidate(goal)
         {
-            return vec![candidate];
+            candidates.applicable.push(candidate);
+            return candidates;
         }
 
         self.assemble_alias_bound_candidates(goal, &mut candidates);
@@ -408,7 +425,7 @@ where
                 // to worry about causing major performance regressions when doing so.
                 // See trait-system-refactor-initiative#226 for some ideas here.
                 if TypingMode::Coherence == self.typing_mode()
-                    || !candidates.iter().any(|c| {
+                    || !candidates.applicable.iter().any(|c| {
                         matches!(
                             c.source,
                             CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)
@@ -445,7 +462,7 @@ where
     fn assemble_impl_candidates<G: GoalKind<D>>(
         &mut self,
         goal: Goal<I, G>,
-        candidates: &mut Vec<Candidate<I>>,
+        candidates: &mut Candidates<I>,
     ) {
         let cx = self.cx();
         cx.for_each_relevant_impl(
@@ -460,7 +477,7 @@ where
                 }
 
                 match G::consider_impl_candidate(self, goal, impl_def_id) {
-                    Ok(candidate) => candidates.push(candidate),
+                    Ok(candidate) => candidates.applicable.push(candidate),
                     Err(NoSolution) => (),
                 }
             },
@@ -471,7 +488,7 @@ where
     fn assemble_builtin_impl_candidates<G: GoalKind<D>>(
         &mut self,
         goal: Goal<I, G>,
-        candidates: &mut Vec<Candidate<I>>,
+        candidates: &mut Candidates<I>,
     ) {
         let cx = self.cx();
         let trait_def_id = goal.predicate.trait_def_id(cx);
@@ -570,31 +587,36 @@ where
             }
         };
 
-        candidates.extend(result);
+        candidates.applicable.extend(result);
 
         // There may be multiple unsize candidates for a trait with several supertraits:
         // `trait Foo: Bar<A> + Bar<B>` and `dyn Foo: Unsize<dyn Bar<_>>`
         if cx.is_lang_item(trait_def_id, TraitSolverLangItem::Unsize) {
-            candidates.extend(G::consider_structural_builtin_unsize_candidates(self, goal));
+            candidates
+                .applicable
+                .extend(G::consider_structural_builtin_unsize_candidates(self, goal));
         }
     }
 
     #[instrument(level = "trace", skip_all)]
     fn assemble_param_env_candidates<G: GoalKind<D>>(
         &mut self,
         goal: Goal<I, G>,
-        candidates: &mut Vec<Candidate<I>>,
+        candidates: &mut Candidates<I>,
     ) {
         for assumption in goal.param_env.caller_bounds().iter() {
-            candidates.extend(G::probe_and_consider_param_env_candidate(self, goal, assumption));
+            match G::probe_and_consider_param_env_candidate(self, goal, assumption) {
+                Ok(candidate) => candidates.applicable.push(candidate),
+                Err(candidate_usages) => candidates.not_applicable_param_env.push(candidate_usages),
+            }
         }
     }
 
     #[instrument(level = "trace", skip_all)]
     fn assemble_alias_bound_candidates<G: GoalKind<D>>(
         &mut self,
         goal: Goal<I, G>,
-        candidates: &mut Vec<Candidate<I>>,
+        candidates: &mut Candidates<I>,
     ) {
         let () = self.probe(|_| ProbeKind::NormalizedSelfTyAssembly).enter(|ecx| {
             ecx.assemble_alias_bound_candidates_recur(
@@ -619,7 +641,7 @@ where
         &mut self,
         self_ty: I::Ty,
         goal: Goal<I, G>,
-        candidates: &mut Vec<Candidate<I>>,
+        candidates: &mut Candidates<I>,
         consider_self_bounds: AliasBoundKind,
     ) {
         let (kind, alias_ty) = match self_ty.kind() {
@@ -661,7 +683,11 @@ where
                 if let Ok(result) =
                     self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
                 {
-                    candidates.push(Candidate { source: CandidateSource::AliasBound, result });
+                    candidates.applicable.push(Candidate {
+                        source: CandidateSource::AliasBound,
+                        result,
+                        candidate_usages: CandidateUsages::default(),
+                    });
                 }
                 return;
             }
@@ -680,7 +706,7 @@ where
                     .item_self_bounds(alias_ty.def_id)
                     .iter_instantiated(self.cx(), alias_ty.args)
                 {
-                    candidates.extend(G::probe_and_consider_implied_clause(
+                    candidates.applicable.extend(G::probe_and_consider_implied_clause(
                         self,
                         CandidateSource::AliasBound,
                         goal,
@@ -695,7 +721,7 @@ where
                     .item_non_self_bounds(alias_ty.def_id)
                     .iter_instantiated(self.cx(), alias_ty.args)
                 {
-                    candidates.extend(G::probe_and_consider_implied_clause(
+                    candidates.applicable.extend(G::probe_and_consider_implied_clause(
                         self,
                         CandidateSource::AliasBound,
                         goal,
@@ -706,7 +732,9 @@ where
             }
         }
 
-        candidates.extend(G::consider_additional_alias_assumptions(self, goal, alias_ty));
+        candidates
+            .applicable
+            .extend(G::consider_additional_alias_assumptions(self, goal, alias_ty));
 
         if kind != ty::Projection {
             return;
@@ -728,7 +756,7 @@ where
     fn assemble_object_bound_candidates<G: GoalKind<D>>(
         &mut self,
         goal: Goal<I, G>,
-        candidates: &mut Vec<Candidate<I>>,
+        candidates: &mut Candidates<I>,
     ) {
         let cx = self.cx();
         if !cx.trait_may_be_implemented_via_object(goal.predicate.trait_def_id(cx)) {
@@ -784,7 +812,7 @@ where
                 }
                 ty::ExistentialPredicate::Projection(_)
                 | ty::ExistentialPredicate::AutoTrait(_) => {
-                    candidates.extend(G::probe_and_consider_object_bound_candidate(
+                    candidates.applicable.extend(G::probe_and_consider_object_bound_candidate(
                         self,
                         CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),
                         goal,
@@ -800,7 +828,7 @@ where
         if let Some(principal) = bounds.principal() {
             let principal_trait_ref = principal.with_self_ty(cx, self_ty);
             for (idx, assumption) in elaborate::supertraits(cx, principal_trait_ref).enumerate() {
-                candidates.extend(G::probe_and_consider_object_bound_candidate(
+                candidates.applicable.extend(G::probe_and_consider_object_bound_candidate(
                     self,
                     CandidateSource::BuiltinImpl(BuiltinImplSource::Object(idx)),
                     goal,
@@ -959,24 +987,30 @@ where
                 // Even when a trait bound has been proven using a where-bound, we
                 // still need to consider alias-bounds for normalization, see
                 // `tests/ui/next-solver/alias-bound-shadowed-by-env.rs`.
-                let mut candidates: Vec<_> = self
+                let mut candidates = self
                     .assemble_and_evaluate_candidates(goal, AssembleCandidatesFrom::EnvAndBounds);
 
                 // We still need to prefer where-bounds over alias-bounds however.
                 // See `tests/ui/winnowing/norm-where-bound-gt-alias-bound.rs`.
-                if candidates.iter().any(|c| matches!(c.source, CandidateSource::ParamEnv(_))) {
-                    candidates.retain(|c| matches!(c.source, CandidateSource::ParamEnv(_)));
-                } else if candidates.is_empty() {
+                if candidates
+                    .applicable
+                    .iter()
+                    .any(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
+                {
+                    for ignored in candidates
+                        .applicable
+                        .extract_if(.., |c| !matches!(c.source, CandidateSource::ParamEnv(_)))
+                    {
+                        self.ignore_candidate_usages(ignored.candidate_usages);
+                    }
+                } else if candidates.applicable.is_empty() {
                     // If the trait goal has been proven by using the environment, we want to treat
                     // aliases as rigid if there are no applicable projection bounds in the environment.
                     return inject_normalize_to_rigid_candidate(self);
                 }
 
-                if let Some(response) = self.try_merge_candidates(&candidates) {
-                    Ok(response)
-                } else {
-                    self.flounder(&candidates)
-                }
+                self.try_merge_candidates(candidates.applicable, vec![])
+                    .or_else(|candidates| self.flounder(&candidates))
             }
             TraitGoalProvenVia::Misc => {
                 let mut candidates =
@@ -985,23 +1019,31 @@ where
                 // Prefer "orphaned" param-env normalization predicates, which are used
                 // (for example, and ideally only) when proving item bounds for an impl.
                 let candidates_from_env: Vec<_> = candidates
+                    .applicable
                     .extract_if(.., |c| matches!(c.source, CandidateSource::ParamEnv(_)))
                     .collect();
-                if let Some(response) = self.try_merge_candidates(&candidates_from_env) {
-                    return Ok(response);
+                if !candidates_from_env.is_empty() {
+                    match self.try_merge_candidates(
+                        candidates_from_env,
+                        candidates.not_applicable_param_env,
+                    ) {
+                        Ok(response) => return Ok(response),
+                        Err(candidates_from_env) => return self.flounder(&candidates_from_env),
+                    }
                 }
 
                 // We drop specialized impls to allow normalization via a final impl here. In case
                 // the specializing impl has different inference constraints from the specialized
                 // impl, proving the trait goal is already ambiguous, so we never get here. This
                 // means we can just ignore inference constraints and don't have to special-case
                 // constraining the normalized-to `term`.
-                self.filter_specialized_impls(AllowInferenceConstraints::Yes, &mut candidates);
-                if let Some(response) = self.try_merge_candidates(&candidates) {
-                    Ok(response)
-                } else {
-                    self.flounder(&candidates)
-                }
+                self.filter_specialized_impls(
+                    AllowInferenceConstraints::Yes,
+                    &mut candidates.applicable,
+                );
+
+                self.try_merge_candidates(candidates.applicable, vec![])
+                    .or_else(|candidates| self.flounder(&candidates))
             }
         }
     }

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

@@ -8,7 +8,7 @@ use rustc_type_ir::fast_reject::DeepRejectCtxt;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::Relate;
 use rustc_type_ir::relate::solver_relating::RelateExt;
-use rustc_type_ir::search_graph::PathKind;
+use rustc_type_ir::search_graph::{CandidateUsages, PathKind};
 use rustc_type_ir::{
     self as ty, CanonicalVarValues, InferCtxtLike, Interner, TypeFoldable, TypeFolder,
     TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
@@ -399,6 +399,10 @@ where
         result
     }
 
+    pub(super) fn ignore_candidate_usages(&mut self, usages: CandidateUsages) {
+        self.search_graph.ignore_candidate_usages(usages);
+    }
+
     /// Recursively evaluates `goal`, returning whether any inference vars have
     /// been constrained and the certainty of the result.
     fn evaluate_goal(