don't pass Certainty which is always Yes

Author: WaffleLapkin

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

@@ -213,7 +213,7 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         impl_def_id: I::ImplId,
-        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResultOrRerunNonErased<I>,
+        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResultOrRerunNonErased<I>,
     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased>;
 
     /// If the predicate contained an error, we want to avoid emitting unnecessary trait
@@ -552,8 +552,8 @@ where
             if cx.impl_is_default(impl_def_id) {
                 return Ok(());
             }
-            match G::consider_impl_candidate(self, goal, impl_def_id, |ecx, certainty| {
-                ecx.evaluate_added_goals_and_make_canonical_response(certainty)
+            match G::consider_impl_candidate(self, goal, impl_def_id, |ecx| {
+                ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
             })
             .map_err_to_rerun()?
             {
@@ -1173,11 +1173,10 @@ where
                     return Ok(());
                 }
 
-                match G::consider_impl_candidate(self, goal, impl_def_id, |ecx, certainty| {
+                match G::consider_impl_candidate(self, goal, impl_def_id, |ecx| {
                     if ecx.shallow_resolve(self_ty).is_ty_var() {
                         // We force the certainty of impl candidates to be `Maybe`.
-                        let certainty = certainty.and(Certainty::AMBIGUOUS);
-                        ecx.evaluate_added_goals_and_make_canonical_response(certainty)
+                        ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
                     } else {
                         // We don't want to use impls if they constrain the opaque.
                         //

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -137,7 +137,7 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
         impl_def_id: I::ImplId,
-        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResultOrRerunNonErased<I>,
+        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResultOrRerunNonErased<I>,
     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased> {
         let cx = ecx.cx();
 
@@ -148,11 +148,9 @@ where
             return Err(NoSolution.into());
         }
 
-        // TODO: certainty can only be yes here...
-        let impl_polarity = cx.impl_polarity(impl_def_id);
-        let certainty = match impl_polarity {
+        match cx.impl_polarity(impl_def_id) {
             ty::ImplPolarity::Negative => return Err(NoSolution.into()),
-            ty::ImplPolarity::Positive => Certainty::Yes,
+            ty::ImplPolarity::Positive => (),
         };
 
         if !cx.impl_is_const(impl_def_id) {
@@ -186,7 +184,7 @@ where
                 });
             ecx.add_goals(GoalSource::ImplWhereBound, const_conditions)?;
 
-            then(ecx, certainty)
+            then(ecx)
         })
     }
 

compiler/rustc_next_trait_solver/src/solve/normalizes_to.rs

@@ -254,7 +254,7 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, NormalizesTo<I>>,
         impl_def_id: I::ImplId,
-        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResultOrRerunNonErased<I>,
+        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResultOrRerunNonErased<I>,
     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased> {
         let cx = ecx.cx();
 
@@ -379,10 +379,10 @@ where
                         // This is not the case here and we only prefer adding an ambiguous
                         // nested goal for consistency.
                         ecx.add_goal(GoalSource::Misc, goal.with(cx, PredicateKind::Ambiguous))?;
-                        return then(ecx, Certainty::Yes);
+                        return then(ecx);
                     } else {
                         ecx.instantiate_normalizes_to_as_rigid(goal)?;
-                        return then(ecx, Certainty::Yes);
+                        return then(ecx);
                     }
                 } else {
                     return error_response(ecx, cx.delay_bug("missing item"));

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -61,7 +61,7 @@ where
         ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, TraitPredicate<I>>,
         impl_def_id: I::ImplId,
-        then: impl FnOnce(&mut EvalCtxt<'_, D>, Certainty) -> QueryResultOrRerunNonErased<I>,
+        then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResultOrRerunNonErased<I>,
     ) -> Result<Candidate<I>, NoSolutionOrRerunNonErased> {
         let cx = ecx.cx();
 
@@ -72,29 +72,18 @@ where
             return Err(NoSolution.into());
         }
 
-        // TODO: this comment is no longer true and maximal_certainty can only be `Yes`
-        // An upper bound of the certainty of this goal, used to lower the certainty
-        // of reservation impl to ambiguous during coherence.
-        let impl_polarity = cx.impl_polarity(impl_def_id);
-        let maximal_certainty = match (impl_polarity, goal.predicate.polarity) {
-            // Impl matches polarity
-            (ty::ImplPolarity::Positive, ty::PredicatePolarity::Positive)
-            | (ty::ImplPolarity::Negative, ty::PredicatePolarity::Negative) => {
-                if ecx.typing_mode().is_reflection()
-                    && !cx.is_fully_generic_for_reflection(impl_def_id)
-                {
-                    return Err(NoSolution.into());
-                } else {
-                    Certainty::Yes
-                }
-            }
-
+        match (cx.impl_polarity(impl_def_id), goal.predicate.polarity) {
             // Impl doesn't match polarity
             (ty::ImplPolarity::Positive, ty::PredicatePolarity::Negative)
             | (ty::ImplPolarity::Negative, ty::PredicatePolarity::Positive) => {
                 return Err(NoSolution.into());
             }
-        };
+            _ => {}
+        }
+
+        if ecx.typing_mode().is_reflection() && !cx.is_fully_generic_for_reflection(impl_def_id) {
+            return Err(NoSolution.into());
+        }
 
         ecx.probe_trait_candidate(CandidateSource::Impl(impl_def_id)).enter(|ecx| {
             let impl_args = ecx.fresh_args_for_item(impl_def_id.into());
@@ -120,7 +109,7 @@ where
                     .map(|pred| goal.with(cx, pred)),
             )?;
 
-            then(ecx, maximal_certainty)
+            then(ecx)
         })
     }