Self review

Author: compiler-errors

Diff for: compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs

@@ -289,6 +289,10 @@ where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
+    /// Helper function that first tries to normalize the self type of the goal, bailing with
+    /// ambiguity if normalizing is ambiguous or if it bottoms out in an infer var, then calls
+    /// the `assemble` callback. It additionally manages assembling a coherence-unknowable
+    /// candidate if necessary, which takes precedence over all other candidates.
     fn assemble_and_evaluate_candidates_with_normalized_goal<G: GoalKind<D>>(
         &mut self,
         goal: Goal<I, G>,
@@ -326,12 +330,28 @@ where
     ) -> Vec<Candidate<I>> {
         self.assemble_and_evaluate_candidates_with_normalized_goal(goal, |ecx, goal| {
             let mut candidates = vec![];
-            ecx.assemble_alias_bound_candidates(goal, &mut candidates);
-            ecx.assemble_param_env_candidates(goal, &mut candidates);
+            // Only assemble candidates via this helper function, since its logic is shared with
+            // `assemble_and_evaluate_candidates` below. Any other candidates that are only
+            // assembled by this function (or only by `assemble_and_evaluate_candidates`) will be
+            // subtly incomplete when it comes to normalizes-to goals.
+            ecx.assemble_param_env_and_bound_candidates(goal, &mut candidates);
+            debug_assert!(candidates.iter().all(|c| matches!(
+                c.source,
+                CandidateSource::AliasBound | CandidateSource::ParamEnv(_)
+            )));
             candidates
         })
     }
 
+    fn assemble_param_env_and_bound_candidates<G: GoalKind<D>>(
+        &mut self,
+        goal: Goal<I, G>,
+        candidates: &mut Vec<Candidate<I>>,
+    ) {
+        self.assemble_alias_bound_candidates(goal, candidates);
+        self.assemble_param_env_candidates(goal, candidates);
+    }
+
     pub(super) fn assemble_and_evaluate_candidates<G: GoalKind<D>>(
         &mut self,
         goal: Goal<I, G>,
@@ -341,8 +361,16 @@ where
             ecx.assemble_impl_candidates(goal, &mut candidates);
             ecx.assemble_builtin_impl_candidates(goal, &mut candidates);
             ecx.assemble_object_bound_candidates(goal, &mut candidates);
-            ecx.assemble_alias_bound_candidates(goal, &mut candidates);
-            ecx.assemble_param_env_candidates(goal, &mut candidates);
+            // NOTE: Make sure that we're not assembling any param-env/bound candidates
+            // outside of `assemble_param_env_and_bound_candidates`, since we want to make
+            // sure not to *incompletely* assemble candidates in
+            // `assemble_and_evaluate_candidates_from_env_and_bounds` which uses the helper
+            // `assemble_param_env_and_bound_candidates`.
+            debug_assert!(!candidates.iter().any(|c| matches!(
+                c.source,
+                CandidateSource::AliasBound | CandidateSource::ParamEnv(_)
+            )));
+            ecx.assemble_param_env_and_bound_candidates(goal, &mut candidates);
             candidates
         })
     }
@@ -766,6 +794,9 @@ where
         })
     }
 
+    /// Assemble and merge candidates for goals which are related to an underlying trait
+    /// goal. Right now, this is normalizes-to and host effect goals.
+    ///
     /// We sadly can't simply take all possible candidates for normalization goals
     /// and check whether they result in the same constraints. We want to make sure
     /// that trying to normalize an alias doesn't result in constraints which aren't
@@ -804,7 +835,7 @@ where
             // 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));
+            return Ok(self.forced_ambiguity(MaybeCause::Ambiguity)?.result);
         };
 
         match proven_via {
@@ -815,11 +846,6 @@ where
                 let candidates_from_env_and_bounds: Vec<_> =
                     self.assemble_and_evaluate_candidates_from_env_and_bounds(goal);
 
-                debug_assert!(candidates_from_env_and_bounds.iter().all(|c| matches!(
-                    c.source,
-                    CandidateSource::AliasBound | CandidateSource::ParamEnv(_)
-                )));
-
                 // We still need to prefer where-bounds over alias-bounds however.
                 // See `tests/ui/winnowing/norm-where-bound-gt-alias-bound.rs`.
                 let mut considered_candidates: Vec<_> = if candidates_from_env_and_bounds

Diff for: compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs

@@ -269,7 +269,7 @@ impl<'tcx> BestObligation<'tcx> {
         goal: &inspect::InspectGoal<'_, 'tcx>,
         self_ty: Ty<'tcx>,
     ) -> ControlFlow<PredicateObligation<'tcx>> {
-        //assert!(!self.consider_ambiguities);
+        assert!(!self.consider_ambiguities);
         let tcx = goal.infcx().tcx;
         if let ty::Alias(..) = self_ty.kind() {
             let infer_term = goal.infcx().next_ty_var(self.obligation.cause.span);