Pull non-wf alias detection into sub-functions

Author: compiler-errors

compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs

@@ -290,6 +290,59 @@ impl<'tcx> BestObligation<'tcx> {
             ControlFlow::Continue(())
         }
     }
+
+    /// It is likely that `NormalizesTo` failed without any applicable candidates
+    /// because the alias is not well-formed.
+    ///
+    /// As we only enter `RigidAlias` candidates if the trait bound of the associated type
+    /// holds, we discard these candidates in `non_trivial_candidates` and always manually
+    /// check this here.
+    fn detect_non_well_formed_assoc_item(
+        &mut self,
+        goal: &inspect::InspectGoal<'_, 'tcx>,
+        alias: ty::AliasTerm<'tcx>,
+    ) -> ControlFlow<PredicateObligation<'tcx>> {
+        let tcx = goal.infcx().tcx;
+        let obligation = Obligation::new(
+            tcx,
+            self.obligation.cause.clone(),
+            goal.goal().param_env,
+            alias.trait_ref(tcx),
+        );
+        self.with_derived_obligation(obligation, |this| {
+            goal.infcx().visit_proof_tree_at_depth(
+                goal.goal().with(tcx, alias.trait_ref(tcx)),
+                goal.depth() + 1,
+                this,
+            )
+        })
+    }
+
+    /// If we have no candidates, then it's likely that we a non-well-formed alias
+    /// in the goal.
+    fn detect_error_from_empty_candidates(
+        &mut self,
+        goal: &inspect::InspectGoal<'_, 'tcx>,
+    ) -> ControlFlow<PredicateObligation<'tcx>> {
+        let tcx = goal.infcx().tcx;
+        let pred_kind = goal.goal().predicate.kind();
+
+        match pred_kind.no_bound_vars() {
+            Some(ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred))) => {
+                self.detect_error_in_self_ty_normalization(goal, pred.self_ty())?;
+            }
+            Some(ty::PredicateKind::NormalizesTo(pred))
+                if let ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst =
+                    pred.alias.kind(tcx) =>
+            {
+                self.detect_error_in_self_ty_normalization(goal, pred.alias.self_ty())?;
+                self.detect_non_well_formed_assoc_item(goal, pred.alias)?;
+            }
+            Some(_) | None => {}
+        }
+
+        ControlFlow::Break(self.obligation.clone())
+    }
 }
 
 impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
@@ -311,40 +364,8 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
 
         let candidates = self.non_trivial_candidates(goal);
         let candidate = match candidates.as_slice() {
-            [] => {
-                match pred_kind.no_bound_vars() {
-                    Some(ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred))) => {
-                        self.detect_error_in_self_ty_normalization(goal, pred.self_ty())?;
-                    }
-                    Some(ty::PredicateKind::NormalizesTo(pred))
-                        if let ty::AliasTermKind::ProjectionTy
-                        | ty::AliasTermKind::ProjectionConst = pred.alias.kind(tcx) =>
-                    {
-                        self.detect_error_in_self_ty_normalization(goal, pred.alias.self_ty())?;
-                        // It is likely that `NormalizesTo` failed because the alias is not well-formed.
-                        // As we only enter `RigidAlias` candidates if the trait bound of the associated type
-                        // holds, we discard these candidates in `non_trivial_candidates` and always manually
-                        // check this here.
-                        let obligation = Obligation::new(
-                            tcx,
-                            self.obligation.cause.clone(),
-                            goal.goal().param_env,
-                            pred.alias.trait_ref(tcx),
-                        );
-                        self.with_derived_obligation(obligation, |this| {
-                            goal.infcx().visit_proof_tree_at_depth(
-                                goal.goal().with(tcx, pred.alias.trait_ref(tcx)),
-                                goal.depth() + 1,
-                                this,
-                            )
-                        })?;
-                    }
-                    Some(_) | None => {}
-                }
-
-                return ControlFlow::Break(self.obligation.clone());
-            }
             [candidate] => candidate,
+            [] => return self.detect_error_from_empty_candidates(goal),
             _ => return ControlFlow::Break(self.obligation.clone()),
         };