Check associated types and consts for well-formedness

arielb1 · arielb1 · commit 3923108d4997 · 2015-05-23T20:57:32.000+03:00
Because we don't check the well-formedness of region relationships of
an impl's on the Self-type, or infer region relationss from them, many impls
now have to specify their region relations, making this a [breaking-change].

The most common pattern I found that is now broken is that

    impl&lt;'a, T&gt; IntoIterator for &amp;'a Collection&lt;T&gt; {
        type Item = &amp;'a T;
        type IntoIter = ...;
    }

now has to specify its `T: 'a` bound.
diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs
@@ -675,7 +675,7 @@ impl<T: Ord> IntoIterator for BinaryHeap<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a BinaryHeap<T> where T: Ord {
+impl<'a, T: 'a> IntoIterator for &'a BinaryHeap<T> where T: Ord {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
@@ -500,7 +500,7 @@ impl<K, V> IntoIterator for BTreeMap<K, V> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V> {
+impl<'a, K: 'a, V: 'a> IntoIterator for &'a BTreeMap<K, V> {
     type Item = (&'a K, &'a V);
     type IntoIter = Iter<'a, K, V>;
 
@@ -510,7 +510,7 @@ impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> IntoIterator for &'a mut BTreeMap<K, V> {
+impl<'a, K: 'a, V: 'a> IntoIterator for &'a mut BTreeMap<K, V> {
     type Item = (&'a K, &'a mut V);
     type IntoIter = IterMut<'a, K, V>;
 
diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs
@@ -490,7 +490,7 @@ impl<T> IntoIterator for BTreeSet<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a BTreeSet<T> {
+impl<'a, T: 'a> IntoIterator for &'a BTreeSet<T> {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs
@@ -272,7 +272,7 @@ impl<E:CLike> FromIterator<E> for EnumSet<E> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, E> IntoIterator for &'a EnumSet<E> where E: CLike {
+impl<'a, E: 'a> IntoIterator for &'a EnumSet<E> where E: CLike {
     type Item = E;
     type IntoIter = Iter<E>;
 
diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs
@@ -846,7 +846,7 @@ impl<T> IntoIterator for LinkedList<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a LinkedList<T> {
+impl<'a, T: 'a> IntoIterator for &'a LinkedList<T> {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
@@ -855,7 +855,7 @@ impl<'a, T> IntoIterator for &'a LinkedList<T> {
     }
 }
 
-impl<'a, T> IntoIterator for &'a mut LinkedList<T> {
+impl<'a, T: 'a> IntoIterator for &'a mut LinkedList<T> {
     type Item = &'a mut T;
     type IntoIter = IterMut<'a, T>;
 
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
@@ -1562,7 +1562,7 @@ impl<T> IntoIterator for Vec<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a Vec<T> {
+impl<'a, T: 'a> IntoIterator for &'a Vec<T> {
     type Item = &'a T;
     type IntoIter = slice::Iter<'a, T>;
 
@@ -1572,7 +1572,7 @@ impl<'a, T> IntoIterator for &'a Vec<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a mut Vec<T> {
+impl<'a, T: 'a> IntoIterator for &'a mut Vec<T> {
     type Item = &'a mut T;
     type IntoIter = slice::IterMut<'a, T>;
 
diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs
@@ -1757,7 +1757,7 @@ impl<T> IntoIterator for VecDeque<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a VecDeque<T> {
+impl<'a, T: 'a> IntoIterator for &'a VecDeque<T> {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
@@ -1767,7 +1767,7 @@ impl<'a, T> IntoIterator for &'a VecDeque<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a mut VecDeque<T> {
+impl<'a, T: 'a> IntoIterator for &'a mut VecDeque<T> {
     type Item = &'a mut T;
     type IntoIter = IterMut<'a, T>;
 
diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs
@@ -800,7 +800,7 @@ impl<T> IntoIterator for VecMap<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a VecMap<T> {
+impl<'a, T: 'a> IntoIterator for &'a VecMap<T> {
     type Item = (usize, &'a T);
     type IntoIter = Iter<'a, T>;
 
@@ -810,7 +810,7 @@ impl<'a, T> IntoIterator for &'a VecMap<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a mut VecMap<T> {
+impl<'a, T: 'a> IntoIterator for &'a mut VecMap<T> {
     type Item = (usize, &'a mut T);
     type IntoIter = IterMut<'a, T>;
 
diff --git a/src/libcore/array.rs b/src/libcore/array.rs
@@ -94,7 +94,7 @@ macro_rules! array_impls {
             }
 
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl<'a, T> IntoIterator for &'a [T; $N] {
+            impl<'a, T: 'a> IntoIterator for &'a [T; $N] {
                 type Item = &'a T;
                 type IntoIter = Iter<'a, T>;
 
@@ -104,7 +104,7 @@ macro_rules! array_impls {
             }
 
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl<'a, T> IntoIterator for &'a mut [T; $N] {
+            impl<'a, T: 'a> IntoIterator for &'a mut [T; $N] {
                 type Item = &'a mut T;
                 type IntoIter = IterMut<'a, T>;
 
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
@@ -647,7 +647,7 @@ impl<'a, T> Default for &'a [T] {
 //
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a [T] {
+impl<'a, T: 'a> IntoIterator for &'a [T] {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
@@ -657,7 +657,7 @@ impl<'a, T> IntoIterator for &'a [T] {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a mut [T] {
+impl<'a, T: 'a> IntoIterator for &'a mut [T] {
     type Item = &'a mut T;
     type IntoIter = IterMut<'a, T>;
 
diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs
@@ -538,7 +538,7 @@ impl<T> IntoIterator for VecPerParamSpace<T> {
     }
 }
 
-impl<'a,T> IntoIterator for &'a VecPerParamSpace<T> {
+impl<'a, T: 'a> IntoIterator for &'a VecPerParamSpace<T> {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs
@@ -2982,10 +2982,10 @@ impl<'o,'tcx> TraitObligationStackList<'o,'tcx> {
     }
 }
 
-impl<'o,'tcx> Iterator for TraitObligationStackList<'o,'tcx>{
-    type Item = &'o TraitObligationStack<'o,'tcx>;
+impl<'o, 'tcx: 'o> Iterator for TraitObligationStackList<'o, 'tcx> {
+    type Item = &'o TraitObligationStack<'o, 'tcx>;
 
-    fn next(&mut self) -> Option<&'o TraitObligationStack<'o,'tcx>> {
+    fn next(&mut self) -> Option<&'o TraitObligationStack<'o, 'tcx>> {
         match self.head {
             Some(o) => {
                 *self = o.previous;
@@ -2996,7 +2996,7 @@ impl<'o,'tcx> Iterator for TraitObligationStackList<'o,'tcx>{
     }
 }
 
-impl<'o,'tcx> Repr<'tcx> for TraitObligationStack<'o,'tcx> {
+impl<'o, 'tcx> Repr<'tcx> for TraitObligationStack<'o, 'tcx> {
     fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
         format!("TraitObligationStack({})",
                 self.obligation.repr(tcx))
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
@@ -2328,38 +2328,35 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
         }
     }
 
-    pub fn for_item(cx: &'a ctxt<'tcx>, id: NodeId) -> ParameterEnvironment<'a, 'tcx> {
+    pub fn for_item(cx: &'a ctxt<'tcx>, id: NodeId)
+                    -> ParameterEnvironment<'a, 'tcx>
+    {
+        // TODO: use Self after a snapshot (or remove this comment)
+        ParameterEnvironment::for_item_inner(cx, id, construct_parameter_environment)
+    }
+
+    pub fn for_item_inner<T, F>(cx: &'a ctxt<'tcx>, id: NodeId, f: F) -> T
+        where F: FnOnce(&'a ctxt<'tcx>, Span, &Generics<'tcx>,
+                        &GenericPredicates<'tcx>, NodeId) -> T {
         match cx.map.find(id) {
             Some(ast_map::NodeImplItem(ref impl_item)) => {
                 match impl_item.node {
                     ast::ConstImplItem(_, _) => {
                         let def_id = ast_util::local_def(id);
                         let scheme = lookup_item_type(cx, def_id);
                         let predicates = lookup_predicates(cx, def_id);
-                        construct_parameter_environment(cx,
-                                                        impl_item.span,
-                                                        &scheme.generics,
-                                                        &predicates,
-                                                        id)
+                        f(cx, impl_item.span, &scheme.generics, &predicates, id)
                     }
                     ast::MethodImplItem(_, ref body) => {
                         let method_def_id = ast_util::local_def(id);
                         match ty::impl_or_trait_item(cx, method_def_id) {
-                            MethodTraitItem(ref method_ty) => {
-                                let method_generics = &method_ty.generics;
-                                let method_bounds = &method_ty.predicates;
-                                construct_parameter_environment(
-                                    cx,
-                                    impl_item.span,
-                                    method_generics,
-                                    method_bounds,
-                                    body.id)
-                            }
-                            _ => {
-                                cx.sess
-                                  .bug("ParameterEnvironment::for_item(): \
-                                        got non-method item from impl method?!")
-                            }
+                            MethodTraitItem(ref method_ty) => f(cx,
+                                                                impl_item.span,
+                                                                &method_ty.generics,
+                                                                &method_ty.predicates,
+                                                                body.id),
+                            _ => cx.sess.bug("ParameterEnvironment::for_item(): \
+                                              got non-method item from impl method?!")
                         }
                     }
                     ast::TypeImplItem(_) => {
@@ -2378,11 +2375,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                                 let def_id = ast_util::local_def(id);
                                 let scheme = lookup_item_type(cx, def_id);
                                 let predicates = lookup_predicates(cx, def_id);
-                                construct_parameter_environment(cx,
-                                                                trait_item.span,
-                                                                &scheme.generics,
-                                                                &predicates,
-                                                                id)
+                                f(cx, trait_item.span, &scheme.generics, &predicates, id)
                             }
                             None => {
                                 cx.sess.bug("ParameterEnvironment::from_item(): \
@@ -2401,22 +2394,14 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                     ast::MethodTraitItem(_, Some(ref body)) => {
                         let method_def_id = ast_util::local_def(id);
                         match ty::impl_or_trait_item(cx, method_def_id) {
-                            MethodTraitItem(ref method_ty) => {
-                                let method_generics = &method_ty.generics;
-                                let method_bounds = &method_ty.predicates;
-                                construct_parameter_environment(
-                                    cx,
-                                    trait_item.span,
-                                    method_generics,
-                                    method_bounds,
-                                    body.id)
-                            }
-                            _ => {
-                                cx.sess
-                                  .bug("ParameterEnvironment::for_item(): \
-                                        got non-method item from provided \
-                                        method?!")
-                            }
+                            MethodTraitItem(ref method_ty) => f(cx,
+                                                                trait_item.span,
+                                                                &method_ty.generics,
+                                                                &method_ty.predicates,
+                                                                body.id),
+                            _ => cx.sess.bug("ParameterEnvironment::for_item(): \
+                                              got non-method item from provided \
+                                              method?!")
                         }
                     }
                     ast::TypeTraitItem(..) => {
@@ -2434,11 +2419,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                         let fn_scheme = lookup_item_type(cx, fn_def_id);
                         let fn_predicates = lookup_predicates(cx, fn_def_id);
 
-                        construct_parameter_environment(cx,
-                                                        item.span,
-                                                        &fn_scheme.generics,
-                                                        &fn_predicates,
-                                                        body.id)
+                        f(cx, item.span, &fn_scheme.generics, &fn_predicates, body.id)
                     }
                     ast::ItemEnum(..) |
                     ast::ItemStruct(..) |
@@ -2448,11 +2429,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                         let def_id = ast_util::local_def(id);
                         let scheme = lookup_item_type(cx, def_id);
                         let predicates = lookup_predicates(cx, def_id);
-                        construct_parameter_environment(cx,
-                                                        item.span,
-                                                        &scheme.generics,
-                                                        &predicates,
-                                                        id)
+                        f(cx, item.span, &scheme.generics, &predicates, id)
                     }
                     _ => {
                         cx.sess.span_bug(item.span,
@@ -2464,7 +2441,14 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
             }
             Some(ast_map::NodeExpr(..)) => {
                 // This is a convenience to allow closures to work.
-                ParameterEnvironment::for_item(cx, cx.map.get_parent(id))
+                ParameterEnvironment::for_item_inner(cx, cx.map.get_parent(id), f)
+            }
+            Some(ast_map::NodeForeignItem(ref item)) => {
+                let def_id = ast_util::local_def(id);
+                let scheme = lookup_item_type(cx, def_id);
+                let predicates = lookup_predicates(cx, def_id);
+
+                f(cx, item.span, &scheme.generics, &predicates, id)
             }
             _ => {
                 cx.sess.bug(&format!("ParameterEnvironment::from_item(): \
diff --git a/src/librustc_trans/trans/context.rs b/src/librustc_trans/trans/context.rs
@@ -171,7 +171,7 @@ pub struct CrateContextIterator<'a, 'tcx: 'a> {
     index: usize,
 }
 
-impl<'a, 'tcx> Iterator for CrateContextIterator<'a,'tcx> {
+impl<'a, 'tcx: 'a> Iterator for CrateContextIterator<'a, 'tcx> {
     type Item = CrateContext<'a, 'tcx>;
 
     fn next(&mut self) -> Option<CrateContext<'a, 'tcx>> {
@@ -198,7 +198,7 @@ pub struct CrateContextMaybeIterator<'a, 'tcx: 'a> {
     origin: usize,
 }
 
-impl<'a, 'tcx> Iterator for CrateContextMaybeIterator<'a, 'tcx> {
+impl<'a, 'tcx: 'a> Iterator for CrateContextMaybeIterator<'a, 'tcx> {
     type Item = (CrateContext<'a, 'tcx>, bool);
 
     fn next(&mut self) -> Option<(CrateContext<'a, 'tcx>, bool)> {
diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs
diff --git a/src/test/compile-fail/wf-non-well-formed.rs b/src/test/compile-fail/wf-non-well-formed.rs
diff --git a/src/test/run-pass/associated-types-nested-projections.rs b/src/test/run-pass/associated-types-nested-projections.rs

Original file line number	Diff line number	Diff line change
`@@ -675,7 +675,7 @@ impl<T: Ord> IntoIterator for BinaryHeap<T> {`
`675`	`675`	`}`
`676`	`676`
`677`	`677`	`#[stable(feature = "rust1", since = "1.0.0")]`
`678`		`-impl<'a, T> IntoIterator for &'a BinaryHeap<T> where T: Ord {`
	`678`	`+impl<'a, T: 'a> IntoIterator for &'a BinaryHeap<T> where T: Ord {`
`679`	`679`	`type Item = &'a T;`
`680`	`680`	`type IntoIter = Iter<'a, T>;`
`681`	`681`
Original file line number	Diff line number	Diff line change
`@@ -500,7 +500,7 @@ impl<K, V> IntoIterator for BTreeMap<K, V> {`
`500`	`500`	`}`
`501`	`501`
`502`	`502`	`#[stable(feature = "rust1", since = "1.0.0")]`
`503`		`-impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V> {`
	`503`	`+impl<'a, K: 'a, V: 'a> IntoIterator for &'a BTreeMap<K, V> {`
`504`	`504`	`type Item = (&'a K, &'a V);`
`505`	`505`	`type IntoIter = Iter<'a, K, V>;`
`506`	`506`
`@@ -510,7 +510,7 @@ impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V> {`
`510`	`510`	`}`
`511`	`511`
`512`	`512`	`#[stable(feature = "rust1", since = "1.0.0")]`
`513`		`-impl<'a, K, V> IntoIterator for &'a mut BTreeMap<K, V> {`
	`513`	`+impl<'a, K: 'a, V: 'a> IntoIterator for &'a mut BTreeMap<K, V> {`
`514`	`514`	`type Item = (&'a K, &'a mut V);`
`515`	`515`	`type IntoIter = IterMut<'a, K, V>;`
`516`	`516`
Original file line number	Diff line number	Diff line change
`@@ -490,7 +490,7 @@ impl<T> IntoIterator for BTreeSet<T> {`
`490`	`490`	`}`
`491`	`491`
`492`	`492`	`#[stable(feature = "rust1", since = "1.0.0")]`
`493`		`-impl<'a, T> IntoIterator for &'a BTreeSet<T> {`
	`493`	`+impl<'a, T: 'a> IntoIterator for &'a BTreeSet<T> {`
`494`	`494`	`type Item = &'a T;`
`495`	`495`	`type IntoIter = Iter<'a, T>;`
`496`	`496`
Original file line number	Diff line number	Diff line change
`@@ -272,7 +272,7 @@ impl<E:CLike> FromIterator<E> for EnumSet<E> {`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`#[stable(feature = "rust1", since = "1.0.0")]`
`275`		`-impl<'a, E> IntoIterator for &'a EnumSet<E> where E: CLike {`
	`275`	`+impl<'a, E: 'a> IntoIterator for &'a EnumSet<E> where E: CLike {`
`276`	`276`	`type Item = E;`
`277`	`277`	`type IntoIter = Iter<E>;`
`278`	`278`
Original file line number	Diff line number	Diff line change
`@@ -846,7 +846,7 @@ impl<T> IntoIterator for LinkedList<T> {`
`846`	`846`	`}`
`847`	`847`
`848`	`848`	`#[stable(feature = "rust1", since = "1.0.0")]`
`849`		`-impl<'a, T> IntoIterator for &'a LinkedList<T> {`
	`849`	`+impl<'a, T: 'a> IntoIterator for &'a LinkedList<T> {`
`850`	`850`	`type Item = &'a T;`
`851`	`851`	`type IntoIter = Iter<'a, T>;`
`852`	`852`
`@@ -855,7 +855,7 @@ impl<'a, T> IntoIterator for &'a LinkedList<T> {`
`855`	`855`	`}`
`856`	`856`	`}`
`857`	`857`
`858`		`-impl<'a, T> IntoIterator for &'a mut LinkedList<T> {`
	`858`	`+impl<'a, T: 'a> IntoIterator for &'a mut LinkedList<T> {`
`859`	`859`	`type Item = &'a mut T;`
`860`	`860`	`type IntoIter = IterMut<'a, T>;`
`861`	`861`
Original file line number	Diff line number	Diff line change
`@@ -1562,7 +1562,7 @@ impl<T> IntoIterator for Vec<T> {`
`1562`	`1562`	`}`
`1563`	`1563`
`1564`	`1564`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1565`		`-impl<'a, T> IntoIterator for &'a Vec<T> {`
	`1565`	`+impl<'a, T: 'a> IntoIterator for &'a Vec<T> {`
`1566`	`1566`	`type Item = &'a T;`
`1567`	`1567`	`type IntoIter = slice::Iter<'a, T>;`
`1568`	`1568`
`@@ -1572,7 +1572,7 @@ impl<'a, T> IntoIterator for &'a Vec<T> {`
`1572`	`1572`	`}`
`1573`	`1573`
`1574`	`1574`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1575`		`-impl<'a, T> IntoIterator for &'a mut Vec<T> {`
	`1575`	`+impl<'a, T: 'a> IntoIterator for &'a mut Vec<T> {`
`1576`	`1576`	`type Item = &'a mut T;`
`1577`	`1577`	`type IntoIter = slice::IterMut<'a, T>;`
`1578`	`1578`
Original file line number	Diff line number	Diff line change
`@@ -1757,7 +1757,7 @@ impl<T> IntoIterator for VecDeque<T> {`
`1757`	`1757`	`}`
`1758`	`1758`
`1759`	`1759`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1760`		`-impl<'a, T> IntoIterator for &'a VecDeque<T> {`
	`1760`	`+impl<'a, T: 'a> IntoIterator for &'a VecDeque<T> {`
`1761`	`1761`	`type Item = &'a T;`
`1762`	`1762`	`type IntoIter = Iter<'a, T>;`
`1763`	`1763`
`@@ -1767,7 +1767,7 @@ impl<'a, T> IntoIterator for &'a VecDeque<T> {`
`1767`	`1767`	`}`
`1768`	`1768`
`1769`	`1769`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1770`		`-impl<'a, T> IntoIterator for &'a mut VecDeque<T> {`
	`1770`	`+impl<'a, T: 'a> IntoIterator for &'a mut VecDeque<T> {`
`1771`	`1771`	`type Item = &'a mut T;`
`1772`	`1772`	`type IntoIter = IterMut<'a, T>;`
`1773`	`1773`
Original file line number	Diff line number	Diff line change
`@@ -800,7 +800,7 @@ impl<T> IntoIterator for VecMap<T> {`
`800`	`800`	`}`
`801`	`801`
`802`	`802`	`#[stable(feature = "rust1", since = "1.0.0")]`
`803`		`-impl<'a, T> IntoIterator for &'a VecMap<T> {`
	`803`	`+impl<'a, T: 'a> IntoIterator for &'a VecMap<T> {`
`804`	`804`	`type Item = (usize, &'a T);`
`805`	`805`	`type IntoIter = Iter<'a, T>;`
`806`	`806`
`@@ -810,7 +810,7 @@ impl<'a, T> IntoIterator for &'a VecMap<T> {`
`810`	`810`	`}`
`811`	`811`
`812`	`812`	`#[stable(feature = "rust1", since = "1.0.0")]`
`813`		`-impl<'a, T> IntoIterator for &'a mut VecMap<T> {`
	`813`	`+impl<'a, T: 'a> IntoIterator for &'a mut VecMap<T> {`
`814`	`814`	`type Item = (usize, &'a mut T);`
`815`	`815`	`type IntoIter = IterMut<'a, T>;`
`816`	`816`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ macro_rules! array_impls {`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`#[stable(feature = "rust1", since = "1.0.0")]`
`97`		`- impl<'a, T> IntoIterator for &'a [T; $N] {`
	`97`	`+ impl<'a, T: 'a> IntoIterator for &'a [T; $N] {`
`98`	`98`	`type Item = &'a T;`
`99`	`99`	`type IntoIter = Iter<'a, T>;`
`100`	`100`
`@@ -104,7 +104,7 @@ macro_rules! array_impls {`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`#[stable(feature = "rust1", since = "1.0.0")]`
`107`		`- impl<'a, T> IntoIterator for &'a mut [T; $N] {`
	`107`	`+ impl<'a, T: 'a> IntoIterator for &'a mut [T; $N] {`
`108`	`108`	`type Item = &'a mut T;`
`109`	`109`	`type IntoIter = IterMut<'a, T>;`
`110`	`110`
Original file line number	Diff line number	Diff line change
`@@ -538,7 +538,7 @@ impl<T> IntoIterator for VecPerParamSpace<T> {`
`538`	`538`	`}`
`539`	`539`	`}`
`540`	`540`
`541`		`-impl<'a,T> IntoIterator for &'a VecPerParamSpace<T> {`
	`541`	`+impl<'a, T: 'a> IntoIterator for &'a VecPerParamSpace<T> {`
`542`	`542`	`type Item = &'a T;`
`543`	`543`	`type IntoIter = Iter<'a, T>;`
`544`	`544`