next solver cleanups

Author: yotamofek

compiler/rustc_next_trait_solver/src/canonicalizer.rs

@@ -289,10 +289,8 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
                 for var in var_infos.iter_mut() {
                     // We simply put all regions from the input into the highest
                     // compressed universe, so we only deal with them at the end.
-                    if !var.is_region() {
-                        if is_existential == var.is_existential() {
-                            update_uv(var, orig_uv, is_existential)
-                        }
+                    if !var.is_region() && is_existential == var.is_existential() {
+                        update_uv(var, orig_uv, is_existential)
                     }
                 }
             }
@@ -317,40 +315,39 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
 
     fn cached_fold_ty(&mut self, t: I::Ty) -> I::Ty {
         let kind = match t.kind() {
-            ty::Infer(i) => match i {
-                ty::TyVar(vid) => {
-                    assert_eq!(
-                        self.delegate.opportunistic_resolve_ty_var(vid),
-                        t,
-                        "ty vid should have been resolved fully before canonicalization"
-                    );
+            ty::Infer(ty::TyVar(vid)) => {
+                assert_eq!(
+                    self.delegate.opportunistic_resolve_ty_var(vid),
+                    t,
+                    "ty vid should have been resolved fully before canonicalization"
+                );
+
+                CanonicalVarKind::Ty(CanonicalTyVarKind::General(
+                    self.delegate
+                        .universe_of_ty(vid)
+                        .unwrap_or_else(|| panic!("ty var should have been resolved: {t:?}")),
+                ))
+            }
+            ty::Infer(ty::IntVar(vid)) => {
+                assert_eq!(
+                    self.delegate.opportunistic_resolve_int_var(vid),
+                    t,
+                    "ty vid should have been resolved fully before canonicalization"
+                );
+                CanonicalVarKind::Ty(CanonicalTyVarKind::Int)
+            }
+            ty::Infer(ty::FloatVar(vid)) => {
+                assert_eq!(
+                    self.delegate.opportunistic_resolve_float_var(vid),
+                    t,
+                    "ty vid should have been resolved fully before canonicalization"
+                );
+                CanonicalVarKind::Ty(CanonicalTyVarKind::Float)
+            }
+            ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
+                panic!("fresh vars not expected in canonicalization")
+            }
 
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::General(
-                        self.delegate
-                            .universe_of_ty(vid)
-                            .unwrap_or_else(|| panic!("ty var should have been resolved: {t:?}")),
-                    ))
-                }
-                ty::IntVar(vid) => {
-                    assert_eq!(
-                        self.delegate.opportunistic_resolve_int_var(vid),
-                        t,
-                        "ty vid should have been resolved fully before canonicalization"
-                    );
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::Int)
-                }
-                ty::FloatVar(vid) => {
-                    assert_eq!(
-                        self.delegate.opportunistic_resolve_float_var(vid),
-                        t,
-                        "ty vid should have been resolved fully before canonicalization"
-                    );
-                    CanonicalVarKind::Ty(CanonicalTyVarKind::Float)
-                }
-                ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
-                    panic!("fresh vars not expected in canonicalization")
-                }
-            },
             ty::Placeholder(placeholder) => match self.canonicalize_mode {
                 CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderTy(
                     PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),

compiler/rustc_next_trait_solver/src/resolve.rs

@@ -44,18 +44,15 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for EagerResolv
             }
             ty::Infer(ty::IntVar(vid)) => self.delegate.opportunistic_resolve_int_var(vid),
             ty::Infer(ty::FloatVar(vid)) => self.delegate.opportunistic_resolve_float_var(vid),
-            _ => {
-                if t.has_infer() {
-                    if let Some(&ty) = self.cache.get(&t) {
-                        return ty;
-                    }
-                    let res = t.super_fold_with(self);
-                    assert!(self.cache.insert(t, res));
-                    res
-                } else {
-                    t
+            _ if t.has_infer() => {
+                if let Some(&ty) = self.cache.get(&t) {
+                    return ty;
                 }
+                let res = t.super_fold_with(self);
+                assert!(self.cache.insert(t, res));
+                res
             }
+            _ => t,
         }
     }
 
@@ -76,13 +73,8 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for EagerResolv
                     resolved
                 }
             }
-            _ => {
-                if c.has_infer() {
-                    c.super_fold_with(self)
-                } else {
-                    c
-                }
-            }
+            _ if c.has_infer() => c.super_fold_with(self),
+            _ => c,
         }
     }
 }

compiler/rustc_next_trait_solver/src/solve/alias_relate.rs

@@ -36,23 +36,21 @@ where
         let Goal { param_env, predicate: (lhs, rhs, direction) } = goal;
         debug_assert!(lhs.to_alias_term().is_some() || rhs.to_alias_term().is_some());
 
-        // Structurally normalize the lhs.
-        let lhs = if let Some(alias) = lhs.to_alias_term() {
-            let term = self.next_term_infer_of_kind(lhs);
-            self.add_normalizes_to_goal(goal.with(cx, ty::NormalizesTo { alias, term }));
-            term
-        } else {
-            lhs
+        let mut normalize = |term: I::Term| {
+            if let Some(alias) = term.to_alias_term() {
+                let term = self.next_term_infer_of_kind(term);
+                self.add_normalizes_to_goal(goal.with(cx, ty::NormalizesTo { alias, term }));
+                term
+            } else {
+                term
+            }
         };
 
+        // Structurally normalize the lhs.
+        let lhs = normalize(lhs);
+
         // Structurally normalize the rhs.
-        let rhs = if let Some(alias) = rhs.to_alias_term() {
-            let term = self.next_term_infer_of_kind(rhs);
-            self.add_normalizes_to_goal(goal.with(cx, ty::NormalizesTo { alias, term }));
-            term
-        } else {
-            rhs
-        };
+        let rhs = normalize(rhs);
 
         // Add a `make_canonical_response` probe step so that we treat this as
         // a candidate, even if `try_evaluate_added_goals` bails due to an error.
@@ -73,12 +71,10 @@ where
         match (lhs.to_alias_term(), rhs.to_alias_term()) {
             (None, None) => {
                 self.relate(param_env, lhs, variance, rhs)?;
-                self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
             }
 
             (Some(alias), None) => {
                 self.relate_rigid_alias_non_alias(param_env, alias, variance, rhs)?;
-                self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
             }
             (None, Some(alias)) => {
                 self.relate_rigid_alias_non_alias(
@@ -87,13 +83,12 @@ where
                     variance.xform(ty::Contravariant),
                     lhs,
                 )?;
-                self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
             }
 
             (Some(alias_lhs), Some(alias_rhs)) => {
                 self.relate(param_env, alias_lhs, variance, alias_rhs)?;
-                self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
             }
         }
+        self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }

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

@@ -492,15 +492,18 @@ where
         goal: Goal<I, G>,
         candidates: &mut Vec<Candidate<I>>,
     ) {
-        for (i, assumption) in goal.param_env.caller_bounds().iter().enumerate() {
-            candidates.extend(G::probe_and_consider_implied_clause(
-                self,
-                CandidateSource::ParamEnv(i),
-                goal,
-                assumption,
-                [],
-            ));
-        }
+        candidates.extend(goal.param_env.caller_bounds().iter().enumerate().filter_map(
+            |(i, assumption)| {
+                G::probe_and_consider_implied_clause(
+                    self,
+                    CandidateSource::ParamEnv(i),
+                    goal,
+                    assumption,
+                    [],
+                )
+                .ok()
+            },
+        ));
     }
 
     #[instrument(level = "trace", skip_all)]
@@ -509,7 +512,7 @@ where
         goal: Goal<I, G>,
         candidates: &mut Vec<Candidate<I>>,
     ) {
-        let () = self.probe(|_| ProbeKind::NormalizedSelfTyAssembly).enter(|ecx| {
+        self.probe(|_| ProbeKind::NormalizedSelfTyAssembly).enter(|ecx| {
             ecx.assemble_alias_bound_candidates_recur(goal.predicate.self_ty(), goal, candidates);
         });
     }
@@ -580,17 +583,21 @@ where
             }
         };
 
-        for assumption in
-            self.cx().item_bounds(alias_ty.def_id).iter_instantiated(self.cx(), alias_ty.args)
-        {
-            candidates.extend(G::probe_and_consider_implied_clause(
-                self,
-                CandidateSource::AliasBound,
-                goal,
-                assumption,
-                [],
-            ));
-        }
+        candidates.extend(
+            self.cx()
+                .item_bounds(alias_ty.def_id)
+                .iter_instantiated(self.cx(), alias_ty.args)
+                .filter_map(|assumption| {
+                    G::probe_and_consider_implied_clause(
+                        self,
+                        CandidateSource::AliasBound,
+                        goal,
+                        assumption,
+                        [],
+                    )
+                    .ok()
+                }),
+        );
 
         candidates.extend(G::consider_additional_alias_assumptions(self, goal, alias_ty));
 
@@ -599,11 +606,9 @@ where
         }
 
         // Recurse on the self type of the projection.
-        match self.structurally_normalize_ty(goal.param_env, alias_ty.self_ty()) {
-            Ok(next_self_ty) => {
-                self.assemble_alias_bound_candidates_recur(next_self_ty, goal, candidates)
-            }
-            Err(NoSolution) => {}
+        if let Ok(next_self_ty) = self.structurally_normalize_ty(goal.param_env, alias_ty.self_ty())
+        {
+            self.assemble_alias_bound_candidates_recur(next_self_ty, goal, candidates)
         }
     }
 
@@ -660,36 +665,43 @@ where
         // Consider all of the auto-trait and projection bounds, which don't
         // need to be recorded as a `BuiltinImplSource::Object` since they don't
         // really have a vtable base...
-        for bound in bounds.iter() {
+        candidates.extend(bounds.iter().filter_map(|bound| {
             match bound.skip_binder() {
                 ty::ExistentialPredicate::Trait(_) => {
                     // Skip principal
+                    None
                 }
                 ty::ExistentialPredicate::Projection(_)
                 | ty::ExistentialPredicate::AutoTrait(_) => {
-                    candidates.extend(G::probe_and_consider_object_bound_candidate(
+                    G::probe_and_consider_object_bound_candidate(
                         self,
                         CandidateSource::BuiltinImpl(BuiltinImplSource::Misc),
                         goal,
                         bound.with_self_ty(cx, self_ty),
-                    ));
+                    )
+                    .ok()
                 }
             }
-        }
+        }));
 
         // FIXME: We only need to do *any* of this if we're considering a trait goal,
         // since we don't need to look at any supertrait or anything if we are doing
         // a projection goal.
         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(
-                    self,
-                    CandidateSource::BuiltinImpl(BuiltinImplSource::Object(idx)),
-                    goal,
-                    assumption.upcast(cx),
-                ));
-            }
+            candidates.extend(
+                elaborate::supertraits(cx, principal_trait_ref).enumerate().filter_map(
+                    |(idx, assumption)| {
+                        G::probe_and_consider_object_bound_candidate(
+                            self,
+                            CandidateSource::BuiltinImpl(BuiltinImplSource::Object(idx)),
+                            goal,
+                            assumption.upcast(cx),
+                        )
+                        .ok()
+                    },
+                ),
+            );
         }
     }
 

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

@@ -342,13 +342,11 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<I: Intern
                     args,
                     sig,
                 )
-            } else {
+            } else if goal_kind != ty::ClosureKind::FnOnce {
                 // Closure kind is not yet determined, so we return ambiguity unless
                 // the expected kind is `FnOnce` as that is always implemented.
-                if goal_kind != ty::ClosureKind::FnOnce {
-                    return Ok(None);
-                }
-
+                return Ok(None);
+            } else {
                 coroutine_closure_to_ambiguous_coroutine(
                     cx,
                     goal_kind, // No captures by ref, so this doesn't matter.