Rename Instance::new to Instance::new_raw and add a note that it is raw

compiler-errors · compiler-errors · commit 9cb372722d24 · 2025-04-28T14:40:57.000Z
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -1282,7 +1282,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
                     intrinsic.name,
                 );
             }
-            return Err(Instance::new(instance.def_id(), instance.args));
+            return Err(Instance::new_raw(instance.def_id(), instance.args));
         }
     }
 
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -399,7 +399,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
             }
 
             // Fall back to default body
-            _ => return Err(Instance::new(instance.def_id(), instance.args)),
+            _ => return Err(Instance::new_raw(instance.def_id(), instance.args)),
         };
 
         if !fn_abi.ret.is_ignore() {
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/unused.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/unused.rs
@@ -157,7 +157,7 @@ fn make_dummy_instance<'tcx>(tcx: TyCtxt<'tcx>, local_def_id: LocalDefId) -> ty:
     let def_id = local_def_id.to_def_id();
 
     // Make a dummy instance that fills in all generics with placeholders.
-    ty::Instance::new(
+    ty::Instance::new_raw(
         def_id,
         ty::GenericArgs::for_item(tcx, def_id, |param, _| {
             if let ty::GenericParamDefKind::Lifetime = param.kind {
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -613,7 +613,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             _ => {
                 debug!("unknown intrinsic '{}' -- falling back to default body", name);
                 // Call the fallback body instead of generating the intrinsic code
-                return Err(ty::Instance::new(instance.def_id(), instance.args));
+                return Err(ty::Instance::new_raw(instance.def_id(), instance.args));
             }
         };
 
diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
@@ -556,7 +556,7 @@ pub(crate) fn symbol_name_for_instance_in_crate<'tcx>(
         ExportedSymbol::Generic(def_id, args) => {
             rustc_symbol_mangling::symbol_name_for_instance_in_crate(
                 tcx,
-                Instance::new(def_id, args),
+                Instance::new_raw(def_id, args),
                 instantiating_crate,
             )
         }
@@ -597,7 +597,7 @@ fn calling_convention_for_symbol<'tcx>(
             None
         }
         ExportedSymbol::NonGeneric(def_id) => Some(Instance::mono(tcx, def_id)),
-        ExportedSymbol::Generic(def_id, args) => Some(Instance::new(def_id, args)),
+        ExportedSymbol::Generic(def_id, args) => Some(Instance::new_raw(def_id, args)),
         // DropGlue always use the Rust calling convention and thus follow the target's default
         // symbol decoration scheme.
         ExportedSymbol::DropGlue(..) => None,
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
@@ -216,7 +216,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
                 check::maybe_check_static_with_link_section(tcx, item_def_id);
             }
             DefKind::Const if tcx.generics_of(item_def_id).is_empty() => {
-                let instance = ty::Instance::new(item_def_id.into(), ty::GenericArgs::empty());
+                let instance = ty::Instance::new_raw(item_def_id.into(), ty::GenericArgs::empty());
                 let cid = GlobalId { instance, promoted: None };
                 let typing_env = ty::TypingEnv::fully_monomorphized();
                 tcx.ensure_ok().eval_to_const_value_raw(typing_env.as_query_input(cid));
diff --git a/compiler/rustc_lint/src/foreign_modules.rs b/compiler/rustc_lint/src/foreign_modules.rs
@@ -104,7 +104,7 @@ impl ClashingExternDeclarations {
     /// for the item, return its HirId without updating the set.
     fn insert(&mut self, tcx: TyCtxt<'_>, fi: hir::ForeignItemId) -> Option<hir::OwnerId> {
         let did = fi.owner_id.to_def_id();
-        let instance = Instance::new(did, ty::List::identity_for_item(tcx, did));
+        let instance = Instance::new_raw(did, ty::List::identity_for_item(tcx, did));
         let name = Symbol::intern(tcx.symbol_name(instance).name);
         if let Some(&existing_id) = self.seen_decls.get(&name) {
             // Avoid updating the map with the new entry when we do find a collision. We want to
diff --git a/compiler/rustc_middle/src/middle/exported_symbols.rs b/compiler/rustc_middle/src/middle/exported_symbols.rs
@@ -55,7 +55,7 @@ impl<'tcx> ExportedSymbol<'tcx> {
         match *self {
             ExportedSymbol::NonGeneric(def_id) => tcx.symbol_name(ty::Instance::mono(tcx, def_id)),
             ExportedSymbol::Generic(def_id, args) => {
-                tcx.symbol_name(ty::Instance::new(def_id, args))
+                tcx.symbol_name(ty::Instance::new_raw(def_id, args))
             }
             ExportedSymbol::DropGlue(ty) => {
                 tcx.symbol_name(ty::Instance::resolve_drop_in_place(tcx, ty))
diff --git a/compiler/rustc_middle/src/mir/interpret/queries.rs b/compiler/rustc_middle/src/mir/interpret/queries.rs
@@ -23,7 +23,7 @@ impl<'tcx> TyCtxt<'tcx> {
         // into `const_eval` which will return `ErrorHandled::TooGeneric` if any of them are
         // encountered.
         let args = GenericArgs::identity_for_item(self, def_id);
-        let instance = ty::Instance::new(def_id, args);
+        let instance = ty::Instance::new_raw(def_id, args);
         let cid = GlobalId { instance, promoted: None };
         let typing_env = ty::TypingEnv::post_analysis(self, def_id);
         self.const_eval_global_id(typing_env, cid, DUMMY_SP)
@@ -39,7 +39,7 @@ impl<'tcx> TyCtxt<'tcx> {
         // into `const_eval` which will return `ErrorHandled::TooGeneric` if any of them are
         // encountered.
         let args = GenericArgs::identity_for_item(self, def_id);
-        let instance = ty::Instance::new(def_id, args);
+        let instance = ty::Instance::new_raw(def_id, args);
         let cid = GlobalId { instance, promoted: None };
         let typing_env = ty::TypingEnv::post_analysis(self, def_id);
         let inputs = self.erase_regions(typing_env.as_query_input(cid));
@@ -208,7 +208,7 @@ impl<'tcx> TyCtxtEnsureOk<'tcx> {
         // into `const_eval` which will return `ErrorHandled::TooGeneric` if any of them are
         // encountered.
         let args = GenericArgs::identity_for_item(self.tcx, def_id);
-        let instance = ty::Instance::new(def_id, self.tcx.erase_regions(args));
+        let instance = ty::Instance::new_raw(def_id, self.tcx.erase_regions(args));
         let cid = GlobalId { instance, promoted: None };
         let typing_env = ty::TypingEnv::post_analysis(self.tcx, def_id);
         // Const-eval shouldn't depend on lifetimes at all, so we can erase them, which should
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
@@ -318,7 +318,7 @@ impl<'tcx> fmt::Display for MonoItem<'tcx> {
         match *self {
             MonoItem::Fn(instance) => write!(f, "fn {instance}"),
             MonoItem::Static(def_id) => {
-                write!(f, "static {}", Instance::new(def_id, GenericArgs::empty()))
+                write!(f, "static {}", Instance::new_raw(def_id, GenericArgs::empty()))
             }
             MonoItem::GlobalAsm(..) => write!(f, "global_asm"),
         }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
@@ -2455,7 +2455,7 @@ rustc_queries! {
     query resolve_instance_raw(
         key: ty::PseudoCanonicalInput<'tcx, (DefId, GenericArgsRef<'tcx>)>
     ) -> Result<Option<ty::Instance<'tcx>>, ErrorGuaranteed> {
-        desc { "resolving instance `{}`", ty::Instance::new(key.value.0, key.value.1) }
+        desc { "resolving instance `{}`", ty::Instance::new_raw(key.value.0, key.value.1) }
     }
 
     query reveal_opaque_types_in_bounds(key: ty::Clauses<'tcx>) -> ty::Clauses<'tcx> {
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
@@ -426,7 +426,10 @@ impl<'tcx> fmt::Display for Instance<'tcx> {
 }
 
 impl<'tcx> Instance<'tcx> {
-    pub fn new(def_id: DefId, args: GenericArgsRef<'tcx>) -> Instance<'tcx> {
+    /// Creates a new [`InstanceKind::Item`] from the `def_id` and `args`. Note that this
+    /// does not resolve trait items to their corresponding impl items -- to do that, use
+    /// [`Instance::expect_resolve`] instead.
+    pub fn new_raw(def_id: DefId, args: GenericArgsRef<'tcx>) -> Instance<'tcx> {
         assert!(
             !args.has_escaping_bound_vars(),
             "args of instance {def_id:?} has escaping bound vars: {args:?}"
@@ -445,7 +448,7 @@ impl<'tcx> Instance<'tcx> {
             }
         });
 
-        Instance::new(def_id, args)
+        Instance::new_raw(def_id, args)
     }
 
     #[inline]
@@ -538,7 +541,7 @@ impl<'tcx> Instance<'tcx> {
                 let type_length = type_length(args);
                 if !tcx.type_length_limit().value_within_limit(type_length) {
                     let (shrunk, written_to_path) =
-                        shrunk_instance_name(tcx, Instance::new(def_id, args));
+                        shrunk_instance_name(tcx, Instance::new_raw(def_id, args));
                     let mut path = PathBuf::new();
                     let was_written = if let Some(path2) = written_to_path {
                         path = path2;
@@ -708,7 +711,7 @@ impl<'tcx> Instance<'tcx> {
 
         match needs_fn_once_adapter_shim(actual_kind, requested_kind) {
             Ok(true) => Instance::fn_once_adapter_instance(tcx, def_id, args),
-            _ => Instance::new(def_id, args),
+            _ => Instance::new_raw(def_id, args),
         }
     }
 
@@ -822,7 +825,7 @@ impl<'tcx> Instance<'tcx> {
             // This is important for `Iterator`'s combinators, but also useful for
             // adding future default methods to `Future`, for instance.
             debug_assert!(tcx.defaultness(trait_item_id).has_value());
-            Some(Instance::new(trait_item_id, rcvr_args))
+            Some(Instance::new_raw(trait_item_id, rcvr_args))
         }
     }
 
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
@@ -913,7 +913,7 @@ fn visit_instance_use<'tcx>(
             // We explicitly skip this otherwise to ensure we get a linker error
             // if anyone tries to call this intrinsic and the codegen backend did not
             // override the implementation.
-            let instance = ty::Instance::new(instance.def_id(), instance.args);
+            let instance = ty::Instance::new_raw(instance.def_id(), instance.args);
             if tcx.should_codegen_locally(instance) {
                 output.push(create_fn_mono_item(tcx, instance, source));
             }
@@ -1500,7 +1500,7 @@ impl<'v> RootCollector<'_, 'v> {
                         ty::Closure(def_id, args)
                         | ty::Coroutine(def_id, args)
                         | ty::CoroutineClosure(def_id, args) => {
-                            Instance::new(def_id, self.tcx.erase_regions(args))
+                            Instance::new_raw(def_id, self.tcx.erase_regions(args))
                         }
                         _ => unreachable!(),
                     };
diff --git a/compiler/rustc_smir/src/rustc_smir/builder.rs b/compiler/rustc_smir/src/rustc_smir/builder.rs
@@ -22,7 +22,7 @@ impl<'tcx> BodyBuilder<'tcx> {
     pub(crate) fn new(tcx: TyCtxt<'tcx>, instance: ty::Instance<'tcx>) -> Self {
         let instance = match instance.def {
             // To get the fallback body of an intrinsic, we need to convert it to an item.
-            ty::InstanceKind::Intrinsic(def_id) => ty::Instance::new(def_id, instance.args),
+            ty::InstanceKind::Intrinsic(def_id) => ty::Instance::new_raw(def_id, instance.args),
             _ => instance,
         };
         BodyBuilder { tcx, instance }
diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs
@@ -56,7 +56,7 @@ impl SymbolNamesTest<'_> {
         // some subset.
         for attr in tcx.get_attrs(def_id, SYMBOL_NAME) {
             let def_id = def_id.to_def_id();
-            let instance = Instance::new(
+            let instance = Instance::new_raw(
                 def_id,
                 tcx.erase_regions(GenericArgs::identity_for_item(tcx, def_id)),
             );
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
@@ -227,7 +227,7 @@ fn resolve_associated_item<'tcx>(
                 tcx.ensure_ok().compare_impl_item(leaf_def_item)?;
             }
 
-            Some(ty::Instance::new(leaf_def.item.def_id, args))
+            Some(ty::Instance::new_raw(leaf_def.item.def_id, args))
         }
         traits::ImplSource::Builtin(BuiltinImplSource::Object(_), _) => {
             let trait_ref = ty::TraitRef::from_method(tcx, trait_id, rcvr_args);
@@ -272,7 +272,7 @@ fn resolve_associated_item<'tcx>(
 
                     // Use the default `fn clone_from` from `trait Clone`.
                     let args = tcx.erase_regions(rcvr_args);
-                    Some(ty::Instance::new(trait_item_id, args))
+                    Some(ty::Instance::new_raw(trait_item_id, args))
                 }
             } else if tcx.is_lang_item(trait_ref.def_id, LangItem::FnPtrTrait) {
                 if tcx.is_lang_item(trait_item_id, LangItem::FnPtrAddr) {
@@ -321,7 +321,7 @@ fn resolve_associated_item<'tcx>(
                         // sync with the built-in trait implementations (since all of the
                         // implementations return `FnOnce::Output`).
                         if ty::ClosureKind::FnOnce == args.as_coroutine_closure().kind() {
-                            Some(Instance::new(coroutine_closure_def_id, args))
+                            Some(Instance::new_raw(coroutine_closure_def_id, args))
                         } else {
                             Some(Instance {
                                 def: ty::InstanceKind::ConstructCoroutineInClosureShim {
@@ -354,7 +354,7 @@ fn resolve_associated_item<'tcx>(
                                 args,
                             })
                         } else {
-                            Some(Instance::new(coroutine_closure_def_id, args))
+                            Some(Instance::new_raw(coroutine_closure_def_id, args))
                         }
                     }
                     ty::Closure(closure_def_id, args) => {
@@ -373,7 +373,7 @@ fn resolve_associated_item<'tcx>(
                 let name = tcx.item_name(trait_item_id);
                 assert_eq!(name, sym::transmute);
                 let args = tcx.erase_regions(rcvr_args);
-                Some(ty::Instance::new(trait_item_id, args))
+                Some(ty::Instance::new_raw(trait_item_id, args))
             } else {
                 Instance::try_resolve_item_for_coroutine(tcx, trait_item_id, trait_id, rcvr_args)
             }
diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
@@ -263,7 +263,7 @@ impl<'tcx> NonCopyConst<'tcx> {
     fn is_value_unfrozen_poly(cx: &LateContext<'tcx>, body_id: BodyId, ty: Ty<'tcx>) -> bool {
         let def_id = body_id.hir_id.owner.to_def_id();
         let args = ty::GenericArgs::identity_for_item(cx.tcx, def_id);
-        let instance = ty::Instance::new(def_id, args);
+        let instance = ty::Instance::new_raw(def_id, args);
         let cid = GlobalId {
             instance,
             promoted: None,

Original file line number	Diff line number	Diff line change
`@@ -1282,7 +1282,7 @@ fn codegen_regular_intrinsic_call<'tcx>(`
`1282`	`1282`	`intrinsic.name,`
`1283`	`1283`	`);`
`1284`	`1284`	`}`
`1285`		`- return Err(Instance::new(instance.def_id(), instance.args));`
	`1285`	`+ return Err(Instance::new_raw(instance.def_id(), instance.args));`
`1286`	`1286`	`}`
`1287`	`1287`	`}`
`1288`	`1288`
Original file line number	Diff line number	Diff line change
`@@ -399,7 +399,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc`
`399`	`399`	`}`
`400`	`400`
`401`	`401`	`// Fall back to default body`
`402`		`- _ => return Err(Instance::new(instance.def_id(), instance.args)),`
	`402`	`+ _ => return Err(Instance::new_raw(instance.def_id(), instance.args)),`
`403`	`403`	`};`
`404`	`404`
`405`	`405`	`if !fn_abi.ret.is_ignore() {`
Original file line number	Diff line number	Diff line change
`@@ -613,7 +613,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {`
`613`	`613`	`_ => {`
`614`	`614`	`debug!("unknown intrinsic '{}' -- falling back to default body", name);`
`615`	`615`	`// Call the fallback body instead of generating the intrinsic code`
`616`		`- return Err(ty::Instance::new(instance.def_id(), instance.args));`
	`616`	`+ return Err(ty::Instance::new_raw(instance.def_id(), instance.args));`
`617`	`617`	`}`
`618`	`618`	`};`
`619`	`619`
Original file line number	Diff line number	Diff line change
`@@ -556,7 +556,7 @@ pub(crate) fn symbol_name_for_instance_in_crate<'tcx>(`
`556`	`556`	`ExportedSymbol::Generic(def_id, args) => {`
`557`	`557`	`rustc_symbol_mangling::symbol_name_for_instance_in_crate(`
`558`	`558`	`tcx,`
`559`		`- Instance::new(def_id, args),`
	`559`	`+ Instance::new_raw(def_id, args),`
`560`	`560`	`instantiating_crate,`
`561`	`561`	`)`
`562`	`562`	`}`
`@@ -597,7 +597,7 @@ fn calling_convention_for_symbol<'tcx>(`
`597`	`597`	`None`
`598`	`598`	`}`
`599`	`599`	`ExportedSymbol::NonGeneric(def_id) => Some(Instance::mono(tcx, def_id)),`
`600`		`- ExportedSymbol::Generic(def_id, args) => Some(Instance::new(def_id, args)),`
	`600`	`+ ExportedSymbol::Generic(def_id, args) => Some(Instance::new_raw(def_id, args)),`
`601`	`601`	`// DropGlue always use the Rust calling convention and thus follow the target's default`
`602`	`602`	`// symbol decoration scheme.`
`603`	`603`	`ExportedSymbol::DropGlue(..) => None,`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) {`
`216`	`216`	`check::maybe_check_static_with_link_section(tcx, item_def_id);`
`217`	`217`	`}`
`218`	`218`	`DefKind::Const if tcx.generics_of(item_def_id).is_empty() => {`
`219`		`- let instance = ty::Instance::new(item_def_id.into(), ty::GenericArgs::empty());`
	`219`	`+ let instance = ty::Instance::new_raw(item_def_id.into(), ty::GenericArgs::empty());`
`220`	`220`	`let cid = GlobalId { instance, promoted: None };`
`221`	`221`	`let typing_env = ty::TypingEnv::fully_monomorphized();`
`222`	`222`	`tcx.ensure_ok().eval_to_const_value_raw(typing_env.as_query_input(cid));`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ impl<'tcx> ExportedSymbol<'tcx> {`
`55`	`55`	`match *self {`
`56`	`56`	`ExportedSymbol::NonGeneric(def_id) => tcx.symbol_name(ty::Instance::mono(tcx, def_id)),`
`57`	`57`	`ExportedSymbol::Generic(def_id, args) => {`
`58`		`- tcx.symbol_name(ty::Instance::new(def_id, args))`
	`58`	`+ tcx.symbol_name(ty::Instance::new_raw(def_id, args))`
`59`	`59`	`}`
`60`	`60`	`ExportedSymbol::DropGlue(ty) => {`
`61`	`61`	`tcx.symbol_name(ty::Instance::resolve_drop_in_place(tcx, ty))`
Original file line number	Diff line number	Diff line change
`@@ -318,7 +318,7 @@ impl<'tcx> fmt::Display for MonoItem<'tcx> {`
`318`	`318`	`match *self {`
`319`	`319`	`MonoItem::Fn(instance) => write!(f, "fn {instance}"),`
`320`	`320`	`MonoItem::Static(def_id) => {`
`321`		`- write!(f, "static {}", Instance::new(def_id, GenericArgs::empty()))`
	`321`	`+ write!(f, "static {}", Instance::new_raw(def_id, GenericArgs::empty()))`
`322`	`322`	`}`
`323`	`323`	`MonoItem::GlobalAsm(..) => write!(f, "global_asm"),`
`324`	`324`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2455,7 +2455,7 @@ rustc_queries! {`
`2455`	`2455`	`query resolve_instance_raw(`
`2456`	`2456`	`key: ty::PseudoCanonicalInput<'tcx, (DefId, GenericArgsRef<'tcx>)>`
`2457`	`2457`	`) -> Result<Option<ty::Instance<'tcx>>, ErrorGuaranteed> {`
`2458`		- desc { "resolving instance `{}`", ty::Instance::new(key.value.0, key.value.1) }
	`2458`	+ desc { "resolving instance `{}`", ty::Instance::new_raw(key.value.0, key.value.1) }
`2459`	`2459`	`}`
`2460`	`2460`
`2461`	`2461`	`query reveal_opaque_types_in_bounds(key: ty::Clauses<'tcx>) -> ty::Clauses<'tcx> {`
Original file line number	Diff line number	Diff line change
`@@ -426,7 +426,10 @@ impl<'tcx> fmt::Display for Instance<'tcx> {`
`426`	`426`	`}`
`427`	`427`
`428`	`428`	`impl<'tcx> Instance<'tcx> {`
`429`		`- pub fn new(def_id: DefId, args: GenericArgsRef<'tcx>) -> Instance<'tcx> {`
	`429`	+ /// Creates a new [`InstanceKind::Item`] from the `def_id` and `args`. Note that this
	`430`	`+ /// does not resolve trait items to their corresponding impl items -- to do that, use`
	`431`	+ /// [`Instance::expect_resolve`] instead.
	`432`	`+ pub fn new_raw(def_id: DefId, args: GenericArgsRef<'tcx>) -> Instance<'tcx> {`
`430`	`433`	`assert!(`
`431`	`434`	`!args.has_escaping_bound_vars(),`
`432`	`435`	`"args of instance {def_id:?} has escaping bound vars: {args:?}"`
`@@ -445,7 +448,7 @@ impl<'tcx> Instance<'tcx> {`
`445`	`448`	`}`
`446`	`449`	`});`
`447`	`450`
`448`		`- Instance::new(def_id, args)`
	`451`	`+ Instance::new_raw(def_id, args)`
`449`	`452`	`}`
`450`	`453`
`451`	`454`	`#[inline]`
`@@ -538,7 +541,7 @@ impl<'tcx> Instance<'tcx> {`
`538`	`541`	`let type_length = type_length(args);`
`539`	`542`	`if !tcx.type_length_limit().value_within_limit(type_length) {`
`540`	`543`	`let (shrunk, written_to_path) =`
`541`		`- shrunk_instance_name(tcx, Instance::new(def_id, args));`
	`544`	`+ shrunk_instance_name(tcx, Instance::new_raw(def_id, args));`
`542`	`545`	`let mut path = PathBuf::new();`
`543`	`546`	`let was_written = if let Some(path2) = written_to_path {`
`544`	`547`	`path = path2;`
`@@ -708,7 +711,7 @@ impl<'tcx> Instance<'tcx> {`
`708`	`711`
`709`	`712`	`match needs_fn_once_adapter_shim(actual_kind, requested_kind) {`
`710`	`713`	`Ok(true) => Instance::fn_once_adapter_instance(tcx, def_id, args),`
`711`		`- _ => Instance::new(def_id, args),`
	`714`	`+ _ => Instance::new_raw(def_id, args),`
`712`	`715`	`}`
`713`	`716`	`}`
`714`	`717`
`@@ -822,7 +825,7 @@ impl<'tcx> Instance<'tcx> {`
`822`	`825`	// This is important for `Iterator`'s combinators, but also useful for
`823`	`826`	// adding future default methods to `Future`, for instance.
`824`	`827`	`debug_assert!(tcx.defaultness(trait_item_id).has_value());`
`825`		`- Some(Instance::new(trait_item_id, rcvr_args))`
	`828`	`+ Some(Instance::new_raw(trait_item_id, rcvr_args))`
`826`	`829`	`}`
`827`	`830`	`}`
`828`	`831`