Add inline to single-call accessor trampolines

traviscross · traviscross · commit 86b8c93c4551 · 2026-05-08T23:20:20.000Z
Some trivial accessors have a single call, like
`fn def_id(self) -&gt; DefId { self.did() }`.  After MIR inlining the
inner call, the auto-inline heuristic from Rust PR 116505 might
already cover these, but the heuristic is conservative.  Let's
annotate explicitly and profile.
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
@@ -255,10 +255,12 @@ impl<'tcx> AdtDef<'tcx> {
 }
 
 impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
+    #[inline]
     fn def_id(self) -> DefId {
         self.did()
     }
 
+    #[inline]
     fn is_struct(self) -> bool {
         self.is_struct()
     }
@@ -273,14 +275,17 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
         Some(interner.type_of(self.non_enum_variant().tail_opt()?.did))
     }
 
+    #[inline]
     fn is_phantom_data(self) -> bool {
         self.is_phantom_data()
     }
 
+    #[inline]
     fn is_manually_drop(self) -> bool {
         self.is_manually_drop()
     }
 
+    #[inline]
     fn field_representing_type_info(
         self,
         tcx: TyCtxt<'tcx>,
@@ -298,6 +303,7 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
         )
     }
 
+    #[inline]
     fn sizedness_constraint(
         self,
         tcx: TyCtxt<'tcx>,
@@ -306,6 +312,7 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
         self.sizedness_constraint(tcx, sizedness)
     }
 
+    #[inline]
     fn is_fundamental(self) -> bool {
         self.is_fundamental()
     }
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
@@ -33,6 +33,7 @@ pub struct Const<'tcx>(pub(super) Interned<'tcx, WithCachedTypeInfo<ConstKind<'t
 impl<'tcx> rustc_type_ir::inherent::IntoKind for Const<'tcx> {
     type Kind = ConstKind<'tcx>;
 
+    #[inline]
     fn kind(self) -> ConstKind<'tcx> {
         self.kind()
     }
@@ -162,14 +163,17 @@ impl<'tcx> Const<'tcx> {
 }
 
 impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
+    #[inline]
     fn new_infer(tcx: TyCtxt<'tcx>, infer: ty::InferConst) -> Self {
         Const::new_infer(tcx, infer)
     }
 
+    #[inline]
     fn new_var(tcx: TyCtxt<'tcx>, vid: ty::ConstVid) -> Self {
         Const::new_var(tcx, vid)
     }
 
+    #[inline]
     fn new_bound(
         interner: TyCtxt<'tcx>,
         debruijn: ty::DebruijnIndex,
@@ -183,22 +187,27 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
         Const::new_bound(tcx, debruijn, ty::BoundConst::new(var))
     }
 
+    #[inline]
     fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: rustc_type_ir::BoundVar) -> Self {
         Const::new_canonical_bound(tcx, var)
     }
 
+    #[inline]
     fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderConst<'tcx>) -> Self {
         Const::new_placeholder(tcx, placeholder)
     }
 
+    #[inline]
     fn new_unevaluated(interner: TyCtxt<'tcx>, uv: ty::UnevaluatedConst<'tcx>) -> Self {
         Const::new_unevaluated(interner, uv)
     }
 
+    #[inline]
     fn new_expr(interner: TyCtxt<'tcx>, expr: ty::Expr<'tcx>) -> Self {
         Const::new_expr(interner, expr)
     }
 
+    #[inline]
     fn new_error(interner: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Self {
         Const::new_error(interner, guar)
     }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -74,10 +74,12 @@ use crate::ty::{
 };
 
 impl<'tcx> rustc_type_ir::inherent::DefId<TyCtxt<'tcx>> for DefId {
+    #[inline]
     fn is_local(self) -> bool {
         self.is_local()
     }
 
+    #[inline]
     fn as_local(self) -> Option<LocalDefId> {
         self.as_local()
     }
@@ -92,24 +94,29 @@ impl<'tcx> rustc_type_ir::inherent::Safety<TyCtxt<'tcx>> for hir::Safety {
         hir::Safety::Unsafe
     }
 
+    #[inline]
     fn is_safe(self) -> bool {
         self.is_safe()
     }
 
+    #[inline]
     fn prefix_str(self) -> &'static str {
         self.prefix_str()
     }
 }
 
 impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>> for &'tcx rustc_feature::Features {
+    #[inline]
     fn generic_const_exprs(self) -> bool {
         self.generic_const_exprs()
     }
 
+    #[inline]
     fn generic_const_args(self) -> bool {
         self.generic_const_args()
     }
 
+    #[inline]
     fn coroutine_clone(self) -> bool {
         self.coroutine_clone()
     }
diff --git a/compiler/rustc_middle/src/ty/generic_args.rs b/compiler/rustc_middle/src/ty/generic_args.rs
@@ -41,6 +41,7 @@ pub struct GenericArg<'tcx> {
 impl<'tcx> rustc_type_ir::inherent::GenericArg<TyCtxt<'tcx>> for GenericArg<'tcx> {}
 
 impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArgsRef<'tcx> {
+    #[inline]
     fn rebase_onto(
         self,
         tcx: TyCtxt<'tcx>,
@@ -51,24 +52,29 @@ impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArg
     }
 
     #[track_caller]
+    #[inline]
     fn type_at(self, i: usize) -> Ty<'tcx> {
         self.type_at(i)
     }
 
     #[track_caller]
+    #[inline]
     fn region_at(self, i: usize) -> ty::Region<'tcx> {
         self.region_at(i)
     }
 
     #[track_caller]
+    #[inline]
     fn const_at(self, i: usize) -> ty::Const<'tcx> {
         self.const_at(i)
     }
 
+    #[inline]
     fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::GenericArgsRef<'tcx> {
         GenericArgs::identity_for_item(tcx, def_id)
     }
 
+    #[inline]
     fn extend_with_error(
         tcx: TyCtxt<'tcx>,
         def_id: DefId,
@@ -130,6 +136,7 @@ impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArg
 impl<'tcx> rustc_type_ir::inherent::IntoKind for GenericArg<'tcx> {
     type Kind = GenericArgKind<'tcx>;
 
+    #[inline]
     fn kind(self) -> Self::Kind {
         self.kind()
     }
diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs
@@ -129,6 +129,7 @@ pub struct Generics {
 }
 
 impl<'tcx> rustc_type_ir::inherent::GenericsOf<TyCtxt<'tcx>> for &'tcx Generics {
+    #[inline]
     fn count(&self) -> usize {
         self.parent_count + self.own_params.len()
     }
diff --git a/compiler/rustc_middle/src/ty/list.rs b/compiler/rustc_middle/src/ty/list.rs
@@ -144,10 +144,12 @@ impl<'a, H, T: Copy> rustc_type_ir::inherent::SliceLike for &'a RawList<H, T> {
 
     type IntoIter = iter::Copied<<&'a [T] as IntoIterator>::IntoIter>;
 
+    #[inline]
     fn iter(self) -> Self::IntoIter {
         (*self).iter()
     }
 
+    #[inline]
     fn as_slice(&self) -> &[Self::Item] {
         (*self).as_slice()
     }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -480,6 +480,7 @@ pub struct Ty<'tcx>(Interned<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>);
 impl<'tcx> rustc_type_ir::inherent::IntoKind for Ty<'tcx> {
     type Kind = TyKind<'tcx>;
 
+    #[inline]
     fn kind(self) -> TyKind<'tcx> {
         *self.kind()
     }
@@ -520,6 +521,7 @@ impl<'tcx> rustc_type_ir::inherent::Term<TyCtxt<'tcx>> for Term<'tcx> {}
 impl<'tcx> rustc_type_ir::inherent::IntoKind for Term<'tcx> {
     type Kind = TermKind<'tcx>;
 
+    #[inline]
     fn kind(self) -> Self::Kind {
         self.kind()
     }
@@ -947,10 +949,12 @@ impl<'tcx> DefinitionSiteHiddenType<'tcx> {
 pub type Clauses<'tcx> = &'tcx ListWithCachedTypeInfo<Clause<'tcx>>;
 
 impl<'tcx> rustc_type_ir::Flags for Clauses<'tcx> {
+    #[inline]
     fn flags(&self) -> TypeFlags {
         (**self).flags()
     }
 
+    #[inline]
     fn outer_exclusive_binder(&self) -> DebruijnIndex {
         (**self).outer_exclusive_binder()
     }
@@ -973,6 +977,7 @@ pub struct ParamEnv<'tcx> {
 }
 
 impl<'tcx> rustc_type_ir::inherent::ParamEnv<TyCtxt<'tcx>> for ParamEnv<'tcx> {
+    #[inline]
     fn caller_bounds(self) -> impl inherent::SliceLike<Item = ty::Clause<'tcx>> {
         self.caller_bounds()
     }
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
@@ -47,6 +47,7 @@ pub struct Predicate<'tcx>(
 );
 
 impl<'tcx> rustc_type_ir::inherent::Predicate<TyCtxt<'tcx>> for Predicate<'tcx> {
+    #[inline]
     fn as_clause(self) -> Option<ty::Clause<'tcx>> {
         self.as_clause()
     }
@@ -55,6 +56,7 @@ impl<'tcx> rustc_type_ir::inherent::Predicate<TyCtxt<'tcx>> for Predicate<'tcx>
 impl<'tcx> rustc_type_ir::inherent::IntoKind for Predicate<'tcx> {
     type Kind = ty::Binder<'tcx, ty::PredicateKind<'tcx>>;
 
+    #[inline]
     fn kind(self) -> Self::Kind {
         self.kind()
     }
@@ -138,10 +140,12 @@ pub struct Clause<'tcx>(
 );
 
 impl<'tcx> rustc_type_ir::inherent::Clause<TyCtxt<'tcx>> for Clause<'tcx> {
+    #[inline]
     fn as_predicate(self) -> Predicate<'tcx> {
         self.as_predicate()
     }
 
+    #[inline]
     fn instantiate_supertrait(self, tcx: TyCtxt<'tcx>, trait_ref: ty::PolyTraitRef<'tcx>) -> Self {
         self.instantiate_supertrait(tcx, trait_ref)
     }
@@ -150,6 +154,7 @@ impl<'tcx> rustc_type_ir::inherent::Clause<TyCtxt<'tcx>> for Clause<'tcx> {
 impl<'tcx> rustc_type_ir::inherent::IntoKind for Clause<'tcx> {
     type Kind = ty::Binder<'tcx, ClauseKind<'tcx>>;
 
+    #[inline]
     fn kind(self) -> Self::Kind {
         self.kind()
     }
diff --git a/compiler/rustc_middle/src/ty/region.rs b/compiler/rustc_middle/src/ty/region.rs
@@ -25,6 +25,7 @@ impl<'tcx> rustc_type_ir::inherent::IntoKind for Region<'tcx> {
 }
 
 impl<'tcx> rustc_type_ir::Flags for Region<'tcx> {
+    #[inline]
     fn flags(&self) -> TypeFlags {
         self.type_flags()
     }
@@ -158,6 +159,7 @@ impl<'tcx> Region<'tcx> {
 }
 
 impl<'tcx> rustc_type_ir::inherent::Region<TyCtxt<'tcx>> for Region<'tcx> {
+    #[inline]
     fn new_bound(
         interner: TyCtxt<'tcx>,
         debruijn: ty::DebruijnIndex,
@@ -166,14 +168,17 @@ impl<'tcx> rustc_type_ir::inherent::Region<TyCtxt<'tcx>> for Region<'tcx> {
         Region::new_bound(interner, debruijn, var)
     }
 
+    #[inline]
     fn new_anon_bound(tcx: TyCtxt<'tcx>, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self {
         Region::new_bound(tcx, debruijn, ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon })
     }
 
+    #[inline]
     fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: rustc_type_ir::BoundVar) -> Self {
         Region::new_canonical_bound(tcx, var)
     }
 
+    #[inline]
     fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderRegion<'tcx>) -> Self {
         Region::new_placeholder(tcx, placeholder)
     }
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs

Original file line number	Diff line number	Diff line change
`@@ -255,10 +255,12 @@ impl<'tcx> AdtDef<'tcx> {`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {`
	`258`	`+ #[inline]`
`258`	`259`	`fn def_id(self) -> DefId {`
`259`	`260`	`self.did()`
`260`	`261`	`}`
`261`	`262`
	`263`	`+ #[inline]`
`262`	`264`	`fn is_struct(self) -> bool {`
`263`	`265`	`self.is_struct()`
`264`	`266`	`}`
`@@ -273,14 +275,17 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {`
`273`	`275`	`Some(interner.type_of(self.non_enum_variant().tail_opt()?.did))`
`274`	`276`	`}`
`275`	`277`
	`278`	`+ #[inline]`
`276`	`279`	`fn is_phantom_data(self) -> bool {`
`277`	`280`	`self.is_phantom_data()`
`278`	`281`	`}`
`279`	`282`
	`283`	`+ #[inline]`
`280`	`284`	`fn is_manually_drop(self) -> bool {`
`281`	`285`	`self.is_manually_drop()`
`282`	`286`	`}`
`283`	`287`
	`288`	`+ #[inline]`
`284`	`289`	`fn field_representing_type_info(`
`285`	`290`	`self,`
`286`	`291`	`tcx: TyCtxt<'tcx>,`
`@@ -298,6 +303,7 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {`
`298`	`303`	`)`
`299`	`304`	`}`
`300`	`305`
	`306`	`+ #[inline]`
`301`	`307`	`fn sizedness_constraint(`
`302`	`308`	`self,`
`303`	`309`	`tcx: TyCtxt<'tcx>,`
`@@ -306,6 +312,7 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {`
`306`	`312`	`self.sizedness_constraint(tcx, sizedness)`
`307`	`313`	`}`
`308`	`314`
	`315`	`+ #[inline]`
`309`	`316`	`fn is_fundamental(self) -> bool {`
`310`	`317`	`self.is_fundamental()`
`311`	`318`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@ pub struct Const<'tcx>(pub(super) Interned<'tcx, WithCachedTypeInfo<ConstKind<'t`
`33`	`33`	`impl<'tcx> rustc_type_ir::inherent::IntoKind for Const<'tcx> {`
`34`	`34`	`type Kind = ConstKind<'tcx>;`
`35`	`35`
	`36`	`+ #[inline]`
`36`	`37`	`fn kind(self) -> ConstKind<'tcx> {`
`37`	`38`	`self.kind()`
`38`	`39`	`}`
`@@ -162,14 +163,17 @@ impl<'tcx> Const<'tcx> {`
`162`	`163`	`}`
`163`	`164`
`164`	`165`	`impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {`
	`166`	`+ #[inline]`
`165`	`167`	`fn new_infer(tcx: TyCtxt<'tcx>, infer: ty::InferConst) -> Self {`
`166`	`168`	`Const::new_infer(tcx, infer)`
`167`	`169`	`}`
`168`	`170`
	`171`	`+ #[inline]`
`169`	`172`	`fn new_var(tcx: TyCtxt<'tcx>, vid: ty::ConstVid) -> Self {`
`170`	`173`	`Const::new_var(tcx, vid)`
`171`	`174`	`}`
`172`	`175`
	`176`	`+ #[inline]`
`173`	`177`	`fn new_bound(`
`174`	`178`	`interner: TyCtxt<'tcx>,`
`175`	`179`	`debruijn: ty::DebruijnIndex,`
`@@ -183,22 +187,27 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {`
`183`	`187`	`Const::new_bound(tcx, debruijn, ty::BoundConst::new(var))`
`184`	`188`	`}`
`185`	`189`
	`190`	`+ #[inline]`
`186`	`191`	`fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: rustc_type_ir::BoundVar) -> Self {`
`187`	`192`	`Const::new_canonical_bound(tcx, var)`
`188`	`193`	`}`
`189`	`194`
	`195`	`+ #[inline]`
`190`	`196`	`fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderConst<'tcx>) -> Self {`
`191`	`197`	`Const::new_placeholder(tcx, placeholder)`
`192`	`198`	`}`
`193`	`199`
	`200`	`+ #[inline]`
`194`	`201`	`fn new_unevaluated(interner: TyCtxt<'tcx>, uv: ty::UnevaluatedConst<'tcx>) -> Self {`
`195`	`202`	`Const::new_unevaluated(interner, uv)`
`196`	`203`	`}`
`197`	`204`
	`205`	`+ #[inline]`
`198`	`206`	`fn new_expr(interner: TyCtxt<'tcx>, expr: ty::Expr<'tcx>) -> Self {`
`199`	`207`	`Const::new_expr(interner, expr)`
`200`	`208`	`}`
`201`	`209`
	`210`	`+ #[inline]`
`202`	`211`	`fn new_error(interner: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Self {`
`203`	`212`	`Const::new_error(interner, guar)`
`204`	`213`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,10 +74,12 @@ use crate::ty::{`
`74`	`74`	`};`
`75`	`75`
`76`	`76`	`impl<'tcx> rustc_type_ir::inherent::DefId<TyCtxt<'tcx>> for DefId {`
	`77`	`+ #[inline]`
`77`	`78`	`fn is_local(self) -> bool {`
`78`	`79`	`self.is_local()`
`79`	`80`	`}`
`80`	`81`
	`82`	`+ #[inline]`
`81`	`83`	`fn as_local(self) -> Option<LocalDefId> {`
`82`	`84`	`self.as_local()`
`83`	`85`	`}`
`@@ -92,24 +94,29 @@ impl<'tcx> rustc_type_ir::inherent::Safety<TyCtxt<'tcx>> for hir::Safety {`
`92`	`94`	`hir::Safety::Unsafe`
`93`	`95`	`}`
`94`	`96`
	`97`	`+ #[inline]`
`95`	`98`	`fn is_safe(self) -> bool {`
`96`	`99`	`self.is_safe()`
`97`	`100`	`}`
`98`	`101`
	`102`	`+ #[inline]`
`99`	`103`	`fn prefix_str(self) -> &'static str {`
`100`	`104`	`self.prefix_str()`
`101`	`105`	`}`
`102`	`106`	`}`
`103`	`107`
`104`	`108`	`impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>> for &'tcx rustc_feature::Features {`
	`109`	`+ #[inline]`
`105`	`110`	`fn generic_const_exprs(self) -> bool {`
`106`	`111`	`self.generic_const_exprs()`
`107`	`112`	`}`
`108`	`113`
	`114`	`+ #[inline]`
`109`	`115`	`fn generic_const_args(self) -> bool {`
`110`	`116`	`self.generic_const_args()`
`111`	`117`	`}`
`112`	`118`
	`119`	`+ #[inline]`
`113`	`120`	`fn coroutine_clone(self) -> bool {`
`114`	`121`	`self.coroutine_clone()`
`115`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -129,6 +129,7 @@ pub struct Generics {`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`impl<'tcx> rustc_type_ir::inherent::GenericsOf<TyCtxt<'tcx>> for &'tcx Generics {`
	`132`	`+ #[inline]`
`132`	`133`	`fn count(&self) -> usize {`
`133`	`134`	`self.parent_count + self.own_params.len()`
`134`	`135`	`}`
Original file line number	Diff line number	Diff line change
`@@ -144,10 +144,12 @@ impl<'a, H, T: Copy> rustc_type_ir::inherent::SliceLike for &'a RawList<H, T> {`
`144`	`144`
`145`	`145`	`type IntoIter = iter::Copied<<&'a [T] as IntoIterator>::IntoIter>;`
`146`	`146`
	`147`	`+ #[inline]`
`147`	`148`	`fn iter(self) -> Self::IntoIter {`
`148`	`149`	`(*self).iter()`
`149`	`150`	`}`
`150`	`151`
	`152`	`+ #[inline]`
`151`	`153`	`fn as_slice(&self) -> &[Self::Item] {`
`152`	`154`	`(*self).as_slice()`
`153`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -480,6 +480,7 @@ pub struct Ty<'tcx>(Interned<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>);`
`480`	`480`	`impl<'tcx> rustc_type_ir::inherent::IntoKind for Ty<'tcx> {`
`481`	`481`	`type Kind = TyKind<'tcx>;`
`482`	`482`
	`483`	`+ #[inline]`
`483`	`484`	`fn kind(self) -> TyKind<'tcx> {`
`484`	`485`	`*self.kind()`
`485`	`486`	`}`
`@@ -520,6 +521,7 @@ impl<'tcx> rustc_type_ir::inherent::Term<TyCtxt<'tcx>> for Term<'tcx> {}`
`520`	`521`	`impl<'tcx> rustc_type_ir::inherent::IntoKind for Term<'tcx> {`
`521`	`522`	`type Kind = TermKind<'tcx>;`
`522`	`523`
	`524`	`+ #[inline]`
`523`	`525`	`fn kind(self) -> Self::Kind {`
`524`	`526`	`self.kind()`
`525`	`527`	`}`
`@@ -947,10 +949,12 @@ impl<'tcx> DefinitionSiteHiddenType<'tcx> {`
`947`	`949`	`pub type Clauses<'tcx> = &'tcx ListWithCachedTypeInfo<Clause<'tcx>>;`
`948`	`950`
`949`	`951`	`impl<'tcx> rustc_type_ir::Flags for Clauses<'tcx> {`
	`952`	`+ #[inline]`
`950`	`953`	`fn flags(&self) -> TypeFlags {`
`951`	`954`	`(**self).flags()`
`952`	`955`	`}`
`953`	`956`
	`957`	`+ #[inline]`
`954`	`958`	`fn outer_exclusive_binder(&self) -> DebruijnIndex {`
`955`	`959`	`(**self).outer_exclusive_binder()`
`956`	`960`	`}`
`@@ -973,6 +977,7 @@ pub struct ParamEnv<'tcx> {`
`973`	`977`	`}`
`974`	`978`
`975`	`979`	`impl<'tcx> rustc_type_ir::inherent::ParamEnv<TyCtxt<'tcx>> for ParamEnv<'tcx> {`
	`980`	`+ #[inline]`
`976`	`981`	`fn caller_bounds(self) -> impl inherent::SliceLike<Item = ty::Clause<'tcx>> {`
`977`	`982`	`self.caller_bounds()`
`978`	`983`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,7 @@ pub struct Predicate<'tcx>(`
`47`	`47`	`);`
`48`	`48`
`49`	`49`	`impl<'tcx> rustc_type_ir::inherent::Predicate<TyCtxt<'tcx>> for Predicate<'tcx> {`
	`50`	`+ #[inline]`
`50`	`51`	`fn as_clause(self) -> Option<ty::Clause<'tcx>> {`
`51`	`52`	`self.as_clause()`
`52`	`53`	`}`
`@@ -55,6 +56,7 @@ impl<'tcx> rustc_type_ir::inherent::Predicate<TyCtxt<'tcx>> for Predicate<'tcx>`
`55`	`56`	`impl<'tcx> rustc_type_ir::inherent::IntoKind for Predicate<'tcx> {`
`56`	`57`	`type Kind = ty::Binder<'tcx, ty::PredicateKind<'tcx>>;`
`57`	`58`
	`59`	`+ #[inline]`
`58`	`60`	`fn kind(self) -> Self::Kind {`
`59`	`61`	`self.kind()`
`60`	`62`	`}`
`@@ -138,10 +140,12 @@ pub struct Clause<'tcx>(`
`138`	`140`	`);`
`139`	`141`
`140`	`142`	`impl<'tcx> rustc_type_ir::inherent::Clause<TyCtxt<'tcx>> for Clause<'tcx> {`
	`143`	`+ #[inline]`
`141`	`144`	`fn as_predicate(self) -> Predicate<'tcx> {`
`142`	`145`	`self.as_predicate()`
`143`	`146`	`}`
`144`	`147`
	`148`	`+ #[inline]`
`145`	`149`	`fn instantiate_supertrait(self, tcx: TyCtxt<'tcx>, trait_ref: ty::PolyTraitRef<'tcx>) -> Self {`
`146`	`150`	`self.instantiate_supertrait(tcx, trait_ref)`
`147`	`151`	`}`
`@@ -150,6 +154,7 @@ impl<'tcx> rustc_type_ir::inherent::Clause<TyCtxt<'tcx>> for Clause<'tcx> {`
`150`	`154`	`impl<'tcx> rustc_type_ir::inherent::IntoKind for Clause<'tcx> {`
`151`	`155`	`type Kind = ty::Binder<'tcx, ClauseKind<'tcx>>;`
`152`	`156`
	`157`	`+ #[inline]`
`153`	`158`	`fn kind(self) -> Self::Kind {`
`154`	`159`	`self.kind()`
`155`	`160`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ impl<'tcx> rustc_type_ir::inherent::IntoKind for Region<'tcx> {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`impl<'tcx> rustc_type_ir::Flags for Region<'tcx> {`
	`28`	`+ #[inline]`
`28`	`29`	`fn flags(&self) -> TypeFlags {`
`29`	`30`	`self.type_flags()`
`30`	`31`	`}`
`@@ -158,6 +159,7 @@ impl<'tcx> Region<'tcx> {`
`158`	`159`	`}`
`159`	`160`
`160`	`161`	`impl<'tcx> rustc_type_ir::inherent::Region<TyCtxt<'tcx>> for Region<'tcx> {`
	`162`	`+ #[inline]`
`161`	`163`	`fn new_bound(`
`162`	`164`	`interner: TyCtxt<'tcx>,`
`163`	`165`	`debruijn: ty::DebruijnIndex,`
`@@ -166,14 +168,17 @@ impl<'tcx> rustc_type_ir::inherent::Region<TyCtxt<'tcx>> for Region<'tcx> {`
`166`	`168`	`Region::new_bound(interner, debruijn, var)`
`167`	`169`	`}`
`168`	`170`
	`171`	`+ #[inline]`
`169`	`172`	`fn new_anon_bound(tcx: TyCtxt<'tcx>, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self {`
`170`	`173`	`Region::new_bound(tcx, debruijn, ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon })`
`171`	`174`	`}`
`172`	`175`
	`176`	`+ #[inline]`
`173`	`177`	`fn new_canonical_bound(tcx: TyCtxt<'tcx>, var: rustc_type_ir::BoundVar) -> Self {`
`174`	`178`	`Region::new_canonical_bound(tcx, var)`
`175`	`179`	`}`
`176`	`180`
	`181`	`+ #[inline]`
`177`	`182`	`fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderRegion<'tcx>) -> Self {`
`178`	`183`	`Region::new_placeholder(tcx, placeholder)`
`179`	`184`	`}`