Auto merge of #144991 - lcnr:ignore-usages-from-ignored-candidates, r=<try>

ignore usages from ignored candidates

Author: rust-bors[bot]

compiler/rustc_next_trait_solver/src/solve/assembly/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(

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

@@ -1,5 +1,6 @@
 use std::marker::PhantomData;
 
+use rustc_type_ir::search_graph::CandidateUsages;
 use rustc_type_ir::{InferCtxtLike, Interner};
 use tracing::instrument;
 
@@ -25,6 +26,20 @@ where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
+    pub(in crate::solve) fn enter_unique_candidate(
+        self,
+        f: impl FnOnce(&mut EvalCtxt<'_, D>) -> T,
+    ) -> (T, CandidateUsages) {
+        self.ecx.search_graph.enter_unique_candidate();
+        let mut candidate_usages = CandidateUsages::default();
+        let result = self.enter(|ecx| {
+            let result = f(ecx);
+            candidate_usages = ecx.search_graph.finish_unique_candidate();
+            result
+        });
+        (result, candidate_usages)
+    }
+
     pub(in crate::solve) fn enter(self, f: impl FnOnce(&mut EvalCtxt<'_, D>) -> T) -> T {
         let ProbeCtxt { ecx: outer, probe_kind, _result } = self;
 
@@ -78,7 +93,8 @@ where
         self,
         f: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
-        self.cx.enter(|ecx| f(ecx)).map(|result| Candidate { source: self.source, result })
+        let (result, candidate_usages) = self.cx.enter_unique_candidate(f);
+        result.map(|result| Candidate { source: self.source, result, candidate_usages })
     }
 }
 

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

@@ -23,12 +23,14 @@ mod trait_goals;
 
 use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
+use rustc_type_ir::search_graph::CandidateUsages;
 pub use rustc_type_ir::solve::*;
 use rustc_type_ir::{self as ty, Interner, TypingMode};
 use tracing::instrument;
 
 pub use self::eval_ctxt::{EvalCtxt, GenerateProofTree, SolverDelegateEvalExt};
 use crate::delegate::SolverDelegate;
+use crate::solve::assembly::{Candidate, Candidates};
 
 /// How many fixpoint iterations we should attempt inside of the solver before bailing
 /// with overflow.
@@ -235,6 +237,12 @@ where
     }
 }
 
+#[derive(Debug)]
+pub enum MergeCandidateKind {
+    AlwaysApplicable(usize),
+    ConsiderAll,
+}
+
 impl<D, I> EvalCtxt<'_, D>
 where
     D: SolverDelegate<Interner = I>,
@@ -244,50 +252,66 @@ where
     ///
     /// In this case we tend to flounder and return ambiguity by calling `[EvalCtxt::flounder]`.
     #[instrument(level = "trace", skip(self), ret)]
-    fn try_merge_responses(
+    fn try_merge_candidates(
         &mut self,
-        responses: &[CanonicalResponse<I>],
-    ) -> Option<CanonicalResponse<I>> {
-        if responses.is_empty() {
-            return None;
-        }
-
-        let one = responses[0];
-        if responses[1..].iter().all(|&resp| resp == one) {
-            return Some(one);
+        candidates: Vec<Candidate<I>>,
+        not_applicable_candidates: Vec<CandidateUsages>,
+    ) -> Result<CanonicalResponse<I>, Vec<Candidate<I>>> {
+        if candidates.is_empty() {
+            return Err(candidates);
         }
 
-        responses
+        let always_applicable = candidates
             .iter()
-            .find(|response| {
-                response.value.certainty == Certainty::Yes
-                    && has_no_inference_or_external_constraints(**response)
+            .enumerate()
+            .find(|(_, candidate)| {
+                candidate.result.value.certainty == Certainty::Yes
+                    && has_no_inference_or_external_constraints(candidate.result)
             })
-            .copied()
+            .map(|(i, c)| (i, c.result));
+        if let Some((i, result)) = always_applicable {
+            for (j, c) in candidates.into_iter().enumerate() {
+                if i != j {
+                    self.ignore_candidate_usages(c.candidate_usages);
+                }
+            }
+            for candidate_usages in not_applicable_candidates {
+                self.ignore_candidate_usages(candidate_usages);
+            }
+            return Ok(result);
+        }
+
+        let one: CanonicalResponse<I> = candidates[0].result;
+        if candidates[1..].iter().all(|candidate| candidate.result == one) {
+            return Ok(one);
+        }
+
+        Err(candidates)
     }
 
-    fn bail_with_ambiguity(&mut self, responses: &[CanonicalResponse<I>]) -> CanonicalResponse<I> {
-        debug_assert!(responses.len() > 1);
-        let maybe_cause = responses.iter().fold(MaybeCause::Ambiguity, |maybe_cause, response| {
-            // Pull down the certainty of `Certainty::Yes` to ambiguity when combining
-            // these responses, b/c we're combining more than one response and this we
-            // don't know which one applies.
-            let candidate = match response.value.certainty {
-                Certainty::Yes => MaybeCause::Ambiguity,
-                Certainty::Maybe(candidate) => candidate,
-            };
-            maybe_cause.or(candidate)
-        });
+    fn bail_with_ambiguity(&mut self, candidates: &[Candidate<I>]) -> CanonicalResponse<I> {
+        debug_assert!(candidates.len() > 1);
+        let maybe_cause =
+            candidates.iter().fold(MaybeCause::Ambiguity, |maybe_cause, candidates| {
+                // Pull down the certainty of `Certainty::Yes` to ambiguity when combining
+                // these responses, b/c we're combining more than one response and this we
+                // don't know which one applies.
+                let candidate = match candidates.result.value.certainty {
+                    Certainty::Yes => MaybeCause::Ambiguity,
+                    Certainty::Maybe(candidate) => candidate,
+                };
+                maybe_cause.or(candidate)
+            });
         self.make_ambiguous_response_no_constraints(maybe_cause)
     }
 
     /// If we fail to merge responses we flounder and return overflow or ambiguity.
     #[instrument(level = "trace", skip(self), ret)]
-    fn flounder(&mut self, responses: &[CanonicalResponse<I>]) -> QueryResult<I> {
-        if responses.is_empty() {
+    fn flounder(&mut self, candidates: &[Candidate<I>]) -> QueryResult<I> {
+        if candidates.is_empty() {
             return Err(NoSolution);
         } else {
-            Ok(self.bail_with_ambiguity(responses))
+            Ok(self.bail_with_ambiguity(candidates))
         }
     }
 

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -48,7 +48,9 @@ where
     ) -> QueryResult<I> {
         match kind {
             PathKind::Coinductive => response_no_constraints(cx, input, Certainty::Yes),
-            PathKind::Unknown => response_no_constraints(cx, input, Certainty::overflow(false)),
+            PathKind::Unknown | PathKind::ForcedAmbiguity => {
+                response_no_constraints(cx, input, Certainty::overflow(false))
+            }
             // Even though we know these cycles to be unproductive, we still return
             // overflow during coherence. This is both as we are not 100% confident in
             // the implementation yet and any incorrect errors would be unsound there.

compiler/rustc_next_trait_solver/src/solve/search_graph.rs

@@ -16,8 +16,8 @@ use crate::solve::assembly::structural_traits::{self, AsyncCallableRelevantTypes
 use crate::solve::assembly::{self, AllowInferenceConstraints, AssembleCandidatesFrom, Candidate};
 use crate::solve::inspect::ProbeKind;
 use crate::solve::{
-    BuiltinImplSource, CandidateSource, Certainty, EvalCtxt, Goal, GoalSource, MaybeCause,
-    NoSolution, ParamEnvSource, QueryResult, has_only_region_constraints,
+    BuiltinImplSource, CandidateSource, Candidates, Certainty, EvalCtxt, Goal, GoalSource,
+    MaybeCause, NoSolution, ParamEnvSource, QueryResult, has_only_region_constraints,
 };
 
 impl<D, I> assembly::GoalKind<D> for TraitPredicate<I>
@@ -1343,22 +1343,20 @@ where
     #[instrument(level = "debug", skip(self), ret)]
     pub(super) fn merge_trait_candidates(
         &mut self,
-        mut candidates: Vec<Candidate<I>>,
+        mut candidates: Candidates<I>,
     ) -> Result<(CanonicalResponse<I>, Option<TraitGoalProvenVia>), NoSolution> {
         if let TypingMode::Coherence = self.typing_mode() {
-            let all_candidates: Vec<_> = candidates.into_iter().map(|c| c.result).collect();
-            return if let Some(response) = self.try_merge_responses(&all_candidates) {
-                Ok((response, Some(TraitGoalProvenVia::Misc)))
-            } else {
-                self.flounder(&all_candidates).map(|r| (r, None))
-            };
+            match self.try_merge_candidates(candidates.applicable, vec![]) {
+                Ok(response) => return Ok((response, Some(TraitGoalProvenVia::Misc))),
+                Err(candidates) => return self.flounder(&candidates).map(|r| (r, None)),
+            }
         }
 
         // We prefer trivial builtin candidates, i.e. builtin impls without any
         // nested requirements, over all others. This is a fix for #53123 and
         // prevents where-bounds from accidentally extending the lifetime of a
         // variable.
-        let mut trivial_builtin_impls = candidates.iter().filter(|c| {
+        let mut trivial_builtin_impls = candidates.applicable.iter().filter(|c| {
             matches!(c.source, CandidateSource::BuiltinImpl(BuiltinImplSource::Trivial))
         });
         if let Some(candidate) = trivial_builtin_impls.next() {
@@ -1371,57 +1369,56 @@ where
         // If there are non-global where-bounds, prefer where-bounds
         // (including global ones) over everything else.
         let has_non_global_where_bounds = candidates
+            .applicable
             .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(_)))
-                .map(|c| c.result)
-                .collect();
-            return if let Some(response) = self.try_merge_responses(&where_bounds) {
-                Ok((response, Some(TraitGoalProvenVia::ParamEnv)))
-            } else {
-                Ok((self.bail_with_ambiguity(&where_bounds), None))
-            };
+            let mut where_bounds = candidates.applicable;
+            for not_where_bound in
+                where_bounds.extract_if(.., |c| !matches!(c.source, CandidateSource::ParamEnv(_)))
+            {
+                self.ignore_candidate_usages(not_where_bound.candidate_usages);
+            }
+            match self.try_merge_candidates(where_bounds, candidates.not_applicable_param_env) {
+                Ok(response) => return Ok((response, Some(TraitGoalProvenVia::ParamEnv))),
+                Err(where_bounds) => return Ok((self.bail_with_ambiguity(&where_bounds), None)),
+            }
         }
 
-        if candidates.iter().any(|c| matches!(c.source, CandidateSource::AliasBound)) {
+        if candidates.applicable.iter().any(|c| matches!(c.source, CandidateSource::AliasBound)) {
             let alias_bounds: Vec<_> = candidates
-                .iter()
-                .filter(|c| matches!(c.source, CandidateSource::AliasBound))
-                .map(|c| c.result)
+                .applicable
+                .extract_if(.., |c| matches!(c.source, CandidateSource::AliasBound))
                 .collect();
-            return if let Some(response) = self.try_merge_responses(&alias_bounds) {
-                Ok((response, Some(TraitGoalProvenVia::AliasBound)))
-            } else {
-                Ok((self.bail_with_ambiguity(&alias_bounds), None))
-            };
+            match self.try_merge_candidates(alias_bounds, vec![]) {
+                Ok(response) => return Ok((response, Some(TraitGoalProvenVia::AliasBound))),
+                Err(alias_bounds) => return Ok((self.bail_with_ambiguity(&alias_bounds), None)),
+            }
         }
 
-        self.filter_specialized_impls(AllowInferenceConstraints::No, &mut candidates);
-        self.unsound_prefer_builtin_dyn_impl(&mut candidates);
+        self.filter_specialized_impls(AllowInferenceConstraints::No, &mut candidates.applicable);
+        self.unsound_prefer_builtin_dyn_impl(&mut candidates.applicable);
 
         // If there are *only* global where bounds, then make sure to return that this
         // 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
+            .applicable
             .iter()
             .all(|c| matches!(c.source, CandidateSource::ParamEnv(ParamEnvSource::Global)))
         {
             TraitGoalProvenVia::ParamEnv
         } else {
             candidates
+                .applicable
                 .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) {
-            Ok((response, Some(proven_via)))
-        } else {
-            self.flounder(&all_candidates).map(|r| (r, None))
+        match self.try_merge_candidates(candidates.applicable, vec![]) {
+            Ok(response) => Ok((response, Some(proven_via))),
+            Err(candidates) => self.flounder(&candidates).map(|r| (r, None)),
         }
     }