Skip to content

Commit 41f5907

Browse files
committed
auto merge of #19777 : nikomatsakis/rust/warn-on-shadowing, r=acrichto
per rfc 459 cc #19390 One question is: should we start by warning, and only switch to hard error later? I think we discussed something like this in the meeting. r? @alexcrichton
2 parents cdd8b5b + 1718cd6 commit 41f5907

File tree

34 files changed

+268
-178
lines changed

34 files changed

+268
-178
lines changed

src/libcollections/bit.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -154,7 +154,7 @@ struct MaskWords<'a> {
154154
impl<'a> Iterator<(uint, u32)> for MaskWords<'a> {
155155
/// Returns (offset, word)
156156
#[inline]
157-
fn next<'a>(&'a mut self) -> Option<(uint, u32)> {
157+
fn next(&mut self) -> Option<(uint, u32)> {
158158
let ret = self.next_word;
159159
match ret {
160160
Some(&w) => {

src/libcollections/btree/map.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -561,7 +561,7 @@ mod stack {
561561
impl<'a, K, V> PartialSearchStack<'a, K, V> {
562562
/// Creates a new PartialSearchStack from a BTreeMap by initializing the stack with the
563563
/// root of the tree.
564-
pub fn new<'a>(map: &'a mut BTreeMap<K, V>) -> PartialSearchStack<'a, K, V> {
564+
pub fn new(map: &'a mut BTreeMap<K, V>) -> PartialSearchStack<'a, K, V> {
565565
let depth = map.depth;
566566

567567
PartialSearchStack {

src/libcollections/dlist.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -692,7 +692,7 @@ impl<'a, A> ListInsertion<A> for MutItems<'a, A> {
692692
}
693693

694694
#[inline]
695-
fn peek_next<'a>(&'a mut self) -> Option<&'a mut A> {
695+
fn peek_next(&mut self) -> Option<&mut A> {
696696
if self.nelem == 0 {
697697
return None
698698
}

src/libcore/fmt/mod.rs

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -115,7 +115,7 @@ impl<'a> Argument<'a> {
115115
Show::fmt(x, f)
116116
}
117117

118-
fn new<'a, T>(x: &'a T, f: fn(&T, &mut Formatter) -> Result) -> Argument<'a> {
118+
fn new<'b, T>(x: &'b T, f: fn(&T, &mut Formatter) -> Result) -> Argument<'b> {
119119
unsafe {
120120
Argument {
121121
formatter: mem::transmute(f),
@@ -124,7 +124,7 @@ impl<'a> Argument<'a> {
124124
}
125125
}
126126

127-
fn from_uint<'a>(x: &'a uint) -> Argument<'a> {
127+
fn from_uint(x: &uint) -> Argument {
128128
Argument::new(x, Argument::show_uint)
129129
}
130130

@@ -144,8 +144,8 @@ impl<'a> Arguments<'a> {
144144
/// Arguments structure.
145145
#[doc(hidden)] #[inline]
146146
#[experimental = "implementation detail of the `format_args!` macro"]
147-
pub fn new<'a>(pieces: &'a [&'a str],
148-
args: &'a [Argument<'a>]) -> Arguments<'a> {
147+
pub fn new(pieces: &'a [&'a str],
148+
args: &'a [Argument<'a>]) -> Arguments<'a> {
149149
Arguments {
150150
pieces: pieces,
151151
fmt: None,
@@ -161,9 +161,9 @@ impl<'a> Arguments<'a> {
161161
/// unsafety, but will ignore invalid .
162162
#[doc(hidden)] #[inline]
163163
#[experimental = "implementation detail of the `format_args!` macro"]
164-
pub fn with_placeholders<'a>(pieces: &'a [&'a str],
165-
fmt: &'a [rt::Argument<'a>],
166-
args: &'a [Argument<'a>]) -> Arguments<'a> {
164+
pub fn with_placeholders(pieces: &'a [&'a str],
165+
fmt: &'a [rt::Argument<'a>],
166+
args: &'a [Argument<'a>]) -> Arguments<'a> {
167167
Arguments {
168168
pieces: pieces,
169169
fmt: Some(fmt),

src/libcore/slice.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -639,12 +639,12 @@ impl<T> AsSlice<T> for [T] {
639639

640640
impl<'a, T, Sized? U: AsSlice<T>> AsSlice<T> for &'a U {
641641
#[inline(always)]
642-
fn as_slice<'a>(&'a self) -> &'a [T] { AsSlice::as_slice(*self) }
642+
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
643643
}
644644

645645
impl<'a, T, Sized? U: AsSlice<T>> AsSlice<T> for &'a mut U {
646646
#[inline(always)]
647-
fn as_slice<'a>(&'a self) -> &'a [T] { AsSlice::as_slice(*self) }
647+
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
648648
}
649649

650650
#[unstable = "waiting for DST"]

src/libfmt_macros/lib.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -185,7 +185,7 @@ impl<'a> Iterator<Piece<'a>> for Parser<'a> {
185185

186186
impl<'a> Parser<'a> {
187187
/// Creates a new parser for the given format string
188-
pub fn new<'a>(s: &'a str) -> Parser<'a> {
188+
pub fn new(s: &'a str) -> Parser<'a> {
189189
Parser {
190190
input: s,
191191
cur: s.char_indices(),

src/libgraphviz/lib.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -165,10 +165,10 @@
165165
//! fn node_id(&'a self, n: &Nd) -> dot::Id<'a> {
166166
//! dot::Id::new(format!("N{}", n)).unwrap()
167167
//! }
168-
//! fn node_label<'a>(&'a self, n: &Nd) -> dot::LabelText<'a> {
168+
//! fn node_label<'b>(&'b self, n: &Nd) -> dot::LabelText<'b> {
169169
//! dot::LabelStr(self.nodes[*n].as_slice().into_cow())
170170
//! }
171-
//! fn edge_label<'a>(&'a self, _: &Ed) -> dot::LabelText<'a> {
171+
//! fn edge_label<'b>(&'b self, _: &Ed) -> dot::LabelText<'b> {
172172
//! dot::LabelStr("&sube;".into_cow())
173173
//! }
174174
//! }
@@ -220,11 +220,11 @@
220220
//! fn node_id(&'a self, n: &Nd<'a>) -> dot::Id<'a> {
221221
//! dot::Id::new(format!("N{}", n.0)).unwrap()
222222
//! }
223-
//! fn node_label<'a>(&'a self, n: &Nd<'a>) -> dot::LabelText<'a> {
223+
//! fn node_label<'b>(&'b self, n: &Nd<'b>) -> dot::LabelText<'b> {
224224
//! let &(i, _) = n;
225225
//! dot::LabelStr(self.nodes[i].as_slice().into_cow())
226226
//! }
227-
//! fn edge_label<'a>(&'a self, _: &Ed<'a>) -> dot::LabelText<'a> {
227+
//! fn edge_label<'b>(&'b self, _: &Ed<'b>) -> dot::LabelText<'b> {
228228
//! dot::LabelStr("&sube;".into_cow())
229229
//! }
230230
//! }

src/libgraphviz/maybe_owned_vec.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -154,7 +154,7 @@ impl<'a, T> Default for MaybeOwnedVector<'a, T> {
154154
}
155155

156156
impl<'a> BytesContainer for MaybeOwnedVector<'a, u8> {
157-
fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
157+
fn container_as_bytes(&self) -> &[u8] {
158158
self.as_slice()
159159
}
160160
}

src/librand/distributions/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -114,7 +114,7 @@ impl<'a, T: Clone> WeightedChoice<'a, T> {
114114
/// - `v` is empty
115115
/// - the total weight is 0
116116
/// - the total weight is larger than a `uint` can contain.
117-
pub fn new<'a>(items: &'a mut [Weighted<T>]) -> WeightedChoice<'a, T> {
117+
pub fn new(items: &'a mut [Weighted<T>]) -> WeightedChoice<'a, T> {
118118
// strictly speaking, this is subsumed by the total weight == 0 case
119119
assert!(!items.is_empty(), "WeightedChoice::new called with no items");
120120

src/librustc/middle/astencode.rs

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -601,7 +601,7 @@ fn encode_method_callee<'a, 'tcx>(ecx: &e::EncodeContext<'a, 'tcx>,
601601
}
602602

603603
impl<'a, 'tcx> read_method_callee_helper<'tcx> for reader::Decoder<'a> {
604-
fn read_method_callee<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
604+
fn read_method_callee<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
605605
-> (ty::ExprAdjustment, MethodCallee<'tcx>) {
606606

607607
self.read_struct("MethodCallee", 4, |this| {
@@ -810,7 +810,7 @@ trait get_ty_str_ctxt<'tcx> {
810810
}
811811

812812
impl<'a, 'tcx> get_ty_str_ctxt<'tcx> for e::EncodeContext<'a, 'tcx> {
813-
fn ty_str_ctxt<'a>(&'a self) -> tyencode::ctxt<'a, 'tcx> {
813+
fn ty_str_ctxt<'b>(&'b self) -> tyencode::ctxt<'b, 'tcx> {
814814
tyencode::ctxt {
815815
diag: self.tcx.sess.diagnostic(),
816816
ds: e::def_to_string,
@@ -851,16 +851,16 @@ trait rbml_writer_helpers<'tcx> {
851851
}
852852

853853
impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
854-
fn emit_closure_type<'a>(&mut self,
855-
ecx: &e::EncodeContext<'a, 'tcx>,
854+
fn emit_closure_type<'b>(&mut self,
855+
ecx: &e::EncodeContext<'b, 'tcx>,
856856
closure_type: &ty::ClosureTy<'tcx>) {
857857
self.emit_opaque(|this| {
858858
Ok(e::write_closure_type(ecx, this, closure_type))
859859
});
860860
}
861861

862-
fn emit_method_origin<'a>(&mut self,
863-
ecx: &e::EncodeContext<'a, 'tcx>,
862+
fn emit_method_origin<'b>(&mut self,
863+
ecx: &e::EncodeContext<'b, 'tcx>,
864864
method_origin: &ty::MethodOrigin<'tcx>)
865865
{
866866
use serialize::Encoder;
@@ -916,20 +916,20 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
916916
});
917917
}
918918

919-
fn emit_ty<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, ty: Ty<'tcx>) {
919+
fn emit_ty<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>, ty: Ty<'tcx>) {
920920
self.emit_opaque(|this| Ok(e::write_type(ecx, this, ty)));
921921
}
922922

923-
fn emit_tys<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>, tys: &[Ty<'tcx>]) {
923+
fn emit_tys<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>, tys: &[Ty<'tcx>]) {
924924
self.emit_from_vec(tys, |this, ty| Ok(this.emit_ty(ecx, *ty)));
925925
}
926926

927-
fn emit_trait_ref<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
927+
fn emit_trait_ref<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
928928
trait_ref: &ty::TraitRef<'tcx>) {
929929
self.emit_opaque(|this| Ok(e::write_trait_ref(ecx, this, trait_ref)));
930930
}
931931

932-
fn emit_type_param_def<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
932+
fn emit_type_param_def<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
933933
type_param_def: &ty::TypeParameterDef<'tcx>) {
934934
self.emit_opaque(|this| {
935935
Ok(tyencode::enc_type_param_def(this.writer,
@@ -938,7 +938,7 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
938938
});
939939
}
940940

941-
fn emit_predicate<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
941+
fn emit_predicate<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
942942
predicate: &ty::Predicate<'tcx>) {
943943
self.emit_opaque(|this| {
944944
Ok(tyencode::enc_predicate(this.writer,
@@ -947,8 +947,8 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
947947
});
948948
}
949949

950-
fn emit_polytype<'a>(&mut self,
951-
ecx: &e::EncodeContext<'a, 'tcx>,
950+
fn emit_polytype<'b>(&mut self,
951+
ecx: &e::EncodeContext<'b, 'tcx>,
952952
pty: ty::Polytype<'tcx>) {
953953
use serialize::Encoder;
954954

@@ -990,14 +990,14 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
990990
bounds)));
991991
}
992992

993-
fn emit_substs<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
993+
fn emit_substs<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
994994
substs: &subst::Substs<'tcx>) {
995995
self.emit_opaque(|this| Ok(tyencode::enc_substs(this.writer,
996996
&ecx.ty_str_ctxt(),
997997
substs)));
998998
}
999999

1000-
fn emit_auto_adjustment<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
1000+
fn emit_auto_adjustment<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
10011001
adj: &ty::AutoAdjustment<'tcx>) {
10021002
use serialize::Encoder;
10031003

@@ -1019,7 +1019,7 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
10191019
});
10201020
}
10211021

1022-
fn emit_autoref<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
1022+
fn emit_autoref<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
10231023
autoref: &ty::AutoRef<'tcx>) {
10241024
use serialize::Encoder;
10251025

@@ -1069,7 +1069,7 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
10691069
});
10701070
}
10711071

1072-
fn emit_auto_deref_ref<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
1072+
fn emit_auto_deref_ref<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
10731073
auto_deref_ref: &ty::AutoDerefRef<'tcx>) {
10741074
use serialize::Encoder;
10751075

@@ -1086,7 +1086,7 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
10861086
});
10871087
}
10881088

1089-
fn emit_unsize_kind<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
1089+
fn emit_unsize_kind<'b>(&mut self, ecx: &e::EncodeContext<'b, 'tcx>,
10901090
uk: &ty::UnsizeKind<'tcx>) {
10911091
use serialize::Encoder;
10921092

@@ -1427,7 +1427,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
14271427
}).unwrap()
14281428
}
14291429

1430-
fn read_method_origin<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1430+
fn read_method_origin<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
14311431
-> ty::MethodOrigin<'tcx>
14321432
{
14331433
self.read_enum("MethodOrigin", |this| {
@@ -1498,7 +1498,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
14981498
}
14991499

15001500

1501-
fn read_ty<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> Ty<'tcx> {
1501+
fn read_ty<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>) -> Ty<'tcx> {
15021502
// Note: regions types embed local node ids. In principle, we
15031503
// should translate these node ids into the new decode
15041504
// context. However, we do not bother, because region types
@@ -1526,12 +1526,12 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
15261526
}
15271527
}
15281528

1529-
fn read_tys<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1529+
fn read_tys<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
15301530
-> Vec<Ty<'tcx>> {
15311531
self.read_to_vec(|this| Ok(this.read_ty(dcx))).unwrap().into_iter().collect()
15321532
}
15331533

1534-
fn read_trait_ref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1534+
fn read_trait_ref<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
15351535
-> Rc<ty::TraitRef<'tcx>> {
15361536
Rc::new(self.read_opaque(|this, doc| {
15371537
let ty = tydecode::parse_trait_ref_data(
@@ -1544,7 +1544,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
15441544
}).unwrap())
15451545
}
15461546

1547-
fn read_type_param_def<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1547+
fn read_type_param_def<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
15481548
-> ty::TypeParameterDef<'tcx> {
15491549
self.read_opaque(|this, doc| {
15501550
Ok(tydecode::parse_type_param_def_data(
@@ -1556,7 +1556,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
15561556
}).unwrap()
15571557
}
15581558

1559-
fn read_predicate<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1559+
fn read_predicate<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
15601560
-> ty::Predicate<'tcx>
15611561
{
15621562
self.read_opaque(|this, doc| {
@@ -1565,7 +1565,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
15651565
}).unwrap()
15661566
}
15671567

1568-
fn read_polytype<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1568+
fn read_polytype<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
15691569
-> ty::Polytype<'tcx> {
15701570
self.read_struct("Polytype", 2, |this| {
15711571
Ok(ty::Polytype {
@@ -1599,7 +1599,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
15991599
}).unwrap()
16001600
}
16011601

1602-
fn read_existential_bounds<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1602+
fn read_existential_bounds<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
16031603
-> ty::ExistentialBounds
16041604
{
16051605
self.read_opaque(|this, doc| {
@@ -1611,7 +1611,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
16111611
}).unwrap()
16121612
}
16131613

1614-
fn read_substs<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1614+
fn read_substs<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
16151615
-> subst::Substs<'tcx> {
16161616
self.read_opaque(|this, doc| {
16171617
Ok(tydecode::parse_substs_data(doc.data,
@@ -1622,7 +1622,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
16221622
}).unwrap()
16231623
}
16241624

1625-
fn read_auto_adjustment<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1625+
fn read_auto_adjustment<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
16261626
-> ty::AutoAdjustment<'tcx> {
16271627
self.read_enum("AutoAdjustment", |this| {
16281628
let variants = ["AutoAddEnv", "AutoDerefRef"];
@@ -1647,7 +1647,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
16471647
}).unwrap()
16481648
}
16491649

1650-
fn read_auto_deref_ref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1650+
fn read_auto_deref_ref<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
16511651
-> ty::AutoDerefRef<'tcx> {
16521652
self.read_struct("AutoDerefRef", 2, |this| {
16531653
Ok(ty::AutoDerefRef {
@@ -1667,7 +1667,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
16671667
}).unwrap()
16681668
}
16691669

1670-
fn read_autoref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>) -> ty::AutoRef<'tcx> {
1670+
fn read_autoref<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>) -> ty::AutoRef<'tcx> {
16711671
self.read_enum("AutoRef", |this| {
16721672
let variants = ["AutoPtr",
16731673
"AutoUnsize",
@@ -1725,7 +1725,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
17251725
}).unwrap()
17261726
}
17271727

1728-
fn read_unsize_kind<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1728+
fn read_unsize_kind<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
17291729
-> ty::UnsizeKind<'tcx> {
17301730
self.read_enum("UnsizeKind", |this| {
17311731
let variants = &["UnsizeLength", "UnsizeStruct", "UnsizeVtable"];
@@ -1768,7 +1768,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
17681768
}).unwrap()
17691769
}
17701770

1771-
fn read_unboxed_closure<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
1771+
fn read_unboxed_closure<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
17721772
-> ty::UnboxedClosure<'tcx> {
17731773
let closure_type = self.read_opaque(|this, doc| {
17741774
Ok(tydecode::parse_ty_closure_data(

0 commit comments

Comments
 (0)