Auto merge of #156343 - traviscross:TC/add-inline-on-trivial-accessors, r=<try>

[PERF CHECK ONLY] Add `inline` to trivial cross-crate accessors

Author: bors

compiler/rustc_index_macros/src/newtype.rs

@@ -101,12 +101,14 @@ impl Parse for Newtype {
             quote! {
                 #gate_rustc_only
                 impl<D: ::rustc_serialize::Decoder> ::rustc_serialize::Decodable<D> for #name {
+                    #[inline]
                     fn decode(d: &mut D) -> Self {
                         Self::from_u32(d.read_u32())
                     }
                 }
                 #gate_rustc_only
                 impl<E: ::rustc_serialize::Encoder> ::rustc_serialize::Encodable<E> for #name {
+                    #[inline]
                     fn encode(&self, e: &mut E) {
                         e.emit_u32(self.as_u32());
                     }
@@ -138,11 +140,13 @@ impl Parse for Newtype {
                     }
                 }
                 impl ::std::cmp::Ord for #name {
+                    #[inline]
                     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
                         self.as_u32().cmp(&other.as_u32())
                     }
                 }
                 impl ::std::cmp::PartialOrd for #name {
+                    #[inline]
                     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
                         self.as_u32().partial_cmp(&other.as_u32())
                     }
@@ -156,6 +160,7 @@ impl Parse for Newtype {
             quote! {
                 #gate_rustc_only
                 impl ::rustc_data_structures::stable_hasher::StableHash for #name {
+                    #[inline]
                     fn stable_hash<
                         __Hcx: ::rustc_data_structures::stable_hasher::StableHashCtxt
                     >(
@@ -340,6 +345,7 @@ impl Parse for Newtype {
             impl ::std::cmp::Eq for #name {}
 
             impl ::std::cmp::PartialEq for #name {
+                #[inline]
                 fn eq(&self, other: &Self) -> bool {
                     self.as_u32().eq(&other.as_u32())
                 }
@@ -349,6 +355,7 @@ impl Parse for Newtype {
             impl ::std::marker::StructuralPartialEq for #name {}
 
             impl ::std::hash::Hash for #name {
+                #[inline]
                 fn hash<H: ::std::hash::Hasher>(&self, state: &mut H) {
                     self.as_u32().hash(state)
                 }

compiler/rustc_middle/src/ty/adt.rs

@@ -263,10 +263,12 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
         self.is_struct()
     }
 
+    #[inline]
     fn is_packed(self) -> bool {
         self.repr().packed()
     }
 
+    #[inline]
     fn struct_tail_ty(self, interner: TyCtxt<'tcx>) -> Option<ty::EarlyBinder<'tcx, Ty<'tcx>>> {
         Some(interner.type_of(self.non_enum_variant().tail_opt()?.did))
     }

compiler/rustc_middle/src/ty/consts.rs

@@ -178,6 +178,7 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
         Const::new_bound(interner, debruijn, bound_const)
     }
 
+    #[inline]
     fn new_anon_bound(tcx: TyCtxt<'tcx>, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self {
         Const::new_bound(tcx, debruijn, ty::BoundConst::new(var))
     }

compiler/rustc_middle/src/ty/context.rs

@@ -114,6 +114,7 @@ impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>> for &'tcx rustc_featu
         self.coroutine_clone()
     }
 
+    #[inline]
     fn feature_bound_holds_in_crate(self, symbol: Symbol) -> bool {
         // We don't consider feature bounds to hold in the crate when `staged_api` feature is
         // enabled, even if it is enabled through `#[feature]`.

compiler/rustc_middle/src/ty/predicate.rs

@@ -156,17 +156,20 @@ impl<'tcx> rustc_type_ir::inherent::IntoKind for Clause<'tcx> {
 }
 
 impl<'tcx> Clause<'tcx> {
+    #[inline]
     pub fn as_predicate(self) -> Predicate<'tcx> {
         Predicate(self.0)
     }
 
+    #[inline]
     pub fn kind(self) -> ty::Binder<'tcx, ClauseKind<'tcx>> {
         self.0.internee.map_bound(|kind| match kind {
             PredicateKind::Clause(clause) => clause,
             _ => unreachable!(),
         })
     }
 
+    #[inline]
     pub fn as_trait_clause(self) -> Option<ty::Binder<'tcx, TraitPredicate<'tcx>>> {
         let clause = self.kind();
         if let ty::ClauseKind::Trait(trait_clause) = clause.skip_binder() {
@@ -176,6 +179,7 @@ impl<'tcx> Clause<'tcx> {
         }
     }
 
+    #[inline]
     pub fn as_projection_clause(self) -> Option<ty::Binder<'tcx, ProjectionPredicate<'tcx>>> {
         let clause = self.kind();
         if let ty::ClauseKind::Projection(projection_clause) = clause.skip_binder() {
@@ -185,6 +189,7 @@ impl<'tcx> Clause<'tcx> {
         }
     }
 
+    #[inline]
     pub fn as_type_outlives_clause(self) -> Option<ty::Binder<'tcx, TypeOutlivesPredicate<'tcx>>> {
         let clause = self.kind();
         if let ty::ClauseKind::TypeOutlives(o) = clause.skip_binder() {
@@ -194,6 +199,7 @@ impl<'tcx> Clause<'tcx> {
         }
     }
 
+    #[inline]
     pub fn as_region_outlives_clause(
         self,
     ) -> Option<ty::Binder<'tcx, RegionOutlivesPredicate<'tcx>>> {
@@ -603,6 +609,7 @@ impl<'tcx> UpcastFrom<TyCtxt<'tcx>, NormalizesTo<'tcx>> for Predicate<'tcx> {
 }
 
 impl<'tcx> Predicate<'tcx> {
+    #[inline]
     pub fn as_trait_clause(self) -> Option<PolyTraitPredicate<'tcx>> {
         let predicate = self.kind();
         match predicate.skip_binder() {
@@ -611,6 +618,7 @@ impl<'tcx> Predicate<'tcx> {
         }
     }
 
+    #[inline]
     pub fn as_projection_clause(self) -> Option<PolyProjectionPredicate<'tcx>> {
         let predicate = self.kind();
         match predicate.skip_binder() {
@@ -620,6 +628,7 @@ impl<'tcx> Predicate<'tcx> {
     }
 
     /// Matches a `PredicateKind::Clause` and turns it into a `Clause`, otherwise returns `None`.
+    #[inline]
     pub fn as_clause(self) -> Option<Clause<'tcx>> {
         match self.kind().skip_binder() {
             PredicateKind::Clause(..) => Some(self.expect_clause()),
@@ -628,6 +637,7 @@ impl<'tcx> Predicate<'tcx> {
     }
 
     /// Assert that the predicate is a clause.
+    #[inline]
     pub fn expect_clause(self) -> Clause<'tcx> {
         match self.kind().skip_binder() {
             PredicateKind::Clause(..) => Clause(self.0),

compiler/rustc_middle/src/ty/region.rs

@@ -29,6 +29,7 @@ impl<'tcx> rustc_type_ir::Flags for Region<'tcx> {
         self.type_flags()
     }
 
+    #[inline]
     fn outer_exclusive_binder(&self) -> ty::DebruijnIndex {
         match self.kind() {
             ty::ReBound(ty::BoundVarIndexKind::Bound(debruijn), _) => debruijn.shifted_in(1),

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -509,13 +509,15 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
 
 // FIXME(clause): This is wonky
 impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ty::Clause<'tcx> {
+    #[inline]
     fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
         self,
         folder: &mut F,
     ) -> Result<Self, F::Error> {
         Ok(folder.try_fold_predicate(self.as_predicate())?.expect_clause())
     }
 
+    #[inline]
     fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
         folder.fold_predicate(self.as_predicate()).expect_clause()
     }
@@ -541,6 +543,7 @@ impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
 }
 
 impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ty::Clause<'tcx> {
+    #[inline]
     fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
         visitor.visit_predicate(self.as_predicate())
     }

compiler/rustc_middle/src/ty/sty.rs

@@ -2146,10 +2146,12 @@ impl<'tcx> Ty<'tcx> {
 }
 
 impl<'tcx> rustc_type_ir::inherent::Tys<TyCtxt<'tcx>> for &'tcx ty::List<Ty<'tcx>> {
+    #[inline]
     fn inputs(self) -> &'tcx [Ty<'tcx>] {
         self.split_last().unwrap().1
     }
 
+    #[inline]
     fn output(self) -> Ty<'tcx> {
         *self.split_last().unwrap().0
     }

compiler/rustc_type_ir/src/binder.rs

@@ -109,6 +109,7 @@ where
         Binder { value, bound_vars: Default::default() }
     }
 
+    #[inline]
     pub fn bind_with_vars(value: T, bound_vars: I::BoundVarKinds) -> Binder<I, T> {
         if cfg!(debug_assertions) {
             let mut validator = ValidateBoundVars::new(bound_vars);
@@ -186,13 +187,15 @@ impl<I: Interner, T> Binder<I, T> {
         Binder { value: &self.value, bound_vars: self.bound_vars }
     }
 
+    #[inline]
     pub fn map_bound_ref<F, U: TypeVisitable<I>>(&self, f: F) -> Binder<I, U>
     where
         F: FnOnce(&T) -> U,
     {
         self.as_ref().map_bound(f)
     }
 
+    #[inline]
     pub fn map_bound<F, U: TypeVisitable<I>>(self, f: F) -> Binder<I, U>
     where
         F: FnOnce(T) -> U,
@@ -206,6 +209,7 @@ impl<I: Interner, T> Binder<I, T> {
         Binder { value, bound_vars }
     }
 
+    #[inline]
     pub fn try_map_bound<F, U: TypeVisitable<I>, E>(self, f: F) -> Result<Binder<I, U>, E>
     where
         F: FnOnce(T) -> Result<U, E>,
@@ -245,6 +249,7 @@ impl<I: Interner, T> Binder<I, T> {
     /// binders, but that would require adjusting the debruijn
     /// indices, and given the shallow binding structure we often use,
     /// would not be that useful.)
+    #[inline]
     pub fn no_bound_vars(self) -> Option<T>
     where
         T: TypeVisitable<I>,
@@ -396,13 +401,15 @@ impl<I: Interner, T> EarlyBinder<I, T> {
         EarlyBinder { value: &self.value, _tcx: PhantomData }
     }
 
+    #[inline]
     pub fn map_bound_ref<F, U>(&self, f: F) -> EarlyBinder<I, U>
     where
         F: FnOnce(&T) -> U,
     {
         self.as_ref().map_bound(f)
     }
 
+    #[inline]
     pub fn map_bound<F, U>(self, f: F) -> EarlyBinder<I, U>
     where
         F: FnOnce(T) -> U,
@@ -411,6 +418,7 @@ impl<I: Interner, T> EarlyBinder<I, T> {
         EarlyBinder { value, _tcx: PhantomData }
     }
 
+    #[inline]
     pub fn try_map_bound<F, U, E>(self, f: F) -> Result<EarlyBinder<I, U>, E>
     where
         F: FnOnce(T) -> Result<U, E>,

compiler/rustc_type_ir/src/predicate.rs

@@ -180,6 +180,7 @@ impl<I: Interner> TraitRef<I> {
 }
 
 impl<I: Interner> ty::Binder<I, TraitRef<I>> {
+    #[inline]
     pub fn self_ty(&self) -> ty::Binder<I, I::Ty> {
         self.map_bound_ref(|tr| tr.self_ty())
     }
@@ -233,11 +234,13 @@ impl<I: Interner> TraitPredicate<I> {
 }
 
 impl<I: Interner> ty::Binder<I, TraitPredicate<I>> {
+    #[inline]
     pub fn def_id(self) -> I::TraitId {
         // Ok to skip binder since trait `DefId` does not care about regions.
         self.skip_binder().def_id()
     }
 
+    #[inline]
     pub fn self_ty(self) -> ty::Binder<I, I::Ty> {
         self.map_bound(|trait_ref| trait_ref.self_ty())
     }
@@ -946,6 +949,7 @@ impl<I: Interner> ty::Binder<I, ProjectionPredicate<I>> {
     ///
     /// Note that this is not the `DefId` of the `TraitRef` containing this
     /// associated type, which is in `tcx.associated_item(projection_def_id()).container`.
+    #[inline]
     pub fn item_def_id(&self) -> I::DefId {
         // Ok to skip binder since trait `DefId` does not care about regions.
         self.skip_binder().projection_term.def_id()
@@ -1025,11 +1029,13 @@ impl<I: Interner> HostEffectPredicate<I> {
 }
 
 impl<I: Interner> ty::Binder<I, HostEffectPredicate<I>> {
+    #[inline]
     pub fn def_id(self) -> I::TraitId {
         // Ok to skip binder since trait `DefId` does not care about regions.
         self.skip_binder().def_id()
     }
 
+    #[inline]
     pub fn self_ty(self) -> ty::Binder<I, I::Ty> {
         self.map_bound(|trait_ref| trait_ref.self_ty())
     }