use the new routine to eagerly normalize

Author: adwinwhite

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -8,9 +8,7 @@ use rustc_middle::mir::{Body, ConstraintCategory};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, Unnormalized, Upcast};
 use rustc_span::Span;
 use rustc_span::def_id::DefId;
-use rustc_trait_selection::solve::NoSolution;
 use rustc_trait_selection::traits::ObligationCause;
-use rustc_trait_selection::traits::query::type_op::custom::CustomTypeOp;
 use rustc_trait_selection::traits::query::type_op::{self, TypeOpOutput};
 use tracing::{debug, instrument};
 
@@ -242,71 +240,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             body.source.def_id().expect_local(),
         );
 
-        if self.infcx.next_trait_solver() {
-            let param_env = self.infcx.param_env;
-            // FIXME: Make this into a real type op?
-            self.fully_perform_op(
-                location.to_locations(),
-                ConstraintCategory::Boring,
-                CustomTypeOp::new(
-                    |ocx| {
-                        let structurally_normalize = |ty| {
-                            ocx.structurally_normalize_ty(&cause, param_env, Unnormalized::new_wip(ty))
-                            .unwrap_or_else(|_| bug!("struct tail should have been computable, since we computed it in HIR"))
-                        };
-
-                        let tail = tcx.struct_tail_raw(
-                            ty,
-                            &cause,
-                            structurally_normalize,
-                            || {},
-                        );
-
-                        Ok(tail)
-                    },
-                    "normalizing struct tail",
-                ),
-            )
-            .unwrap_or_else(|guar| Ty::new_error(tcx, guar))
-        } else {
-            let mut normalize = |ty| self.normalize(ty, location);
-            let tail = tcx.struct_tail_raw(ty, &cause, &mut normalize, || {});
-            normalize(tail)
-        }
-    }
-
-    #[instrument(skip(self), level = "debug")]
-    pub(super) fn structurally_resolve(
-        &mut self,
-        ty: Ty<'tcx>,
-        location: impl NormalizeLocation,
-    ) -> Ty<'tcx> {
-        if self.infcx.next_trait_solver() {
-            let body = self.body;
-            let param_env = self.infcx.param_env;
-            // FIXME: Make this into a real type op?
-            self.fully_perform_op(
-                location.to_locations(),
-                ConstraintCategory::Boring,
-                CustomTypeOp::new(
-                    |ocx| {
-                        ocx.structurally_normalize_ty(
-                            &ObligationCause::misc(
-                                location.to_locations().span(body),
-                                body.source.def_id().expect_local(),
-                            ),
-                            param_env,
-                            Unnormalized::new_wip(ty),
-                        )
-                        .map_err(|_| NoSolution)
-                    },
-                    "normalizing struct tail",
-                ),
-            )
-            .unwrap_or_else(|guar| Ty::new_error(self.tcx(), guar))
-        } else {
-            self.normalize(ty, location)
-        }
+        let mut normalize = |ty| self.normalize(ty, location);
+        let tail = tcx.struct_tail_raw(ty, &cause, &mut normalize, || {});
+        normalize(tail)
     }
 
     #[instrument(skip(self), level = "debug")]

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -461,7 +461,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             let projected_ty = curr_projected_ty.projection_ty_core(
                 tcx,
                 proj,
-                |ty| self.structurally_resolve(ty, locations),
+                |ty| self.normalize(ty, locations),
                 |ty, variant_index, field, ()| PlaceTy::field_ty(tcx, ty, variant_index, field),
                 |_| unreachable!(),
             );

compiler/rustc_hir_analysis/src/autoderef.rs

@@ -87,19 +87,7 @@ impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
         let (kind, new_ty) =
             if let Some(ty) = self.state.cur_ty.builtin_deref(self.include_raw_pointers) {
                 debug_assert_eq!(ty, self.infcx.resolve_vars_if_possible(ty));
-                // NOTE: we may still need to normalize the built-in deref in case
-                // we have some type like `&<Ty as Trait>::Assoc`, since users of
-                // autoderef expect this type to have been structurally normalized.
-                if self.infcx.next_trait_solver()
-                    && let ty::Alias(..) = ty.kind()
-                {
-                    let (normalized_ty, obligations) =
-                        self.structurally_normalize_ty(Unnormalized::new_wip(ty))?;
-                    self.state.obligations.extend(obligations);
-                    (AutoderefKind::Builtin, normalized_ty)
-                } else {
-                    (AutoderefKind::Builtin, ty)
-                }
+                (AutoderefKind::Builtin, ty)
             } else if let Some(ty) = self.overloaded_deref_ty(self.state.cur_ty) {
                 // The overloaded deref check already normalizes the pointee type.
                 (AutoderefKind::Overloaded, ty)
@@ -177,35 +165,27 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
             return None;
         }
 
-        let (normalized_ty, obligations) = self.structurally_normalize_ty(Unnormalized::new(
-            Ty::new_projection(tcx, trait_target_def_id, [ty]),
-        ))?;
+        let (normalized_ty, obligations) = self
+            .normalize_ty(Unnormalized::new(Ty::new_projection(tcx, trait_target_def_id, [ty])))?;
         debug!("overloaded_deref_ty({:?}) = ({:?}, {:?})", ty, normalized_ty, obligations);
         self.state.obligations.extend(obligations);
 
         Some(self.infcx.resolve_vars_if_possible(normalized_ty))
     }
 
     #[instrument(level = "debug", skip(self), ret)]
-    pub fn structurally_normalize_ty(
+    pub fn normalize_ty(
         &self,
         ty: Unnormalized<'tcx, Ty<'tcx>>,
     ) -> Option<(Ty<'tcx>, PredicateObligations<'tcx>)> {
         let ocx = ObligationCtxt::new(self.infcx);
-        let Ok(normalized_ty) = ocx.structurally_normalize_ty(
+        let normalized_ty = ocx.normalize(
             &traits::ObligationCause::misc(self.span, self.body_id),
             self.param_env,
             ty,
-        ) else {
-            // We shouldn't have errors here in the old solver, except for
-            // evaluate/fulfill mismatches, but that's not a reason for an ICE.
-            return None;
-        };
+        );
         let errors = ocx.try_evaluate_obligations();
         if !errors.is_empty() {
-            if self.infcx.next_trait_solver() {
-                unreachable!();
-            }
             // We shouldn't have errors here in the old solver, except for
             // evaluate/fulfill mismatches, but that's not a reason for an ICE.
             debug!(?errors, "encountered errors while fulfilling");

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -315,17 +315,6 @@ fn orphan_check<'tcx>(
             return Ok(user_ty);
         }
 
-        let ty = if infcx.next_trait_solver() {
-            ocx.structurally_normalize_ty(
-                &cause,
-                ty::ParamEnv::empty(),
-                Unnormalized::new_wip(infcx.resolve_vars_if_possible(ty)),
-            )
-            .unwrap_or(ty)
-        } else {
-            ty
-        };
-
         Ok::<_, !>(ty)
     };
 

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1099,23 +1099,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // Make sure to structurally resolve the types, since we use
             // the `TyKind`s heavily in coercion.
             let ocx = ObligationCtxt::new(self);
-            let structurally_resolve = |ty| {
-                let ty = self.shallow_resolve(ty);
-                if self.next_trait_solver()
-                    && let ty::Alias(..) = ty.kind()
-                {
-                    ocx.structurally_normalize_ty(&cause, self.param_env, Unnormalized::new_wip(ty))
-                } else {
-                    Ok(ty)
-                }
-            };
-            let Ok(expr_ty) = structurally_resolve(expr_ty) else {
-                return false;
-            };
-            let Ok(target_ty) = structurally_resolve(target_ty) else {
-                return false;
-            };
-
             let Ok(ok) = coerce.coerce(expr_ty, target_ty) else {
                 return false;
             };

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -2112,21 +2112,14 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                         // `WhereClauseCandidate` requires that the self type is a param,
                         // because it has special behavior with candidate preference as an
                         // inherent pick.
-                        match ocx.structurally_normalize_ty(
+                        let ty = ocx.normalize(
                             cause,
                             self.param_env,
                             Unnormalized::new_wip(trait_ref.self_ty()),
-                        ) {
-                            Ok(ty) => {
-                                if !matches!(ty.kind(), ty::Param(_)) {
-                                    debug!("--> not a param ty: {xform_self_ty:?}");
-                                    return ProbeResult::NoMatch;
-                                }
-                            }
-                            Err(errors) => {
-                                debug!("--> cannot relate self-types {:?}", errors);
-                                return ProbeResult::NoMatch;
-                            }
+                        );
+                        if !matches!(ty.kind(), ty::Param(_)) {
+                            debug!("--> not a param ty: {xform_self_ty:?}");
+                            return ProbeResult::NoMatch;
                         }
                     }
 

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -1586,13 +1586,11 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         |alias_term: ty::AliasTerm<'tcx>, expected_term: ty::Term<'tcx>| {
                             let ocx = ObligationCtxt::new(self);
 
-                            let Ok(normalized_term) = ocx.structurally_normalize_term(
+                            let normalized_term = ocx.normalize(
                                 &ObligationCause::dummy(),
                                 obligation.param_env,
                                 Unnormalized::new_wip(alias_term.to_term(self.tcx)),
-                            ) else {
-                                return None;
-                            };
+                            );
 
                             if let Err(terr) = ocx.eq(
                                 &ObligationCause::dummy(),
@@ -2859,13 +2857,11 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         );
         let trait_ref = normalized_predicate.trait_ref;
 
-        let Ok(assume) = ocx.structurally_normalize_const(
+        let assume = ocx.normalize(
             &obligation.cause,
             obligation.param_env,
             Unnormalized::new_wip(trait_ref.args.const_at(2)),
-        ) else {
-            return (obligation.clone(), trait_predicate);
-        };
+        );
 
         let Some(assume) = rustc_transmute::Assume::from_const(self.tcx, assume) else {
             return (obligation.clone(), trait_predicate);
@@ -2912,17 +2908,11 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             );
 
             let ocx = ObligationCtxt::new(self);
-            let Ok(assume) = ocx.structurally_normalize_const(
+            let assume = ocx.normalize(
                 &obligation.cause,
                 obligation.param_env,
                 Unnormalized::new_wip(trait_pred.trait_ref.args.const_at(2)),
-            ) else {
-                self.dcx().span_delayed_bug(
-                    span,
-                    "Unable to construct rustc_transmute::Assume where it was previously possible",
-                );
-                return GetSafeTransmuteErrorAndReason::Silent;
-            };
+            );
 
             let Some(assume) = rustc_transmute::Assume::from_const(self.infcx.tcx, assume) else {
                 self.dcx().span_delayed_bug(

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -258,7 +258,11 @@ fn do_normalize_predicates<'tcx>(
     elaborated_env: ty::ParamEnv<'tcx>,
     predicates: Vec<ty::Clause<'tcx>>,
 ) -> Result<Vec<ty::Clause<'tcx>>, ErrorGuaranteed> {
-    let span = cause.span;
+    // Even if we move back to eager normalization elsewhere,
+    // param env normalization remains lazy in the next solver.
+    if tcx.next_trait_solver_globally() {
+        return Ok(predicates);
+    }
 
     // FIXME. We should really... do something with these region
     // obligations. But this call just continues the older
@@ -273,6 +277,7 @@ fn do_normalize_predicates<'tcx>(
     // by wfcheck anyway, so I'm not sure we have to check
     // them here too, and we will remove this function when
     // we move over to lazy normalization *anyway*.
+    let span = cause.span;
     let infcx = tcx.infer_ctxt().ignoring_regions().build(TypingMode::non_body_analysis());
     let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
     let predicates = ocx.normalize(&cause, elaborated_env, Unnormalized::new_wip(predicates));

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -32,11 +32,11 @@ impl<'tcx> At<'_, 'tcx> {
         &self,
         value: Unnormalized<'tcx, T>,
     ) -> InferOk<'tcx, T> {
-        let value = value.skip_normalization();
         if self.infcx.next_trait_solver() {
             let Normalized { value, obligations } = crate::solve::normalize(*self, value);
             InferOk { value, obligations }
         } else {
+            let value = value.skip_normalization();
             let mut selcx = SelectionContext::new(self.infcx);
             let Normalized { value, obligations } =
                 normalize_with_depth(&mut selcx, self.param_env, self.cause.clone(), 0, value);

compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs

@@ -158,7 +158,12 @@ where
                 root_def_id,
                 "query type op",
                 span,
-                |ocx| QueryTypeOp::perform_locally_with_next_solver(ocx, self, span),
+                |ocx| {
+                    if let Some(result) = QueryTypeOp::try_fast_path(infcx.tcx, &self) {
+                        return Ok(result);
+                    }
+                    QueryTypeOp::perform_locally_with_next_solver(ocx, self, span)
+                },
             )?
             .0);
         }