fix(upstream): add Unnormalized and skip_norm_wip

Author: nbdd0121

flake.lock

@@ -41,11 +41,11 @@ pub fn build_drop_shim<'tcx>(
     if let ty::Coroutine(gen_def_id, args) = ty.kind() {
         let body = cx.analysis_mir(*gen_def_id).coroutine_drop().unwrap();
         let body = EarlyBinder::bind(body.clone()).instantiate(cx.tcx, args);
-        return body;
+        return body.skip_norm_wip();
     }
 
     let args = cx.mk_args(&[ty.into()]);
-    let sig = cx.fn_sig(def_id).instantiate(cx.tcx, args);
+    let sig = cx.fn_sig(def_id).instantiate(cx.tcx, args).skip_norm_wip();
     let sig = cx.instantiate_bound_regions_with_erased(sig);
     let span = cx.def_span(def_id);
 

src/mir/drop_shim.rs

@@ -11,7 +11,7 @@ use rustc_index::Idx;
 use rustc_middle::mir::*;
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::util::IntTypeExt;
-use rustc_middle::ty::{self, GenericArg, GenericArgsRef, Ty, TyCtxt};
+use rustc_middle::ty::{self, GenericArg, GenericArgsRef, Ty, TyCtxt, Unnormalized};
 use rustc_middle::{span_bug, traits};
 use rustc_span::{DUMMY_SP, Spanned, dummy_spanned};
 use tracing::{debug, instrument};
@@ -304,7 +304,10 @@ where
             // Resolving async_drop_in_place<T> function for drop_ty
             let drop_fn_def_id = tcx.require_lang_item(LangItem::AsyncDropInPlace, span);
             let trait_args = tcx.mk_args(&[drop_ty.into()]);
-            let sig = tcx.fn_sig(drop_fn_def_id).instantiate(tcx, trait_args);
+            let sig = tcx
+                .fn_sig(drop_fn_def_id)
+                .instantiate(tcx, trait_args)
+                .skip_norm_wip();
             let sig = tcx.instantiate_bound_regions_with_erased(sig);
             (sig.output(), drop_fn_def_id, trait_args)
         };
@@ -558,9 +561,10 @@ where
                         bug!()
                     }
                 }
+                let field_ty = field.ty(tcx, args);
                 let field_ty = match tcx.try_normalize_erasing_regions(
                     self.elaborator.typing_env(),
-                    field.ty(tcx, args),
+                    Unnormalized::new_wip(field_ty),
                 ) {
                     Ok(t) => t,
                     Err(_) => Ty::new_error(

src/mir/elaborate_drop.rs

@@ -29,7 +29,7 @@ use rustc_middle::ty::adjustment::{CustomCoerceUnsized, PointerCoercion};
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
     self, GenericArgs, GenericParamDefKind, Instance, InstanceKind, Ty, TyCtxt, TypeFoldable,
-    TypeVisitableExt, VtblEntry,
+    TypeVisitableExt, Unnormalized, VtblEntry,
 };
 use rustc_session::config::{DebugInfo, EntryFnType};
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Spanned, dummy_spanned, respan};
@@ -960,10 +960,14 @@ pub fn find_tails_for_unsizing<'tcx>(
                 };
             let coerce_field = &source_adt_def.non_enum_variant().fields[coerce_index];
             // We're getting a possibly unnormalized type, so normalize it.
-            let source_field =
-                tcx.normalize_erasing_regions(typing_env, coerce_field.ty(*tcx, source_args));
-            let target_field =
-                tcx.normalize_erasing_regions(typing_env, coerce_field.ty(*tcx, target_args));
+            let source_field = tcx.normalize_erasing_regions(
+                typing_env,
+                Unnormalized::new_wip(coerce_field.ty(*tcx, source_args)),
+            );
+            let target_field = tcx.normalize_erasing_regions(
+                typing_env,
+                Unnormalized::new_wip(coerce_field.ty(*tcx, target_args)),
+            );
             find_tails_for_unsizing(tcx, typing_env, source_field, target_field)
         }
         _ => bug!(
@@ -1320,7 +1324,8 @@ impl<'v> RootCollector<'_, 'v> {
                     let ty = self
                         .tcx
                         .type_of(id.owner_id.to_def_id())
-                        .instantiate(self.tcx, id_args);
+                        .instantiate(self.tcx, id_args)
+                        .skip_norm_wip();
                     assert!(!ty.has_non_region_param());
                     visit_drop_use(self.tcx, ty, true, DUMMY_SP, self.output);
                 }
@@ -1379,25 +1384,36 @@ impl<'v> RootCollector<'_, 'v> {
         match self.tcx.def_kind(def_id) {
             DefKind::Closure => {
                 // for 'pub async fn foo(..)' also trying to monomorphize foo::{closure}
-                let is_pub_fn_coroutine =
-                    match *self.tcx.type_of(def_id).instantiate_identity().kind() {
-                        ty::Coroutine(cor_id, _args) => {
-                            let tcx = self.tcx;
-                            let parent_id = tcx.parent(cor_id);
-                            tcx.def_kind(parent_id) == DefKind::Fn
-                                && tcx.asyncness(parent_id).is_async()
-                                && tcx.visibility(parent_id).is_public()
-                        }
-                        ty::Closure(..) | ty::CoroutineClosure(..) => false,
-                        _ => unreachable!(),
-                    };
+                let is_pub_fn_coroutine = match *self
+                    .tcx
+                    .type_of(def_id)
+                    .instantiate_identity()
+                    .skip_norm_wip()
+                    .kind()
+                {
+                    ty::Coroutine(cor_id, _args) => {
+                        let tcx = self.tcx;
+                        let parent_id = tcx.parent(cor_id);
+                        tcx.def_kind(parent_id) == DefKind::Fn
+                            && tcx.asyncness(parent_id).is_async()
+                            && tcx.visibility(parent_id).is_public()
+                    }
+                    ty::Closure(..) | ty::CoroutineClosure(..) => false,
+                    _ => unreachable!(),
+                };
                 if (self.strategy == MonoItemCollectionStrategy::Eager || is_pub_fn_coroutine)
                     && !self
                         .tcx
                         .generics_of(self.tcx.typeck_root_def_id(def_id.to_def_id()))
                         .requires_monomorphization(self.tcx)
                 {
-                    let instance = match *self.tcx.type_of(def_id).instantiate_identity().kind() {
+                    let instance = match *self
+                        .tcx
+                        .type_of(def_id)
+                        .instantiate_identity()
+                        .skip_norm_wip()
+                        .kind()
+                    {
                         ty::Closure(def_id, args)
                         | ty::Coroutine(def_id, args)
                         | ty::CoroutineClosure(def_id, args) => {
@@ -1407,7 +1423,7 @@ impl<'v> RootCollector<'_, 'v> {
                     };
                     let Ok(instance) = self.tcx.try_normalize_erasing_regions(
                         ty::TypingEnv::fully_monomorphized(),
-                        instance,
+                        Unnormalized::new_wip(instance),
                     ) else {
                         // Don't ICE on an impossible-to-normalize closure.
                         return;
@@ -1489,7 +1505,7 @@ impl<'v> RootCollector<'_, 'v> {
         // listing.
         let main_ret_ty = self.tcx.normalize_erasing_regions(
             ty::TypingEnv::fully_monomorphized(),
-            main_ret_ty.no_bound_vars().unwrap(),
+            Unnormalized::new_wip(main_ret_ty.no_bound_vars().unwrap()),
         );
 
         let start_instance = Instance::expect_resolve(
@@ -1538,7 +1554,7 @@ fn create_mono_items_for_default_impls<'tcx>(
         }
     };
     let impl_args = GenericArgs::for_item(tcx, item.owner_id.to_def_id(), only_region_params);
-    let trait_ref = impl_.trait_ref.instantiate(tcx, impl_args);
+    let trait_ref = impl_.trait_ref.instantiate(tcx, impl_args).skip_norm_wip();
 
     // Unlike 'lazy' monomorphization that begins by collecting items transitively
     // called by `main` or other global items, when eagerly monomorphizing impl
@@ -1554,7 +1570,7 @@ fn create_mono_items_for_default_impls<'tcx>(
     }
 
     let typing_env = ty::TypingEnv::fully_monomorphized();
-    let trait_ref = tcx.normalize_erasing_regions(typing_env, trait_ref);
+    let trait_ref = tcx.normalize_erasing_regions(typing_env, Unnormalized::new_wip(trait_ref));
     let overridden_methods = tcx.impl_item_implementor_ids(item.owner_id);
     for method in tcx.provided_trait_methods(trait_ref.def_id) {
         if overridden_methods.contains_key(&method.def_id) {

src/monomorphize_collector.rs

@@ -10,7 +10,7 @@ use rustc_middle::mir::{self, Body, Location, visit::Visitor as MirVisitor};
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::{
     self, GenericArgs, GenericParamDefKind, Instance, PseudoCanonicalInput, Ty, TyCtxt,
-    TypeFoldable, TypeVisitableExt, TypingEnv, Upcast,
+    TypeFoldable, TypeVisitableExt, TypingEnv, Unnormalized, Upcast,
 };
 use rustc_span::{DUMMY_SP, Span};
 
@@ -511,6 +511,7 @@ memoize!(
                 let super_traits = cx
                     .explicit_super_predicates_of(trait_ref.def_id())
                     .iter_identity_copied()
+                    .map(Unnormalized::skip_norm_wip)
                     .filter_map(|(pred, _)| {
                         pred.instantiate_supertrait(cx.tcx, trait_ref)
                             .as_trait_clause()
@@ -537,7 +538,9 @@ memoize!(
                     let predicates = cx.predicates_of(entry).instantiate_own(cx.tcx, args);
                     if rustc_trait_selection::traits::impossible_predicates(
                         cx.tcx,
-                        predicates.map(|(predicate, _)| predicate).collect(),
+                        predicates
+                            .map(|(predicate, _)| predicate.skip_norm_wip())
+                            .collect(),
                     ) {
                         continue;
                     }