(temporarily) skip normalization in rustdoc

Author: adwinwhite

src/librustdoc/clean/auto_trait.rs

@@ -22,7 +22,7 @@ pub(crate) fn synthesize_auto_trait_impls<'tcx>(
 ) -> Vec<clean::Item> {
     let tcx = cx.tcx;
     let typing_env = ty::TypingEnv::non_body_analysis(tcx, item_def_id);
-    let ty = tcx.type_of(item_def_id).instantiate_identity();
+    let ty = tcx.type_of(item_def_id).instantiate_identity().skip_normalization();
 
     let finder = auto_trait::AutoTraitFinder::new(tcx);
     let mut auto_trait_impls: Vec<_> = cx

src/librustdoc/clean/blanket_impl.rs

@@ -40,11 +40,11 @@ pub(crate) fn synthesize_blanket_impls(
             }
             let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
             let args = infcx.fresh_args_for_item(DUMMY_SP, item_def_id);
-            let impl_ty = ty.instantiate(tcx, args);
+            let impl_ty = ty.instantiate(tcx, args).skip_normalization();
             let param_env = ty::ParamEnv::empty();
 
             let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id);
-            let impl_trait_ref = trait_ref.instantiate(tcx, impl_args);
+            let impl_trait_ref = trait_ref.instantiate(tcx, impl_args).skip_normalization();
 
             // Require the type the impl is implemented on to match
             // our type, and ignore the impl if there was a mismatch.
@@ -60,8 +60,7 @@ pub(crate) fn synthesize_blanket_impls(
             drop(obligations);
 
             let predicates = tcx
-                .predicates_of(impl_def_id)
-                .instantiate(tcx, impl_args)
+                .predicates_of(impl_def_id).instantiate(tcx, impl_args).skip_normalization()
                 .predicates
                 .into_iter()
                 .chain(Some(impl_trait_ref.upcast(tcx)));
@@ -95,11 +94,11 @@ pub(crate) fn synthesize_blanket_impls(
                         // the post-inference `trait_ref`, as it's more accurate.
                         trait_: Some(clean_trait_ref_with_constraints(
                             cx,
-                            ty::Binder::dummy(trait_ref.instantiate_identity()),
+                            ty::Binder::dummy(trait_ref.instantiate_identity().skip_normalization()),
                             ThinVec::new(),
                         )),
                         for_: clean_middle_ty(
-                            ty::Binder::dummy(ty.instantiate_identity()),
+                            ty::Binder::dummy(ty.instantiate_identity().skip_normalization()),
                             cx,
                             None,
                             None,
@@ -112,7 +111,7 @@ pub(crate) fn synthesize_blanket_impls(
                             .collect(),
                         polarity: ty::ImplPolarity::Positive,
                         kind: clean::ImplKind::Blanket(Box::new(clean_middle_ty(
-                            ty::Binder::dummy(trait_ref.instantiate_identity().self_ty()),
+                            ty::Binder::dummy(trait_ref.instantiate_identity().skip_normalization().self_ty()),
                             cx,
                             None,
                             None,

src/librustdoc/clean/inline.rs

@@ -309,7 +309,7 @@ fn build_trait_alias(cx: &mut DocContext<'_>, did: DefId) -> clean::TraitAlias {
 }
 
 pub(super) fn build_function(cx: &mut DocContext<'_>, def_id: DefId) -> Box<clean::Function> {
-    let sig = cx.tcx.fn_sig(def_id).instantiate_identity();
+    let sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_normalization();
     // The generics need to be cleaned before the signature.
     let mut generics = clean_ty_generics(cx, def_id);
     let bound_vars = clean_bound_vars(sig.bound_vars(), cx.tcx);
@@ -369,7 +369,7 @@ fn build_type_alias(
     did: DefId,
     ret: &mut Vec<Item>,
 ) -> Box<clean::TypeAlias> {
-    let ty = cx.tcx.type_of(did).instantiate_identity();
+    let ty = cx.tcx.type_of(did).instantiate_identity().skip_normalization();
     let type_ = clean_middle_ty(ty::Binder::dummy(ty), cx, Some(did), None);
     let inner_type = clean_ty_alias_inner_type(ty, cx, ret);
 
@@ -488,7 +488,7 @@ pub(crate) fn build_impl(
     let for_ = match &impl_item {
         Some(impl_) => clean_ty(impl_.self_ty, cx),
         None => clean_middle_ty(
-            ty::Binder::dummy(tcx.type_of(did).instantiate_identity()),
+            ty::Binder::dummy(tcx.type_of(did).instantiate_identity().skip_normalization()),
             cx,
             Some(did),
             None,
@@ -749,7 +749,7 @@ fn build_const_item(cx: &mut DocContext<'_>, def_id: DefId) -> clean::Constant {
     let mut generics = clean_ty_generics(cx, def_id);
     clean::simplify::move_bounds_to_generic_parameters(&mut generics);
     let ty = clean_middle_ty(
-        ty::Binder::dummy(cx.tcx.type_of(def_id).instantiate_identity()),
+        ty::Binder::dummy(cx.tcx.type_of(def_id).instantiate_identity().skip_normalization()),
         cx,
         None,
         None,
@@ -760,7 +760,7 @@ fn build_const_item(cx: &mut DocContext<'_>, def_id: DefId) -> clean::Constant {
 fn build_static(cx: &mut DocContext<'_>, did: DefId, mutable: bool) -> clean::Static {
     clean::Static {
         type_: Box::new(clean_middle_ty(
-            ty::Binder::dummy(cx.tcx.type_of(did).instantiate_identity()),
+            ty::Binder::dummy(cx.tcx.type_of(did).instantiate_identity().skip_normalization()),
             cx,
             Some(did),
             None,

src/librustdoc/clean/mod.rs

@@ -46,7 +46,7 @@ use rustc_hir::{LangItem, PredicateOrigin, find_attr};
 use rustc_hir_analysis::{lower_const_arg_for_rustdoc, lower_ty};
 use rustc_middle::metadata::Reexport;
 use rustc_middle::middle::resolve_bound_vars as rbv;
-use rustc_middle::ty::{self, AdtKind, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt, TypingMode};
+use rustc_middle::ty::{self, AdtKind, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt, TypingMode, Unnormalized};
 use rustc_middle::{bug, span_bug};
 use rustc_span::ExpnKind;
 use rustc_span::hygiene::{AstPass, MacroKind};
@@ -507,7 +507,7 @@ fn clean_hir_term<'tcx>(
         hir::Term::Ty(ty) => Term::Type(clean_ty(ty, cx)),
         hir::Term::Const(c) => {
             // FIXME(generic_const_items): this should instantiate with the alias item's args
-            let ty = cx.tcx.type_of(assoc_item.unwrap()).instantiate_identity();
+            let ty = cx.tcx.type_of(assoc_item.unwrap()).instantiate_identity().skip_normalization();
             let ct = lower_const_arg_for_rustdoc(cx.tcx, c, ty);
             Term::Constant(clean_middle_const(ty::Binder::dummy(ct)))
         }
@@ -590,7 +590,7 @@ fn clean_generic_param_def(
                 && has_default
             {
                 Some(clean_middle_ty(
-                    ty::Binder::dummy(cx.tcx.type_of(def.def_id).instantiate_identity()),
+                    ty::Binder::dummy(cx.tcx.type_of(def.def_id).instantiate_identity().skip_normalization()),
                     cx,
                     Some(def.def_id),
                     None,
@@ -611,7 +611,7 @@ fn clean_generic_param_def(
             def.name,
             GenericParamDefKind::Const {
                 ty: Box::new(clean_middle_ty(
-                    ty::Binder::dummy(cx.tcx.type_of(def.def_id).instantiate_identity()),
+                    ty::Binder::dummy(cx.tcx.type_of(def.def_id).instantiate_identity().skip_normalization()),
                     cx,
                     Some(def.def_id),
                     None,
@@ -620,7 +620,7 @@ fn clean_generic_param_def(
                     && has_default
                 {
                     Some(Box::new(
-                        cx.tcx.const_param_default(def.def_id).instantiate_identity().to_string(),
+                        cx.tcx.const_param_default(def.def_id).instantiate_identity().skip_normalization().to_string(),
                     ))
                 } else {
                     None
@@ -1328,7 +1328,7 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
     let kind = match assoc_item.kind {
         ty::AssocKind::Const { .. } => {
             let ty = clean_middle_ty(
-                ty::Binder::dummy(tcx.type_of(assoc_item.def_id).instantiate_identity()),
+                ty::Binder::dummy(tcx.type_of(assoc_item.def_id).instantiate_identity().skip_normalization()),
                 cx,
                 Some(assoc_item.def_id),
                 None,
@@ -1364,12 +1364,12 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
             if has_self {
                 let self_ty = match assoc_item.container {
                     ty::AssocContainer::InherentImpl | ty::AssocContainer::TraitImpl(_) => {
-                        tcx.type_of(assoc_item.container_id(tcx)).instantiate_identity()
+                        tcx.type_of(assoc_item.container_id(tcx)).instantiate_identity().skip_normalization()
                     }
                     ty::AssocContainer::Trait => tcx.types.self_param,
                 };
                 let self_param_ty =
-                    tcx.fn_sig(assoc_item.def_id).instantiate_identity().input(0).skip_binder();
+                    tcx.fn_sig(assoc_item.def_id).instantiate_identity().skip_normalization().input(0).skip_binder();
                 if self_param_ty == self_ty {
                     item.decl.inputs[0].type_ = SelfTy;
                 } else if let ty::Ref(_, ty, _) = *self_param_ty.kind()
@@ -1423,7 +1423,7 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
 
             let mut predicates = tcx.explicit_predicates_of(assoc_item.def_id).predicates;
             if let ty::AssocContainer::Trait = assoc_item.container {
-                let bounds = tcx.explicit_item_bounds(assoc_item.def_id).iter_identity_copied();
+                let bounds = tcx.explicit_item_bounds(assoc_item.def_id).iter_identity_copied().map(Unnormalized::skip_normalization);
                 predicates = tcx.arena.alloc_from_iter(bounds.chain(predicates.iter().copied()));
             }
             let mut generics = clean_ty_generics_inner(
@@ -1509,7 +1509,7 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
                         Box::new(TypeAlias {
                             type_: clean_middle_ty(
                                 ty::Binder::dummy(
-                                    tcx.type_of(assoc_item.def_id).instantiate_identity(),
+                                    tcx.type_of(assoc_item.def_id).instantiate_identity().skip_normalization(),
                                 ),
                                 cx,
                                 Some(assoc_item.def_id),
@@ -1529,7 +1529,7 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
                     Box::new(TypeAlias {
                         type_: clean_middle_ty(
                             ty::Binder::dummy(
-                                tcx.type_of(assoc_item.def_id).instantiate_identity(),
+                                tcx.type_of(assoc_item.def_id).instantiate_identity().skip_normalization(),
                             ),
                             cx,
                             Some(assoc_item.def_id),
@@ -2267,7 +2267,7 @@ pub(crate) fn clean_middle_ty<'tcx>(
                     clean_middle_path(cx, def_id, false, ThinVec::new(), bound_ty.rebind(args));
                 Type::Path { path }
             } else {
-                let ty = cx.tcx.type_of(def_id).instantiate(cx.tcx, args);
+                let ty = cx.tcx.type_of(def_id).instantiate(cx.tcx, args).skip_normalization();
                 clean_middle_ty(bound_ty.rebind(ty), cx, None, None)
             }
         }
@@ -2328,8 +2328,7 @@ fn clean_middle_opaque_bounds<'tcx>(
 
     let bounds: Vec<_> = cx
         .tcx
-        .explicit_item_bounds(impl_trait_def_id)
-        .iter_instantiated_copied(cx.tcx, args)
+        .explicit_item_bounds(impl_trait_def_id).iter_instantiated_copied(cx.tcx, args).map(Unnormalized::skip_normalization)
         .collect();
 
     let mut bounds = bounds
@@ -2427,7 +2426,7 @@ pub(crate) fn clean_middle_field(field: &ty::FieldDef, cx: &mut DocContext<'_>)
         field.did,
         field.name,
         clean_middle_ty(
-            ty::Binder::dummy(cx.tcx.type_of(field.did).instantiate_identity()),
+            ty::Binder::dummy(cx.tcx.type_of(field.did).instantiate_identity().skip_normalization()),
             cx,
             Some(field.did),
             None,
@@ -2491,7 +2490,7 @@ pub(crate) fn clean_variant_def_with_args<'tcx>(
                 .fields
                 .iter()
                 .map(|field| {
-                    let ty = cx.tcx.type_of(field.did).instantiate(cx.tcx, args);
+                    let ty = cx.tcx.type_of(field.did).instantiate(cx.tcx, args).skip_normalization();
 
                     // normalize the type to only show concrete types
                     // note: we do not use try_normalize_erasing_regions since we
@@ -2516,7 +2515,7 @@ pub(crate) fn clean_variant_def_with_args<'tcx>(
                 .fields
                 .iter()
                 .map(|field| {
-                    let ty = cx.tcx.type_of(field.did).instantiate(cx.tcx, args);
+                    let ty = cx.tcx.type_of(field.did).instantiate(cx.tcx, args).skip_normalization();
 
                     // normalize the type to only show concrete types
                     // note: we do not use try_normalize_erasing_regions since we
@@ -2860,7 +2859,7 @@ fn clean_maybe_renamed_item<'tcx>(
                     }
                 }
 
-                let ty = cx.tcx.type_of(def_id).instantiate_identity();
+                let ty = cx.tcx.type_of(def_id).instantiate_identity().skip_normalization();
 
                 let mut ret = Vec::new();
                 let inner_type = clean_ty_alias_inner_type(ty, cx, &mut ret);
@@ -2992,7 +2991,7 @@ fn clean_impl<'tcx>(
     let type_alias =
         for_.def_id(&cx.cache).and_then(|alias_def_id: DefId| match tcx.def_kind(alias_def_id) {
             DefKind::TyAlias => Some(clean_middle_ty(
-                ty::Binder::dummy(tcx.type_of(def_id).instantiate_identity()),
+                ty::Binder::dummy(tcx.type_of(def_id).instantiate_identity().skip_normalization()),
                 cx,
                 Some(def_id.to_def_id()),
                 None,

src/librustdoc/clean/simplify.rs

@@ -15,7 +15,7 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_data_structures::unord::UnordSet;
 use rustc_hir::def_id::DefId;
-use rustc_middle::ty::TyCtxt;
+use rustc_middle::ty::{TyCtxt, Unnormalized};
 
 use crate::clean;
 use crate::clean::{GenericArgs as PP, WherePredicate as WP};
@@ -114,8 +114,7 @@ fn trait_is_same_or_supertrait(tcx: TyCtxt<'_>, child: DefId, trait_: DefId) ->
         return true;
     }
     let predicates = tcx.explicit_super_predicates_of(child);
-    predicates
-        .iter_identity_copied()
+    predicates.iter_identity_copied().map(Unnormalized::skip_normalization)
         .filter_map(|(pred, _)| Some(pred.as_trait_clause()?.def_id()))
         .any(|did| trait_is_same_or_supertrait(tcx, did, trait_))
 }

src/librustdoc/clean/utils.rs

@@ -126,7 +126,7 @@ pub(crate) fn clean_middle_generic_args<'tcx>(
 
         // Elide arguments that coincide with their default.
         if !elision_has_failed_once_before && let Some(default) = param.default_value(cx.tcx) {
-            let default = default.instantiate(cx.tcx, args.as_ref());
+            let default = default.instantiate(cx.tcx, args.as_ref()).skip_normalization();
             if can_elide_generic_arg(arg, arg.rebind(default)) {
                 return None;
             }
@@ -371,7 +371,7 @@ pub(crate) fn print_evaluated_const(
     with_type: bool,
 ) -> Option<String> {
     tcx.const_eval_poly(def_id).ok().and_then(|val| {
-        let ty = tcx.type_of(def_id).instantiate_identity();
+        let ty = tcx.type_of(def_id).instantiate_identity().skip_normalization();
         match (val, ty.kind()) {
             (_, &ty::Ref(..)) => None,
             (mir::ConstValue::Scalar(_), &ty::Adt(_, _)) => None,

src/librustdoc/formats/cache.rs

@@ -425,7 +425,7 @@ impl DocFolder for CacheBuilder<'_, '_> {
                     dids.insert(path.def_id());
                     if let Some(generics) = path.generics()
                         && let ty::Adt(adt, _) =
-                            self.tcx.type_of(path.def_id()).instantiate_identity().kind()
+                            self.tcx.type_of(path.def_id()).instantiate_identity().skip_normalization().kind()
                         && adt.is_fundamental()
                     {
                         for ty in generics {

src/librustdoc/html/format.rs

@@ -441,7 +441,7 @@ fn generate_item_def_id_path(
         let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
         def_id = infcx
             .at(&ObligationCause::dummy(), tcx.param_env(def_id))
-            .query_normalize(ty::Binder::dummy(tcx.type_of(def_id).instantiate_identity()))
+            .query_normalize(ty::Binder::dummy(tcx.type_of(def_id).instantiate_identity().skip_normalization()))
             .map(|resolved| infcx.resolve_vars_if_possible(resolved.value))
             .ok()
             .and_then(|normalized| normalized.skip_binder().ty_adt_def())

src/librustdoc/html/render/mod.rs

@@ -2995,7 +2995,7 @@ fn repr_attribute<'tcx>(
             // Side note: There can only ever be one or zero non-1-ZST fields.
             let non_1zst_field = var.fields.iter().find(|field| {
                 let ty = ty::TypingEnv::post_analysis(tcx, field.did)
-                    .as_query_input(tcx.type_of(field.did).instantiate_identity());
+                    .as_query_input(tcx.type_of(field.did).instantiate_identity().skip_normalization());
                 tcx.layout_of(ty).is_ok_and(|layout| !layout.is_1zst())
             });
 

src/librustdoc/html/render/print_item.rs

@@ -1275,7 +1275,7 @@ fn item_type_alias(cx: &Context<'_>, it: &clean::Item, t: &clean::TypeAlias) ->
 
             match inner_type {
                 clean::TypeAliasInnerType::Enum { variants, is_non_exhaustive } => {
-                    let ty = cx.tcx().type_of(it.def_id().unwrap()).instantiate_identity();
+                    let ty = cx.tcx().type_of(it.def_id().unwrap()).instantiate_identity().skip_normalization();
                     let enum_def_id = ty.ty_adt_def().unwrap().did();
 
                     DisplayEnum {
@@ -1287,7 +1287,7 @@ fn item_type_alias(cx: &Context<'_>, it: &clean::Item, t: &clean::TypeAlias) ->
                     .render_into(cx, it, true, w)?;
                 }
                 clean::TypeAliasInnerType::Union { fields } => {
-                    let ty = cx.tcx().type_of(it.def_id().unwrap()).instantiate_identity();
+                    let ty = cx.tcx().type_of(it.def_id().unwrap()).instantiate_identity().skip_normalization();
                     let union_def_id = ty.ty_adt_def().unwrap().did();
 
                     ItemUnion {
@@ -1301,7 +1301,7 @@ fn item_type_alias(cx: &Context<'_>, it: &clean::Item, t: &clean::TypeAlias) ->
                     .render_into(w)?;
                 }
                 clean::TypeAliasInnerType::Struct { ctor_kind, fields } => {
-                    let ty = cx.tcx().type_of(it.def_id().unwrap()).instantiate_identity();
+                    let ty = cx.tcx().type_of(it.def_id().unwrap()).instantiate_identity().skip_normalization();
                     let struct_def_id = ty.ty_adt_def().unwrap().did();
 
                     DisplayStruct {