rarw

Author: lcnr

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

@@ -292,6 +292,7 @@ where
     pub(super) fn assemble_and_evaluate_candidates<G: GoalKind<D>>(
         &mut self,
         goal: Goal<I, G>,
+        proven_via: Option<TraitGoalProvenVia>,
     ) -> Vec<Candidate<I>> {
         let Ok(normalized_self_ty) =
             self.structurally_normalize_ty(goal.param_env, goal.predicate.self_ty())
@@ -318,15 +319,18 @@ where
             }
         }
 
-        self.assemble_impl_candidates(goal, &mut candidates);
-
-        self.assemble_builtin_impl_candidates(goal, &mut candidates);
-
-        self.assemble_alias_bound_candidates(goal, &mut candidates);
-
-        self.assemble_object_bound_candidates(goal, &mut candidates);
-
         self.assemble_param_env_candidates(goal, &mut candidates);
+        self.assemble_alias_bound_candidates(goal, &mut candidates);
+        if candidates.is_empty()
+            && !matches!(
+                proven_via,
+                Some(TraitGoalProvenVia::ParamEnv | TraitGoalProvenVia::AliasBound)
+            )
+        {
+            self.assemble_impl_candidates(goal, &mut candidates);
+            self.assemble_builtin_impl_candidates(goal, &mut candidates);
+            self.assemble_object_bound_candidates(goal, &mut candidates);
+        }
 
         candidates
     }
@@ -780,17 +784,10 @@ where
     #[instrument(level = "debug", skip(self, inject_normalize_to_rigid_candidate), ret)]
     pub(super) fn merge_candidates(
         &mut self,
-        proven_via: Option<TraitGoalProvenVia>,
+        proven_via: TraitGoalProvenVia,
         candidates: Vec<Candidate<I>>,
         inject_normalize_to_rigid_candidate: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
     ) -> QueryResult<I> {
-        let Some(proven_via) = proven_via else {
-            // We don't care about overflow. If proving the trait goal overflowed, then
-            // it's enough to report an overflow error for that, we don't also have to
-            // overflow during normalization.
-            return Ok(self.make_ambiguous_response_no_constraints(MaybeCause::Ambiguity));
-        };
-
         match proven_via {
             // Even when a trait bound has been proven using a where-bound, we
             // still need to consider alias-bounds for normalization, see

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -11,8 +11,8 @@ use tracing::instrument;
 use super::assembly::{Candidate, structural_traits};
 use crate::delegate::SolverDelegate;
 use crate::solve::{
-    BuiltinImplSource, CandidateSource, Certainty, EvalCtxt, Goal, GoalSource, NoSolution,
-    QueryResult, assembly,
+    BuiltinImplSource, CandidateSource, Certainty, EvalCtxt, Goal, GoalSource, MaybeCause,
+    NoSolution, QueryResult, assembly,
 };
 
 impl<D, I> assembly::GoalKind<D> for ty::HostEffectPredicate<I>
@@ -399,12 +399,19 @@ where
         &mut self,
         goal: Goal<I, ty::HostEffectPredicate<I>>,
     ) -> QueryResult<I> {
-        let candidates = self.assemble_and_evaluate_candidates(goal);
         let (_, proven_via) = self.probe(|_| ProbeKind::ShadowedEnvProbing).enter(|ecx| {
             let trait_goal: Goal<I, ty::TraitPredicate<I>> =
                 goal.with(ecx.cx(), goal.predicate.trait_ref);
             ecx.compute_trait_goal(trait_goal)
         })?;
-        self.merge_candidates(proven_via, candidates, |_ecx| Err(NoSolution))
+        if let Some(proven_via) = proven_via {
+            let candidates = self.assemble_and_evaluate_candidates(goal, Some(proven_via));
+            self.merge_candidates(proven_via, candidates, |_ecx| Err(NoSolution))
+        } else {
+            // We don't care about overflow. If proving the trait goal overflowed, then
+            // it's enough to report an overflow error for that, we don't also have to
+            // overflow during normalization.
+            Ok(self.make_ambiguous_response_no_constraints(MaybeCause::Ambiguity))
+        }
     }
 }

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

@@ -32,23 +32,30 @@ where
         let cx = self.cx();
         match goal.predicate.alias.kind(cx) {
             ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => {
-                let candidates = self.assemble_and_evaluate_candidates(goal);
                 let trait_ref = goal.predicate.alias.trait_ref(cx);
                 let (_, proven_via) =
                     self.probe(|_| ProbeKind::ShadowedEnvProbing).enter(|ecx| {
                         let trait_goal: Goal<I, ty::TraitPredicate<I>> = goal.with(cx, trait_ref);
                         ecx.compute_trait_goal(trait_goal)
                     })?;
-                self.merge_candidates(proven_via, candidates, |ecx| {
-                    ecx.probe(|&result| ProbeKind::RigidAlias { result }).enter(|this| {
-                        this.structurally_instantiate_normalizes_to_term(
-                            goal,
-                            goal.predicate.alias,
-                        );
-                        this.add_goal(GoalSource::AliasWellFormed, goal.with(cx, trait_ref));
-                        this.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+                if let Some(proven_via) = proven_via {
+                    let candidates = self.assemble_and_evaluate_candidates(goal, Some(proven_via));
+                    self.merge_candidates(proven_via, candidates, |ecx| {
+                        ecx.probe(|&result| ProbeKind::RigidAlias { result }).enter(|this| {
+                            this.structurally_instantiate_normalizes_to_term(
+                                goal,
+                                goal.predicate.alias,
+                            );
+                            this.add_goal(GoalSource::AliasWellFormed, goal.with(cx, trait_ref));
+                            this.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+                        })
                     })
-                })
+                } else {
+                    // We don't care about overflow. If proving the trait goal overflowed, then
+                    // it's enough to report an overflow error for that, we don't also have to
+                    // overflow during normalization.
+                    Ok(self.make_ambiguous_response_no_constraints(MaybeCause::Ambiguity))
+                }
             }
             ty::AliasTermKind::InherentTy => self.normalize_inherent_associated_type(goal),
             ty::AliasTermKind::OpaqueTy => self.normalize_opaque_type(goal),

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -1377,7 +1377,7 @@ where
         &mut self,
         goal: Goal<I, TraitPredicate<I>>,
     ) -> Result<(CanonicalResponse<I>, Option<TraitGoalProvenVia>), NoSolution> {
-        let candidates = self.assemble_and_evaluate_candidates(goal);
+        let candidates = self.assemble_and_evaluate_candidates(goal, None);
         self.merge_trait_candidates(goal, candidates)
     }
 }