Add inline attributes and add unit to CommonTypes

Zoxc · Zoxc · commit 4cce4ffdefd2 · 2018-11-29T22:11:02.000+01:00
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
@@ -3614,6 +3614,7 @@ assert_eq!(3", stringify!($SelfT), ".checked_next_power_of_two(), Some(4));
 assert_eq!(", stringify!($SelfT), "::max_value().checked_next_power_of_two(), None);",
 $EndFeature, "
 ```"),
+            #[inline]
             #[stable(feature = "rust1", since = "1.0.0")]
             pub fn checked_next_power_of_two(self) -> Option<Self> {
                 self.one_less_than_next_power_of_two().checked_add(1)
diff --git a/src/librustc/infer/at.rs b/src/librustc/infer/at.rs
@@ -52,6 +52,7 @@ pub struct Trace<'a, 'gcx: 'tcx, 'tcx: 'a> {
 }
 
 impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
+    #[inline]
     pub fn at(&'a self,
               cause: &'a ObligationCause<'tcx>,
               param_env: ty::ParamEnv<'tcx>)
diff --git a/src/librustc/infer/resolve.rs b/src/librustc/infer/resolve.rs
@@ -25,6 +25,7 @@ pub struct OpportunisticTypeResolver<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
 }
 
 impl<'a, 'gcx, 'tcx> OpportunisticTypeResolver<'a, 'gcx, 'tcx> {
+    #[inline]
     pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) -> Self {
         OpportunisticTypeResolver { infcx }
     }
diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs
@@ -1052,6 +1052,7 @@ impl<'tcx,O> Obligation<'tcx,O> {
 }
 
 impl<'tcx> ObligationCause<'tcx> {
+    #[inline]
     pub fn new(span: Span,
                body_id: ast::NodeId,
                code: ObligationCauseCode<'tcx>)
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -155,6 +155,7 @@ impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> {
     }
 
     /// Intern a type
+    #[inline(never)]
     fn intern_ty(
         local: &CtxtInterners<'tcx>,
         global: &CtxtInterners<'gcx>,
@@ -216,6 +217,7 @@ impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> {
 }
 
 pub struct CommonTypes<'tcx> {
+    pub unit: Ty<'tcx>,
     pub bool: Ty<'tcx>,
     pub char: Ty<'tcx>,
     pub isize: Ty<'tcx>,
@@ -832,7 +834,9 @@ impl<'tcx> CommonTypes<'tcx> {
             interners.region.borrow_mut().insert(Interned(r));
             &*r
         };
+
         CommonTypes {
+            unit: mk(Tuple(List::empty())),
             bool: mk(Bool),
             char: mk(Char),
             never: mk(Never),
@@ -885,6 +889,7 @@ pub struct TyCtxt<'a, 'gcx: 'tcx, 'tcx: 'a> {
 
 impl<'a, 'gcx, 'tcx> Deref for TyCtxt<'a, 'gcx, 'tcx> {
     type Target = &'a GlobalCtxt<'gcx>;
+    #[inline(always)]
     fn deref(&self) -> &Self::Target {
         &self.gcx
     }
@@ -2515,6 +2520,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.mk_fn_ptr(converted_sig)
     }
 
+    #[inline]
     pub fn mk_ty(&self, st: TyKind<'tcx>) -> Ty<'tcx> {
         CtxtInterners::intern_ty(&self.interners, &self.global_interners, st)
     }
@@ -2548,19 +2554,23 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
+    #[inline]
     pub fn mk_str(self) -> Ty<'tcx> {
         self.mk_ty(Str)
     }
 
+    #[inline]
     pub fn mk_static_str(self) -> Ty<'tcx> {
         self.mk_imm_ref(self.types.re_static, self.mk_str())
     }
 
+    #[inline]
     pub fn mk_adt(self, def: &'tcx AdtDef, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
         // take a copy of substs so that we own the vectors inside
         self.mk_ty(Adt(def, substs))
     }
 
+    #[inline]
     pub fn mk_foreign(self, def_id: DefId) -> Ty<'tcx> {
         self.mk_ty(Foreign(def_id))
     }
@@ -2584,42 +2594,52 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.mk_ty(Adt(adt_def, substs))
     }
 
+    #[inline]
     pub fn mk_ptr(self, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
         self.mk_ty(RawPtr(tm))
     }
 
+    #[inline]
     pub fn mk_ref(self, r: Region<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
         self.mk_ty(Ref(r, tm.ty, tm.mutbl))
     }
 
+    #[inline]
     pub fn mk_mut_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
         self.mk_ref(r, TypeAndMut {ty: ty, mutbl: hir::MutMutable})
     }
 
+    #[inline]
     pub fn mk_imm_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
         self.mk_ref(r, TypeAndMut {ty: ty, mutbl: hir::MutImmutable})
     }
 
+    #[inline]
     pub fn mk_mut_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
         self.mk_ptr(TypeAndMut {ty: ty, mutbl: hir::MutMutable})
     }
 
+    #[inline]
     pub fn mk_imm_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
         self.mk_ptr(TypeAndMut {ty: ty, mutbl: hir::MutImmutable})
     }
 
+    #[inline]
     pub fn mk_nil_ptr(self) -> Ty<'tcx> {
         self.mk_imm_ptr(self.mk_unit())
     }
 
+    #[inline]
     pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {
         self.mk_ty(Array(ty, ty::Const::from_usize(self, n)))
     }
 
+    #[inline]
     pub fn mk_slice(self, ty: Ty<'tcx>) -> Ty<'tcx> {
         self.mk_ty(Slice(ty))
     }
 
+    #[inline]
     pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {
         self.mk_ty(Tuple(self.intern_type_list(ts)))
     }
@@ -2628,10 +2648,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         iter.intern_with(|ts| self.mk_ty(Tuple(self.intern_type_list(ts))))
     }
 
+    #[inline]
     pub fn mk_unit(self) -> Ty<'tcx> {
-        self.intern_tup(&[])
+        self.types.unit
     }
 
+    #[inline]
     pub fn mk_diverging_default(self) -> Ty<'tcx> {
         if self.features().never_type {
             self.types.never
@@ -2640,19 +2662,23 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
+    #[inline]
     pub fn mk_bool(self) -> Ty<'tcx> {
         self.mk_ty(Bool)
     }
 
+    #[inline]
     pub fn mk_fn_def(self, def_id: DefId,
                      substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
         self.mk_ty(FnDef(def_id, substs))
     }
 
+    #[inline]
     pub fn mk_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
         self.mk_ty(FnPtr(fty))
     }
 
+    #[inline]
     pub fn mk_dynamic(
         self,
         obj: ty::Binder<&'tcx List<ExistentialPredicate<'tcx>>>,
@@ -2661,6 +2687,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.mk_ty(Dynamic(obj, reg))
     }
 
+    #[inline]
     pub fn mk_projection(self,
                          item_def_id: DefId,
                          substs: &'tcx Substs<'tcx>)
@@ -2671,11 +2698,13 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             }))
         }
 
+    #[inline]
     pub fn mk_closure(self, closure_id: DefId, closure_substs: ClosureSubsts<'tcx>)
                       -> Ty<'tcx> {
         self.mk_ty(Closure(closure_id, closure_substs))
     }
 
+    #[inline]
     pub fn mk_generator(self,
                         id: DefId,
                         generator_substs: GeneratorSubsts<'tcx>,
@@ -2684,32 +2713,39 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.mk_ty(Generator(id, generator_substs, movability))
     }
 
+    #[inline]
     pub fn mk_generator_witness(self, types: ty::Binder<&'tcx List<Ty<'tcx>>>) -> Ty<'tcx> {
         self.mk_ty(GeneratorWitness(types))
     }
 
+    #[inline]
     pub fn mk_var(self, v: TyVid) -> Ty<'tcx> {
         self.mk_infer(TyVar(v))
     }
 
+    #[inline]
     pub fn mk_int_var(self, v: IntVid) -> Ty<'tcx> {
         self.mk_infer(IntVar(v))
     }
 
+    #[inline]
     pub fn mk_float_var(self, v: FloatVid) -> Ty<'tcx> {
         self.mk_infer(FloatVar(v))
     }
 
+    #[inline]
     pub fn mk_infer(self, it: InferTy) -> Ty<'tcx> {
         self.mk_ty(Infer(it))
     }
 
+    #[inline]
     pub fn mk_ty_param(self,
                        index: u32,
                        name: InternedString) -> Ty<'tcx> {
         self.mk_ty(Param(ParamTy { idx: index, name: name }))
     }
 
+    #[inline]
     pub fn mk_self_type(self) -> Ty<'tcx> {
         self.mk_ty_param(0, keywords::SelfType.name().as_interned_str())
     }
@@ -2723,6 +2759,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
+    #[inline]
     pub fn mk_opaque(self, def_id: DefId, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
         self.mk_ty(Opaque(def_id, substs))
     }
diff --git a/src/librustc/ty/fold.rs b/src/librustc/ty/fold.rs
@@ -374,6 +374,7 @@ pub struct RegionFolder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
 }
 
 impl<'a, 'gcx, 'tcx> RegionFolder<'a, 'gcx, 'tcx> {
+    #[inline]
     pub fn new(
         tcx: TyCtxt<'a, 'gcx, 'tcx>,
         skipped_regions: &'a mut bool,
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -1275,6 +1275,7 @@ impl<'tcx> PolyProjectionPredicate<'tcx> {
         self.skip_binder().projection_ty.item_def_id
     }
 
+    #[inline]
     pub fn to_poly_trait_ref(&self, tcx: TyCtxt<'_, '_, '_>) -> PolyTraitRef<'tcx> {
         // Note: unlike with `TraitRef::to_poly_trait_ref()`,
         // `self.0.trait_ref` is permitted to have escaping regions.
@@ -1633,6 +1634,7 @@ impl<'tcx> ParamEnv<'tcx> {
     /// there are no where clauses in scope. Hidden types (like `impl
     /// Trait`) are left hidden, so this is suitable for ordinary
     /// type-checking.
+    #[inline]
     pub fn empty() -> Self {
         Self::new(List::empty(), Reveal::UserFacing)
     }
@@ -1644,11 +1646,13 @@ impl<'tcx> ParamEnv<'tcx> {
     ///
     /// N.B. If you want to have predicates in scope, use `ParamEnv::new`,
     /// or invoke `param_env.with_reveal_all()`.
+    #[inline]
     pub fn reveal_all() -> Self {
         Self::new(List::empty(), Reveal::All)
     }
 
     /// Construct a trait environment with the given set of predicates.
+    #[inline]
     pub fn new(caller_bounds: &'tcx List<ty::Predicate<'tcx>>,
                reveal: Reveal)
                -> Self {
@@ -2148,6 +2152,7 @@ impl<'a, 'gcx, 'tcx> AdtDef {
         }
     }
 
+    #[inline]
     pub fn variant_descr(&self) -> &'static str {
         match self.adt_kind() {
             AdtKind::Struct => "struct",
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
@@ -667,6 +667,7 @@ impl<'tcx> TraitRef<'tcx> {
         }
     }
 
+    #[inline]
     pub fn self_ty(&self) -> Ty<'tcx> {
         self.substs.type_at(0)
     }
@@ -978,15 +979,18 @@ impl<'tcx> FnSig<'tcx> {
 pub type PolyFnSig<'tcx> = Binder<FnSig<'tcx>>;
 
 impl<'tcx> PolyFnSig<'tcx> {
+    #[inline]
     pub fn inputs(&self) -> Binder<&'tcx [Ty<'tcx>]> {
         self.map_bound_ref(|fn_sig| fn_sig.inputs())
     }
+    #[inline]
     pub fn input(&self, index: usize) -> ty::Binder<Ty<'tcx>> {
         self.map_bound_ref(|fn_sig| fn_sig.inputs()[index])
     }
     pub fn inputs_and_output(&self) -> ty::Binder<&'tcx List<Ty<'tcx>>> {
         self.map_bound_ref(|fn_sig| fn_sig.inputs_and_output)
     }
+    #[inline]
     pub fn output(&self) -> ty::Binder<Ty<'tcx>> {
         self.map_bound_ref(|fn_sig| fn_sig.output())
     }
@@ -1548,6 +1552,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
         }
     }
 
+    #[inline]
     pub fn is_ty_var(&self) -> bool {
         match self.sty {
             Infer(TyVar(_)) => true,
@@ -1732,6 +1737,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
         }
     }
 
+    #[inline]
     pub fn is_integral(&self) -> bool {
         match self.sty {
             Infer(IntVar(_)) | Int(_) | Uint(_) => true,
@@ -1762,6 +1768,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
         }
     }
 
+    #[inline]
     pub fn is_fp(&self) -> bool {
         match self.sty {
             Infer(FloatVar(_)) | Float(_) => true,
@@ -1845,6 +1852,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
         }
     }
 
+    #[inline]
     pub fn ty_adt_def(&self) -> Option<&'tcx AdtDef> {
         match self.sty {
             Adt(adt, _) => Some(adt),
diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs
@@ -587,6 +587,7 @@ impl fmt::Debug for SpanData {
 }
 
 impl MultiSpan {
+    #[inline]
     pub fn new() -> MultiSpan {
         MultiSpan {
             primary_spans: vec![],

Original file line number	Diff line number	Diff line change
`@@ -52,6 +52,7 @@ pub struct Trace<'a, 'gcx: 'tcx, 'tcx: 'a> {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
	`55`	`+ #[inline]`
`55`	`56`	`pub fn at(&'a self,`
`56`	`57`	`cause: &'a ObligationCause<'tcx>,`
`57`	`58`	`param_env: ty::ParamEnv<'tcx>)`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ pub struct OpportunisticTypeResolver<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`impl<'a, 'gcx, 'tcx> OpportunisticTypeResolver<'a, 'gcx, 'tcx> {`
	`28`	`+ #[inline]`
`28`	`29`	`pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) -> Self {`
`29`	`30`	`OpportunisticTypeResolver { infcx }`
`30`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1052,6 +1052,7 @@ impl<'tcx,O> Obligation<'tcx,O> {`
`1052`	`1052`	`}`
`1053`	`1053`
`1054`	`1054`	`impl<'tcx> ObligationCause<'tcx> {`
	`1055`	`+ #[inline]`
`1055`	`1056`	`pub fn new(span: Span,`
`1056`	`1057`	`body_id: ast::NodeId,`
`1057`	`1058`	`code: ObligationCauseCode<'tcx>)`
Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,7 @@ impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> {`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`/// Intern a type`
	`158`	`+ #[inline(never)]`
`158`	`159`	`fn intern_ty(`
`159`	`160`	`local: &CtxtInterners<'tcx>,`
`160`	`161`	`global: &CtxtInterners<'gcx>,`
`@@ -216,6 +217,7 @@ impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> {`
`216`	`217`	`}`
`217`	`218`
`218`	`219`	`pub struct CommonTypes<'tcx> {`
	`220`	`+ pub unit: Ty<'tcx>,`
`219`	`221`	`pub bool: Ty<'tcx>,`
`220`	`222`	`pub char: Ty<'tcx>,`
`221`	`223`	`pub isize: Ty<'tcx>,`
`@@ -832,7 +834,9 @@ impl<'tcx> CommonTypes<'tcx> {`
`832`	`834`	`interners.region.borrow_mut().insert(Interned(r));`
`833`	`835`	`&*r`
`834`	`836`	`};`
	`837`	`+`
`835`	`838`	`CommonTypes {`
	`839`	`+ unit: mk(Tuple(List::empty())),`
`836`	`840`	`bool: mk(Bool),`
`837`	`841`	`char: mk(Char),`
`838`	`842`	`never: mk(Never),`
`@@ -885,6 +889,7 @@ pub struct TyCtxt<'a, 'gcx: 'tcx, 'tcx: 'a> {`
`885`	`889`
`886`	`890`	`impl<'a, 'gcx, 'tcx> Deref for TyCtxt<'a, 'gcx, 'tcx> {`
`887`	`891`	`type Target = &'a GlobalCtxt<'gcx>;`
	`892`	`+ #[inline(always)]`
`888`	`893`	`fn deref(&self) -> &Self::Target {`
`889`	`894`	`&self.gcx`
`890`	`895`	`}`
`@@ -2515,6 +2520,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2515`	`2520`	`self.mk_fn_ptr(converted_sig)`
`2516`	`2521`	`}`
`2517`	`2522`
	`2523`	`+ #[inline]`
`2518`	`2524`	`pub fn mk_ty(&self, st: TyKind<'tcx>) -> Ty<'tcx> {`
`2519`	`2525`	`CtxtInterners::intern_ty(&self.interners, &self.global_interners, st)`
`2520`	`2526`	`}`
`@@ -2548,19 +2554,23 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2548`	`2554`	`}`
`2549`	`2555`	`}`
`2550`	`2556`
	`2557`	`+ #[inline]`
`2551`	`2558`	`pub fn mk_str(self) -> Ty<'tcx> {`
`2552`	`2559`	`self.mk_ty(Str)`
`2553`	`2560`	`}`
`2554`	`2561`
	`2562`	`+ #[inline]`
`2555`	`2563`	`pub fn mk_static_str(self) -> Ty<'tcx> {`
`2556`	`2564`	`self.mk_imm_ref(self.types.re_static, self.mk_str())`
`2557`	`2565`	`}`
`2558`	`2566`
	`2567`	`+ #[inline]`
`2559`	`2568`	`pub fn mk_adt(self, def: &'tcx AdtDef, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {`
`2560`	`2569`	`// take a copy of substs so that we own the vectors inside`
`2561`	`2570`	`self.mk_ty(Adt(def, substs))`
`2562`	`2571`	`}`
`2563`	`2572`
	`2573`	`+ #[inline]`
`2564`	`2574`	`pub fn mk_foreign(self, def_id: DefId) -> Ty<'tcx> {`
`2565`	`2575`	`self.mk_ty(Foreign(def_id))`
`2566`	`2576`	`}`
`@@ -2584,42 +2594,52 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2584`	`2594`	`self.mk_ty(Adt(adt_def, substs))`
`2585`	`2595`	`}`
`2586`	`2596`
	`2597`	`+ #[inline]`
`2587`	`2598`	`pub fn mk_ptr(self, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {`
`2588`	`2599`	`self.mk_ty(RawPtr(tm))`
`2589`	`2600`	`}`
`2590`	`2601`
	`2602`	`+ #[inline]`
`2591`	`2603`	`pub fn mk_ref(self, r: Region<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {`
`2592`	`2604`	`self.mk_ty(Ref(r, tm.ty, tm.mutbl))`
`2593`	`2605`	`}`
`2594`	`2606`
	`2607`	`+ #[inline]`
`2595`	`2608`	`pub fn mk_mut_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {`
`2596`	`2609`	`self.mk_ref(r, TypeAndMut {ty: ty, mutbl: hir::MutMutable})`
`2597`	`2610`	`}`
`2598`	`2611`
	`2612`	`+ #[inline]`
`2599`	`2613`	`pub fn mk_imm_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {`
`2600`	`2614`	`self.mk_ref(r, TypeAndMut {ty: ty, mutbl: hir::MutImmutable})`
`2601`	`2615`	`}`
`2602`	`2616`
	`2617`	`+ #[inline]`
`2603`	`2618`	`pub fn mk_mut_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {`
`2604`	`2619`	`self.mk_ptr(TypeAndMut {ty: ty, mutbl: hir::MutMutable})`
`2605`	`2620`	`}`
`2606`	`2621`
	`2622`	`+ #[inline]`
`2607`	`2623`	`pub fn mk_imm_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {`
`2608`	`2624`	`self.mk_ptr(TypeAndMut {ty: ty, mutbl: hir::MutImmutable})`
`2609`	`2625`	`}`
`2610`	`2626`
	`2627`	`+ #[inline]`
`2611`	`2628`	`pub fn mk_nil_ptr(self) -> Ty<'tcx> {`
`2612`	`2629`	`self.mk_imm_ptr(self.mk_unit())`
`2613`	`2630`	`}`
`2614`	`2631`
	`2632`	`+ #[inline]`
`2615`	`2633`	`pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {`
`2616`	`2634`	`self.mk_ty(Array(ty, ty::Const::from_usize(self, n)))`
`2617`	`2635`	`}`
`2618`	`2636`
	`2637`	`+ #[inline]`
`2619`	`2638`	`pub fn mk_slice(self, ty: Ty<'tcx>) -> Ty<'tcx> {`
`2620`	`2639`	`self.mk_ty(Slice(ty))`
`2621`	`2640`	`}`
`2622`	`2641`
	`2642`	`+ #[inline]`
`2623`	`2643`	`pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {`
`2624`	`2644`	`self.mk_ty(Tuple(self.intern_type_list(ts)))`
`2625`	`2645`	`}`
`@@ -2628,10 +2648,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2628`	`2648`	`iter.intern_with(\|ts\| self.mk_ty(Tuple(self.intern_type_list(ts))))`
`2629`	`2649`	`}`
`2630`	`2650`
	`2651`	`+ #[inline]`
`2631`	`2652`	`pub fn mk_unit(self) -> Ty<'tcx> {`
`2632`		`- self.intern_tup(&[])`
	`2653`	`+ self.types.unit`
`2633`	`2654`	`}`
`2634`	`2655`
	`2656`	`+ #[inline]`
`2635`	`2657`	`pub fn mk_diverging_default(self) -> Ty<'tcx> {`
`2636`	`2658`	`if self.features().never_type {`
`2637`	`2659`	`self.types.never`
`@@ -2640,19 +2662,23 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2640`	`2662`	`}`
`2641`	`2663`	`}`
`2642`	`2664`
	`2665`	`+ #[inline]`
`2643`	`2666`	`pub fn mk_bool(self) -> Ty<'tcx> {`
`2644`	`2667`	`self.mk_ty(Bool)`
`2645`	`2668`	`}`
`2646`	`2669`
	`2670`	`+ #[inline]`
`2647`	`2671`	`pub fn mk_fn_def(self, def_id: DefId,`
`2648`	`2672`	`substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {`
`2649`	`2673`	`self.mk_ty(FnDef(def_id, substs))`
`2650`	`2674`	`}`
`2651`	`2675`
	`2676`	`+ #[inline]`
`2652`	`2677`	`pub fn mk_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {`
`2653`	`2678`	`self.mk_ty(FnPtr(fty))`
`2654`	`2679`	`}`
`2655`	`2680`
	`2681`	`+ #[inline]`
`2656`	`2682`	`pub fn mk_dynamic(`
`2657`	`2683`	`self,`
`2658`	`2684`	`obj: ty::Binder<&'tcx List<ExistentialPredicate<'tcx>>>,`
`@@ -2661,6 +2687,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2661`	`2687`	`self.mk_ty(Dynamic(obj, reg))`
`2662`	`2688`	`}`
`2663`	`2689`
	`2690`	`+ #[inline]`
`2664`	`2691`	`pub fn mk_projection(self,`
`2665`	`2692`	`item_def_id: DefId,`
`2666`	`2693`	`substs: &'tcx Substs<'tcx>)`
`@@ -2671,11 +2698,13 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2671`	`2698`	`}))`
`2672`	`2699`	`}`
`2673`	`2700`
	`2701`	`+ #[inline]`
`2674`	`2702`	`pub fn mk_closure(self, closure_id: DefId, closure_substs: ClosureSubsts<'tcx>)`
`2675`	`2703`	`-> Ty<'tcx> {`
`2676`	`2704`	`self.mk_ty(Closure(closure_id, closure_substs))`
`2677`	`2705`	`}`
`2678`	`2706`
	`2707`	`+ #[inline]`
`2679`	`2708`	`pub fn mk_generator(self,`
`2680`	`2709`	`id: DefId,`
`2681`	`2710`	`generator_substs: GeneratorSubsts<'tcx>,`
`@@ -2684,32 +2713,39 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2684`	`2713`	`self.mk_ty(Generator(id, generator_substs, movability))`
`2685`	`2714`	`}`
`2686`	`2715`
	`2716`	`+ #[inline]`
`2687`	`2717`	`pub fn mk_generator_witness(self, types: ty::Binder<&'tcx List<Ty<'tcx>>>) -> Ty<'tcx> {`
`2688`	`2718`	`self.mk_ty(GeneratorWitness(types))`
`2689`	`2719`	`}`
`2690`	`2720`
	`2721`	`+ #[inline]`
`2691`	`2722`	`pub fn mk_var(self, v: TyVid) -> Ty<'tcx> {`
`2692`	`2723`	`self.mk_infer(TyVar(v))`
`2693`	`2724`	`}`
`2694`	`2725`
	`2726`	`+ #[inline]`
`2695`	`2727`	`pub fn mk_int_var(self, v: IntVid) -> Ty<'tcx> {`
`2696`	`2728`	`self.mk_infer(IntVar(v))`
`2697`	`2729`	`}`
`2698`	`2730`
	`2731`	`+ #[inline]`
`2699`	`2732`	`pub fn mk_float_var(self, v: FloatVid) -> Ty<'tcx> {`
`2700`	`2733`	`self.mk_infer(FloatVar(v))`
`2701`	`2734`	`}`
`2702`	`2735`
	`2736`	`+ #[inline]`
`2703`	`2737`	`pub fn mk_infer(self, it: InferTy) -> Ty<'tcx> {`
`2704`	`2738`	`self.mk_ty(Infer(it))`
`2705`	`2739`	`}`
`2706`	`2740`
	`2741`	`+ #[inline]`
`2707`	`2742`	`pub fn mk_ty_param(self,`
`2708`	`2743`	`index: u32,`
`2709`	`2744`	`name: InternedString) -> Ty<'tcx> {`
`2710`	`2745`	`self.mk_ty(Param(ParamTy { idx: index, name: name }))`
`2711`	`2746`	`}`
`2712`	`2747`
	`2748`	`+ #[inline]`
`2713`	`2749`	`pub fn mk_self_type(self) -> Ty<'tcx> {`
`2714`	`2750`	`self.mk_ty_param(0, keywords::SelfType.name().as_interned_str())`
`2715`	`2751`	`}`
`@@ -2723,6 +2759,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2723`	`2759`	`}`
`2724`	`2760`	`}`
`2725`	`2761`
	`2762`	`+ #[inline]`
`2726`	`2763`	`pub fn mk_opaque(self, def_id: DefId, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {`
`2727`	`2764`	`self.mk_ty(Opaque(def_id, substs))`
`2728`	`2765`	`}`
Original file line number	Diff line number	Diff line change
`@@ -374,6 +374,7 @@ pub struct RegionFolder<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {`
`374`	`374`	`}`
`375`	`375`
`376`	`376`	`impl<'a, 'gcx, 'tcx> RegionFolder<'a, 'gcx, 'tcx> {`
	`377`	`+ #[inline]`
`377`	`378`	`pub fn new(`
`378`	`379`	`tcx: TyCtxt<'a, 'gcx, 'tcx>,`
`379`	`380`	`skipped_regions: &'a mut bool,`
Original file line number	Diff line number	Diff line change
`@@ -667,6 +667,7 @@ impl<'tcx> TraitRef<'tcx> {`
`667`	`667`	`}`
`668`	`668`	`}`
`669`	`669`
	`670`	`+ #[inline]`
`670`	`671`	`pub fn self_ty(&self) -> Ty<'tcx> {`
`671`	`672`	`self.substs.type_at(0)`
`672`	`673`	`}`
`@@ -978,15 +979,18 @@ impl<'tcx> FnSig<'tcx> {`
`978`	`979`	`pub type PolyFnSig<'tcx> = Binder<FnSig<'tcx>>;`
`979`	`980`
`980`	`981`	`impl<'tcx> PolyFnSig<'tcx> {`
	`982`	`+ #[inline]`
`981`	`983`	`pub fn inputs(&self) -> Binder<&'tcx [Ty<'tcx>]> {`
`982`	`984`	`self.map_bound_ref(\|fn_sig\| fn_sig.inputs())`
`983`	`985`	`}`
	`986`	`+ #[inline]`
`984`	`987`	`pub fn input(&self, index: usize) -> ty::Binder<Ty<'tcx>> {`
`985`	`988`	`self.map_bound_ref(\|fn_sig\| fn_sig.inputs()[index])`
`986`	`989`	`}`
`987`	`990`	`pub fn inputs_and_output(&self) -> ty::Binder<&'tcx List<Ty<'tcx>>> {`
`988`	`991`	`self.map_bound_ref(\|fn_sig\| fn_sig.inputs_and_output)`
`989`	`992`	`}`
	`993`	`+ #[inline]`
`990`	`994`	`pub fn output(&self) -> ty::Binder<Ty<'tcx>> {`
`991`	`995`	`self.map_bound_ref(\|fn_sig\| fn_sig.output())`
`992`	`996`	`}`
`@@ -1548,6 +1552,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {`
`1548`	`1552`	`}`
`1549`	`1553`	`}`
`1550`	`1554`
	`1555`	`+ #[inline]`
`1551`	`1556`	`pub fn is_ty_var(&self) -> bool {`
`1552`	`1557`	`match self.sty {`
`1553`	`1558`	`Infer(TyVar(_)) => true,`
`@@ -1732,6 +1737,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {`
`1732`	`1737`	`}`
`1733`	`1738`	`}`
`1734`	`1739`
	`1740`	`+ #[inline]`
`1735`	`1741`	`pub fn is_integral(&self) -> bool {`
`1736`	`1742`	`match self.sty {`
`1737`	`1743`	`Infer(IntVar(_)) \| Int(_) \| Uint(_) => true,`
`@@ -1762,6 +1768,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {`
`1762`	`1768`	`}`
`1763`	`1769`	`}`
`1764`	`1770`
	`1771`	`+ #[inline]`
`1765`	`1772`	`pub fn is_fp(&self) -> bool {`
`1766`	`1773`	`match self.sty {`
`1767`	`1774`	`Infer(FloatVar(_)) \| Float(_) => true,`
`@@ -1845,6 +1852,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {`
`1845`	`1852`	`}`
`1846`	`1853`	`}`
`1847`	`1854`
	`1855`	`+ #[inline]`
`1848`	`1856`	`pub fn ty_adt_def(&self) -> Option<&'tcx AdtDef> {`
`1849`	`1857`	`match self.sty {`
`1850`	`1858`	`Adt(adt, _) => Some(adt),`
Original file line number	Diff line number	Diff line change
`@@ -587,6 +587,7 @@ impl fmt::Debug for SpanData {`
`587`	`587`	`}`
`588`	`588`
`589`	`589`	`impl MultiSpan {`
	`590`	`+ #[inline]`
`590`	`591`	`pub fn new() -> MultiSpan {`
`591`	`592`	`MultiSpan {`
`592`	`593`	`primary_spans: vec![],`