rustc: remove some unnecessary lifetimes in -> TyCtxt methods.

eddyb · eddyb · commit 21ac96033448 · 2019-06-12T13:38:27.000+03:00
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -793,7 +793,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> {
             type DynExistential = ();
             type Const = ();
 
-            fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {
+            fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
                 self.tcx
             }
 
diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs
@@ -144,7 +144,7 @@ pub struct AllocDecodingSession<'s> {
 impl<'s> AllocDecodingSession<'s> {
 
     // Decodes an AllocId in a thread-safe way.
-    pub fn decode_alloc_id<'tcx, D>(&self,
+    pub fn decode_alloc_id<D>(&self,
                                         decoder: &mut D)
                                         -> Result<AllocId, D::Error>
         where D: TyDecoder<'tcx>,
diff --git a/src/librustc/traits/query/normalize_erasing_regions.rs b/src/librustc/traits/query/normalize_erasing_regions.rs
@@ -68,7 +68,7 @@ struct NormalizeAfterErasingRegionsFolder<'tcx> {
 }
 
 impl TypeFolder<'tcx, 'tcx> for NormalizeAfterErasingRegionsFolder<'tcx> {
-    fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.tcx
     }
 
diff --git a/src/librustc/ty/codec.rs b/src/librustc/ty/codec.rs
@@ -131,38 +131,34 @@ pub trait TyDecoder<'tcx>: Decoder {
 }
 
 #[inline]
-pub fn decode_arena_allocable<'a, 'tcx, D, T: ArenaAllocatable + Decodable>(
+pub fn decode_arena_allocable<D, T: ArenaAllocatable + Decodable>(
     decoder: &mut D
 ) -> Result<&'tcx T, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     Ok(decoder.tcx().arena.alloc(Decodable::decode(decoder)?))
 }
 
 #[inline]
-pub fn decode_arena_allocable_slice<'a, 'tcx, D, T: ArenaAllocatable + Decodable>(
+pub fn decode_arena_allocable_slice<D, T: ArenaAllocatable + Decodable>(
     decoder: &mut D
 ) -> Result<&'tcx [T], D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     Ok(decoder.tcx().arena.alloc_from_iter(<Vec<T> as Decodable>::decode(decoder)?))
 }
 
 #[inline]
-pub fn decode_cnum<'a, 'tcx, D>(decoder: &mut D) -> Result<CrateNum, D::Error>
+pub fn decode_cnum<D>(decoder: &mut D) -> Result<CrateNum, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     let cnum = CrateNum::from_u32(u32::decode(decoder)?);
     Ok(decoder.map_encoded_cnum_to_current(cnum))
 }
 
 #[inline]
-pub fn decode_ty<'a, 'tcx, D>(decoder: &mut D) -> Result<Ty<'tcx>, D::Error>
+pub fn decode_ty<D>(decoder: &mut D) -> Result<Ty<'tcx>, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     // Handle shorthands first, if we have an usize > 0x80.
     if decoder.positioned_at_shorthand() {
@@ -180,10 +176,9 @@ pub fn decode_ty<'a, 'tcx, D>(decoder: &mut D) -> Result<Ty<'tcx>, D::Error>
 }
 
 #[inline]
-pub fn decode_predicates<'a, 'tcx, D>(decoder: &mut D)
+pub fn decode_predicates<D>(decoder: &mut D)
                                       -> Result<ty::GenericPredicates<'tcx>, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     Ok(ty::GenericPredicates {
         parent: Decodable::decode(decoder)?,
@@ -205,59 +200,53 @@ pub fn decode_predicates<'a, 'tcx, D>(decoder: &mut D)
 }
 
 #[inline]
-pub fn decode_substs<'a, 'tcx, D>(decoder: &mut D) -> Result<SubstsRef<'tcx>, D::Error>
+pub fn decode_substs<D>(decoder: &mut D) -> Result<SubstsRef<'tcx>, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     let len = decoder.read_usize()?;
     let tcx = decoder.tcx();
     Ok(tcx.mk_substs((0..len).map(|_| Decodable::decode(decoder)))?)
 }
 
 #[inline]
-pub fn decode_region<'a, 'tcx, D>(decoder: &mut D) -> Result<ty::Region<'tcx>, D::Error>
+pub fn decode_region<D>(decoder: &mut D) -> Result<ty::Region<'tcx>, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     Ok(decoder.tcx().mk_region(Decodable::decode(decoder)?))
 }
 
 #[inline]
-pub fn decode_ty_slice<'a, 'tcx, D>(decoder: &mut D)
+pub fn decode_ty_slice<D>(decoder: &mut D)
                                     -> Result<&'tcx ty::List<Ty<'tcx>>, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     let len = decoder.read_usize()?;
     Ok(decoder.tcx().mk_type_list((0..len).map(|_| Decodable::decode(decoder)))?)
 }
 
 #[inline]
-pub fn decode_adt_def<'a, 'tcx, D>(decoder: &mut D)
+pub fn decode_adt_def<D>(decoder: &mut D)
                                    -> Result<&'tcx ty::AdtDef, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     let def_id = DefId::decode(decoder)?;
     Ok(decoder.tcx().adt_def(def_id))
 }
 
 #[inline]
-pub fn decode_existential_predicate_slice<'a, 'tcx, D>(decoder: &mut D)
+pub fn decode_existential_predicate_slice<D>(decoder: &mut D)
     -> Result<&'tcx ty::List<ty::ExistentialPredicate<'tcx>>, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     let len = decoder.read_usize()?;
     Ok(decoder.tcx()
               .mk_existential_predicates((0..len).map(|_| Decodable::decode(decoder)))?)
 }
 
 #[inline]
-pub fn decode_canonical_var_infos<'a, 'tcx, D>(decoder: &mut D)
+pub fn decode_canonical_var_infos<D>(decoder: &mut D)
     -> Result<CanonicalVarInfos<'tcx>, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     let len = decoder.read_usize()?;
     let interned: Result<Vec<CanonicalVarInfo>, _> = (0..len).map(|_| Decodable::decode(decoder))
@@ -267,19 +256,17 @@ pub fn decode_canonical_var_infos<'a, 'tcx, D>(decoder: &mut D)
 }
 
 #[inline]
-pub fn decode_const<'a, 'tcx, D>(decoder: &mut D)
+pub fn decode_const<D>(decoder: &mut D)
                                  -> Result<&'tcx ty::Const<'tcx>, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     Ok(decoder.tcx().mk_const(Decodable::decode(decoder)?))
 }
 
 #[inline]
-pub fn decode_allocation<'a, 'tcx, D>(decoder: &mut D)
+pub fn decode_allocation<D>(decoder: &mut D)
     -> Result<&'tcx Allocation, D::Error>
     where D: TyDecoder<'tcx>,
-          'tcx: 'a,
 {
     Ok(decoder.tcx().intern_const_alloc(Decodable::decode(decoder)?))
 }
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
@@ -1727,7 +1727,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
 }
 
 pub trait HasTyCtxt<'tcx>: HasDataLayout {
-    fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx>;
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx>;
 }
 
 pub trait HasParamEnv<'tcx> {
@@ -1741,7 +1741,7 @@ impl<'gcx, 'tcx> HasDataLayout for TyCtxt<'gcx, 'tcx> {
 }
 
 impl<'gcx, 'tcx> HasTyCtxt<'gcx> for TyCtxt<'gcx, 'tcx> {
-    fn tcx<'b>(&'b self) -> TyCtxt<'gcx, 'gcx> {
+    fn tcx(&self) -> TyCtxt<'gcx, 'gcx> {
         self.global_tcx()
     }
 }
@@ -1759,7 +1759,7 @@ impl<'tcx, T: HasDataLayout> HasDataLayout for LayoutCx<'tcx, T> {
 }
 
 impl<'gcx, 'tcx, T: HasTyCtxt<'gcx>> HasTyCtxt<'gcx> for LayoutCx<'tcx, T> {
-    fn tcx<'b>(&'b self) -> TyCtxt<'gcx, 'gcx> {
+    fn tcx(&self) -> TyCtxt<'gcx, 'gcx> {
         self.tcx.tcx()
     }
 }
diff --git a/src/librustc_codegen_llvm/builder.rs b/src/librustc_codegen_llvm/builder.rs
@@ -66,7 +66,7 @@ impl ty::layout::HasDataLayout for Builder<'_, '_, '_> {
 }
 
 impl ty::layout::HasTyCtxt<'tcx> for Builder<'_, '_, 'tcx> {
-    fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.cx.tcx
     }
 }
diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs
@@ -838,7 +838,7 @@ impl HasTargetSpec for CodegenCx<'ll, 'tcx> {
 }
 
 impl ty::layout::HasTyCtxt<'tcx> for CodegenCx<'ll, 'tcx> {
-    fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.tcx
     }
 }
diff --git a/src/librustc_codegen_utils/symbol_names/legacy.rs b/src/librustc_codegen_utils/symbol_names/legacy.rs
@@ -203,7 +203,7 @@ impl Printer<'tcx, 'tcx> for SymbolPrinter<'tcx> {
     type DynExistential = Self;
     type Const = Self;
 
-    fn tcx(&'a self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.tcx
     }
 
diff --git a/src/librustc_codegen_utils/symbol_names/v0.rs b/src/librustc_codegen_utils/symbol_names/v0.rs
@@ -223,7 +223,7 @@ impl Printer<'tcx, 'tcx> for SymbolMangler<'tcx> {
     type DynExistential = Self;
     type Const = Self;
 
-    fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.tcx
     }
 
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
@@ -173,7 +173,7 @@ impl<'mir, 'tcx, M> layout::HasTyCtxt<'tcx> for InterpretCx<'mir, 'tcx, M>
     where M: Machine<'mir, 'tcx>
 {
     #[inline]
-    fn tcx<'d>(&'d self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         *self.tcx
     }
 }
diff --git a/src/librustc_mir/interpret/intrinsics/type_name.rs b/src/librustc_mir/interpret/intrinsics/type_name.rs
@@ -23,7 +23,7 @@ impl<'tcx> Printer<'tcx, 'tcx> for AbsolutePathPrinter<'tcx> {
     type DynExistential = Self;
     type Const = Self;
 
-    fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.tcx
     }
 
diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs
@@ -113,7 +113,7 @@ impl<'mir, 'tcx> HasDataLayout for ConstPropagator<'mir, 'tcx> {
 
 impl<'mir, 'tcx> HasTyCtxt<'tcx> for ConstPropagator<'mir, 'tcx> {
     #[inline]
-    fn tcx<'c>(&'c self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.tcx
     }
 }
diff --git a/src/librustc_passes/layout_test.rs b/src/librustc_passes/layout_test.rs
@@ -119,7 +119,7 @@ impl LayoutOf for UnwrapLayoutCx<'tcx> {
 }
 
 impl HasTyCtxt<'tcx> for UnwrapLayoutCx<'tcx> {
-    fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.tcx
     }
 }
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -171,7 +171,7 @@ impl ItemCtxt<'tcx> {
 }
 
 impl AstConv<'tcx, 'tcx> for ItemCtxt<'tcx> {
-    fn tcx<'b>(&'b self) -> TyCtxt<'tcx, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {
         self.tcx
     }
 

Original file line number	Diff line number	Diff line change
`@@ -793,7 +793,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> {`
`793`	`793`	`type DynExistential = ();`
`794`	`794`	`type Const = ();`
`795`	`795`
`796`		`- fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {`
	`796`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {`
`797`	`797`	`self.tcx`
`798`	`798`	`}`
`799`	`799`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ struct NormalizeAfterErasingRegionsFolder<'tcx> {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`impl TypeFolder<'tcx, 'tcx> for NormalizeAfterErasingRegionsFolder<'tcx> {`
`71`		`- fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {`
	`71`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {`
`72`	`72`	`self.tcx`
`73`	`73`	`}`
`74`	`74`
Original file line number	Diff line number	Diff line change
`@@ -131,38 +131,34 @@ pub trait TyDecoder<'tcx>: Decoder {`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`#[inline]`
`134`		`-pub fn decode_arena_allocable<'a, 'tcx, D, T: ArenaAllocatable + Decodable>(`
	`134`	`+pub fn decode_arena_allocable<D, T: ArenaAllocatable + Decodable>(`
`135`	`135`	`decoder: &mut D`
`136`	`136`	`) -> Result<&'tcx T, D::Error>`
`137`	`137`	`where D: TyDecoder<'tcx>,`
`138`		`- 'tcx: 'a,`
`139`	`138`	`{`
`140`	`139`	`Ok(decoder.tcx().arena.alloc(Decodable::decode(decoder)?))`
`141`	`140`	`}`
`142`	`141`
`143`	`142`	`#[inline]`
`144`		`-pub fn decode_arena_allocable_slice<'a, 'tcx, D, T: ArenaAllocatable + Decodable>(`
	`143`	`+pub fn decode_arena_allocable_slice<D, T: ArenaAllocatable + Decodable>(`
`145`	`144`	`decoder: &mut D`
`146`	`145`	`) -> Result<&'tcx [T], D::Error>`
`147`	`146`	`where D: TyDecoder<'tcx>,`
`148`		`- 'tcx: 'a,`
`149`	`147`	`{`
`150`	`148`	`Ok(decoder.tcx().arena.alloc_from_iter(<Vec<T> as Decodable>::decode(decoder)?))`
`151`	`149`	`}`
`152`	`150`
`153`	`151`	`#[inline]`
`154`		`-pub fn decode_cnum<'a, 'tcx, D>(decoder: &mut D) -> Result<CrateNum, D::Error>`
	`152`	`+pub fn decode_cnum<D>(decoder: &mut D) -> Result<CrateNum, D::Error>`
`155`	`153`	`where D: TyDecoder<'tcx>,`
`156`		`- 'tcx: 'a,`
`157`	`154`	`{`
`158`	`155`	`let cnum = CrateNum::from_u32(u32::decode(decoder)?);`
`159`	`156`	`Ok(decoder.map_encoded_cnum_to_current(cnum))`
`160`	`157`	`}`
`161`	`158`
`162`	`159`	`#[inline]`
`163`		`-pub fn decode_ty<'a, 'tcx, D>(decoder: &mut D) -> Result<Ty<'tcx>, D::Error>`
	`160`	`+pub fn decode_ty<D>(decoder: &mut D) -> Result<Ty<'tcx>, D::Error>`
`164`	`161`	`where D: TyDecoder<'tcx>,`
`165`		`- 'tcx: 'a,`
`166`	`162`	`{`
`167`	`163`	`// Handle shorthands first, if we have an usize > 0x80.`
`168`	`164`	`if decoder.positioned_at_shorthand() {`
`@@ -180,10 +176,9 @@ pub fn decode_ty<'a, 'tcx, D>(decoder: &mut D) -> Result<Ty<'tcx>, D::Error>`
`180`	`176`	`}`
`181`	`177`
`182`	`178`	`#[inline]`
`183`		`-pub fn decode_predicates<'a, 'tcx, D>(decoder: &mut D)`
	`179`	`+pub fn decode_predicates<D>(decoder: &mut D)`
`184`	`180`	`-> Result<ty::GenericPredicates<'tcx>, D::Error>`
`185`	`181`	`where D: TyDecoder<'tcx>,`
`186`		`- 'tcx: 'a,`
`187`	`182`	`{`
`188`	`183`	`Ok(ty::GenericPredicates {`
`189`	`184`	`parent: Decodable::decode(decoder)?,`
`@@ -205,59 +200,53 @@ pub fn decode_predicates<'a, 'tcx, D>(decoder: &mut D)`
`205`	`200`	`}`
`206`	`201`
`207`	`202`	`#[inline]`
`208`		`-pub fn decode_substs<'a, 'tcx, D>(decoder: &mut D) -> Result<SubstsRef<'tcx>, D::Error>`
	`203`	`+pub fn decode_substs<D>(decoder: &mut D) -> Result<SubstsRef<'tcx>, D::Error>`
`209`	`204`	`where D: TyDecoder<'tcx>,`
`210`		`- 'tcx: 'a,`
`211`	`205`	`{`
`212`	`206`	`let len = decoder.read_usize()?;`
`213`	`207`	`let tcx = decoder.tcx();`
`214`	`208`	`Ok(tcx.mk_substs((0..len).map(\|_\| Decodable::decode(decoder)))?)`
`215`	`209`	`}`
`216`	`210`
`217`	`211`	`#[inline]`
`218`		`-pub fn decode_region<'a, 'tcx, D>(decoder: &mut D) -> Result<ty::Region<'tcx>, D::Error>`
	`212`	`+pub fn decode_region<D>(decoder: &mut D) -> Result<ty::Region<'tcx>, D::Error>`
`219`	`213`	`where D: TyDecoder<'tcx>,`
`220`		`- 'tcx: 'a,`
`221`	`214`	`{`
`222`	`215`	`Ok(decoder.tcx().mk_region(Decodable::decode(decoder)?))`
`223`	`216`	`}`
`224`	`217`
`225`	`218`	`#[inline]`
`226`		`-pub fn decode_ty_slice<'a, 'tcx, D>(decoder: &mut D)`
	`219`	`+pub fn decode_ty_slice<D>(decoder: &mut D)`
`227`	`220`	`-> Result<&'tcx ty::List<Ty<'tcx>>, D::Error>`
`228`	`221`	`where D: TyDecoder<'tcx>,`
`229`		`- 'tcx: 'a,`
`230`	`222`	`{`
`231`	`223`	`let len = decoder.read_usize()?;`
`232`	`224`	`Ok(decoder.tcx().mk_type_list((0..len).map(\|_\| Decodable::decode(decoder)))?)`
`233`	`225`	`}`
`234`	`226`
`235`	`227`	`#[inline]`
`236`		`-pub fn decode_adt_def<'a, 'tcx, D>(decoder: &mut D)`
	`228`	`+pub fn decode_adt_def<D>(decoder: &mut D)`
`237`	`229`	`-> Result<&'tcx ty::AdtDef, D::Error>`
`238`	`230`	`where D: TyDecoder<'tcx>,`
`239`		`- 'tcx: 'a,`
`240`	`231`	`{`
`241`	`232`	`let def_id = DefId::decode(decoder)?;`
`242`	`233`	`Ok(decoder.tcx().adt_def(def_id))`
`243`	`234`	`}`
`244`	`235`
`245`	`236`	`#[inline]`
`246`		`-pub fn decode_existential_predicate_slice<'a, 'tcx, D>(decoder: &mut D)`
	`237`	`+pub fn decode_existential_predicate_slice<D>(decoder: &mut D)`
`247`	`238`	`-> Result<&'tcx ty::List<ty::ExistentialPredicate<'tcx>>, D::Error>`
`248`	`239`	`where D: TyDecoder<'tcx>,`
`249`		`- 'tcx: 'a,`
`250`	`240`	`{`
`251`	`241`	`let len = decoder.read_usize()?;`
`252`	`242`	`Ok(decoder.tcx()`
`253`	`243`	`.mk_existential_predicates((0..len).map(\|_\| Decodable::decode(decoder)))?)`
`254`	`244`	`}`
`255`	`245`
`256`	`246`	`#[inline]`
`257`		`-pub fn decode_canonical_var_infos<'a, 'tcx, D>(decoder: &mut D)`
	`247`	`+pub fn decode_canonical_var_infos<D>(decoder: &mut D)`
`258`	`248`	`-> Result<CanonicalVarInfos<'tcx>, D::Error>`
`259`	`249`	`where D: TyDecoder<'tcx>,`
`260`		`- 'tcx: 'a,`
`261`	`250`	`{`
`262`	`251`	`let len = decoder.read_usize()?;`
`263`	`252`	`let interned: Result<Vec<CanonicalVarInfo>, _> = (0..len).map(\|_\| Decodable::decode(decoder))`
`@@ -267,19 +256,17 @@ pub fn decode_canonical_var_infos<'a, 'tcx, D>(decoder: &mut D)`
`267`	`256`	`}`
`268`	`257`
`269`	`258`	`#[inline]`
`270`		`-pub fn decode_const<'a, 'tcx, D>(decoder: &mut D)`
	`259`	`+pub fn decode_const<D>(decoder: &mut D)`
`271`	`260`	`-> Result<&'tcx ty::Const<'tcx>, D::Error>`
`272`	`261`	`where D: TyDecoder<'tcx>,`
`273`		`- 'tcx: 'a,`
`274`	`262`	`{`
`275`	`263`	`Ok(decoder.tcx().mk_const(Decodable::decode(decoder)?))`
`276`	`264`	`}`
`277`	`265`
`278`	`266`	`#[inline]`
`279`		`-pub fn decode_allocation<'a, 'tcx, D>(decoder: &mut D)`
	`267`	`+pub fn decode_allocation<D>(decoder: &mut D)`
`280`	`268`	`-> Result<&'tcx Allocation, D::Error>`
`281`	`269`	`where D: TyDecoder<'tcx>,`
`282`		`- 'tcx: 'a,`
`283`	`270`	`{`
`284`	`271`	`Ok(decoder.tcx().intern_const_alloc(Decodable::decode(decoder)?))`
`285`	`272`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1727,7 +1727,7 @@ impl<'tcx> SizeSkeleton<'tcx> {`
`1727`	`1727`	`}`
`1728`	`1728`
`1729`	`1729`	`pub trait HasTyCtxt<'tcx>: HasDataLayout {`
`1730`		`- fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx>;`
	`1730`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx>;`
`1731`	`1731`	`}`
`1732`	`1732`
`1733`	`1733`	`pub trait HasParamEnv<'tcx> {`
`@@ -1741,7 +1741,7 @@ impl<'gcx, 'tcx> HasDataLayout for TyCtxt<'gcx, 'tcx> {`
`1741`	`1741`	`}`
`1742`	`1742`
`1743`	`1743`	`impl<'gcx, 'tcx> HasTyCtxt<'gcx> for TyCtxt<'gcx, 'tcx> {`
`1744`		`- fn tcx<'b>(&'b self) -> TyCtxt<'gcx, 'gcx> {`
	`1744`	`+ fn tcx(&self) -> TyCtxt<'gcx, 'gcx> {`
`1745`	`1745`	`self.global_tcx()`
`1746`	`1746`	`}`
`1747`	`1747`	`}`
`@@ -1759,7 +1759,7 @@ impl<'tcx, T: HasDataLayout> HasDataLayout for LayoutCx<'tcx, T> {`
`1759`	`1759`	`}`
`1760`	`1760`
`1761`	`1761`	`impl<'gcx, 'tcx, T: HasTyCtxt<'gcx>> HasTyCtxt<'gcx> for LayoutCx<'tcx, T> {`
`1762`		`- fn tcx<'b>(&'b self) -> TyCtxt<'gcx, 'gcx> {`
	`1762`	`+ fn tcx(&self) -> TyCtxt<'gcx, 'gcx> {`
`1763`	`1763`	`self.tcx.tcx()`
`1764`	`1764`	`}`
`1765`	`1765`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ impl ty::layout::HasDataLayout for Builder<'_, '_, '_> {`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`impl ty::layout::HasTyCtxt<'tcx> for Builder<'_, '_, 'tcx> {`
`69`		`- fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {`
	`69`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {`
`70`	`70`	`self.cx.tcx`
`71`	`71`	`}`
`72`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -838,7 +838,7 @@ impl HasTargetSpec for CodegenCx<'ll, 'tcx> {`
`838`	`838`	`}`
`839`	`839`
`840`	`840`	`impl ty::layout::HasTyCtxt<'tcx> for CodegenCx<'ll, 'tcx> {`
`841`		`- fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {`
	`841`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {`
`842`	`842`	`self.tcx`
`843`	`843`	`}`
`844`	`844`	`}`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ impl Printer<'tcx, 'tcx> for SymbolPrinter<'tcx> {`
`203`	`203`	`type DynExistential = Self;`
`204`	`204`	`type Const = Self;`
`205`	`205`
`206`		`- fn tcx(&'a self) -> TyCtxt<'tcx, 'tcx> {`
	`206`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {`
`207`	`207`	`self.tcx`
`208`	`208`	`}`
`209`	`209`
Original file line number	Diff line number	Diff line change
`@@ -223,7 +223,7 @@ impl Printer<'tcx, 'tcx> for SymbolMangler<'tcx> {`
`223`	`223`	`type DynExistential = Self;`
`224`	`224`	`type Const = Self;`
`225`	`225`
`226`		`- fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {`
	`226`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {`
`227`	`227`	`self.tcx`
`228`	`228`	`}`
`229`	`229`
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ impl<'mir, 'tcx, M> layout::HasTyCtxt<'tcx> for InterpretCx<'mir, 'tcx, M>`
`173`	`173`	`where M: Machine<'mir, 'tcx>`
`174`	`174`	`{`
`175`	`175`	`#[inline]`
`176`		`- fn tcx<'d>(&'d self) -> TyCtxt<'tcx, 'tcx> {`
	`176`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {`
`177`	`177`	`*self.tcx`
`178`	`178`	`}`
`179`	`179`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ impl<'tcx> Printer<'tcx, 'tcx> for AbsolutePathPrinter<'tcx> {`
`23`	`23`	`type DynExistential = Self;`
`24`	`24`	`type Const = Self;`
`25`	`25`
`26`		`- fn tcx<'a>(&'a self) -> TyCtxt<'tcx, 'tcx> {`
	`26`	`+ fn tcx(&self) -> TyCtxt<'tcx, 'tcx> {`
`27`	`27`	`self.tcx`
`28`	`28`	`}`
`29`	`29`