Rename structurally_normalize to structurally_normalize_ty

Author: BoxyUwU

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -185,7 +185,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 CustomTypeOp::new(
  |ocx| {
 let structurally_normalize = |ty| {
- ocx.structurally_normalize(
+ ocx.structurally_normalize_ty(
 &ObligationCause::misc(
  location.to_locations().span(body),
  body.source.def_id().expect_local(),
@@ -230,7 +230,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 ConstraintCategory::Boring,
 CustomTypeOp::new(
  |ocx| {
- ocx.structurally_normalize(
+ ocx.structurally_normalize_ty(
 &ObligationCause::misc(
  location.to_locations().span(body),
  body.source.def_id().expect_local(),

compiler/rustc_hir_analysis/src/autoderef.rs

@@ -86,7 +86,7 @@ impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
 ifself.infcx.next_trait_solver()
  && let ty::Alias(..) = ty.kind()
 {
-let(normalized_ty, obligations) = self.structurally_normalize(ty)?;
+let(normalized_ty, obligations) = self.structurally_normalize_ty(ty)?;
 self.state.obligations.extend(obligations);
 (AutoderefKind::Builtin, normalized_ty)
 }else{
@@ -166,20 +166,20 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
 }
 
 let(normalized_ty, obligations) =
-self.structurally_normalize(Ty::new_projection(tcx, trait_target_def_id,[ty]))?;
+self.structurally_normalize_ty(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)]
-pubfnstructurally_normalize(
+pubfnstructurally_normalize_ty(
 &self,
 ty:Ty<'tcx>,
 ) -> Option<(Ty<'tcx>,PredicateObligations<'tcx>)>{
 let ocx = ObligationCtxt::new(self.infcx);
-letOk(normalized_ty) = ocx.structurally_normalize(
+letOk(normalized_ty) = ocx.structurally_normalize_ty(
 &traits::ObligationCause::misc(self.span,self.body_id),
 self.param_env,
  ty,

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -320,7 +320,7 @@ fn orphan_check<'tcx>(
 }
 
 let ty = if infcx.next_trait_solver(){
- ocx.structurally_normalize(
+ ocx.structurally_normalize_ty(
 &cause,
  ty::ParamEnv::empty(),
  infcx.resolve_vars_if_possible(ty),

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1124,7 +1124,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 ifself.next_trait_solver()
  && let ty::Alias(..) = ty.kind()
 {
- ocx.structurally_normalize(&cause,self.param_env, ty)
+ ocx.structurally_normalize_ty(&cause,self.param_env, ty)
 }else{
 Ok(ty)
 }

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1433,7 +1433,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 // in a reentrant borrow, causing an ICE.
 let result = self
 .at(&self.misc(sp),self.param_env)
-.structurally_normalize(ty,&mut**self.fulfillment_cx.borrow_mut());
+.structurally_normalize_ty(ty,&mut**self.fulfillment_cx.borrow_mut());
 match result {
 Ok(normalized_ty) => normalized_ty,
 Err(errors) => {

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -709,7 +709,7 @@ impl<'a, 'tcx> ProofTreeVisitor<'tcx> for AmbiguityCausesVisitor<'a, 'tcx> {
 ifmatches!(ty.kind(), ty::Alias(..)){
 let ocx = ObligationCtxt::new(infcx);
  ty = ocx
-.structurally_normalize(&ObligationCause::dummy(), param_env, ty)
+.structurally_normalize_ty(&ObligationCause::dummy(), param_env, ty)
 .map_err(|_| ())?;
 if !ocx.select_where_possible().is_empty(){
 returnErr(());

compiler/rustc_trait_selection/src/traits/engine.rs

@@ -319,15 +319,15 @@ where
 self.infcx.at(cause, param_env).deeply_normalize(value,&mut**self.engine.borrow_mut())
 }
 
-pubfnstructurally_normalize(
+pubfnstructurally_normalize_ty(
 &self,
 cause:&ObligationCause<'tcx>,
 param_env: ty::ParamEnv<'tcx>,
 value:Ty<'tcx>,
 ) -> Result<Ty<'tcx>,Vec<E>>{
 self.infcx
 .at(cause, param_env)
-.structurally_normalize(value,&mut**self.engine.borrow_mut())
+.structurally_normalize_ty(value,&mut**self.engine.borrow_mut())
 }
 
 pubfnstructurally_normalize_const(

compiler/rustc_trait_selection/src/traits/structural_normalize.rs

@@ -7,7 +7,7 @@ use crate::traits::{NormalizeExt, Obligation};
 
 #[extension(pubtraitStructurallyNormalizeExt<'tcx>)]
 impl<'tcx>At<'_,'tcx>{
-fnstructurally_normalize<E:'tcx>(
+fnstructurally_normalize_ty<E:'tcx>(
 &self,
 ty:Ty<'tcx>,
 fulfill_cx:&mutdynTraitEngine<'tcx,E>,