From cedc6753f2bb8aedf527245ba9874e85cf669ac2 Mon Sep 17 00:00:00 2001 From: Keegan McAllister Date: Sat, 31 Jan 2015 14:54:43 -0800 Subject: Fix end of TtDelimited span --- src/libsyntax/parse/mod.rs | 23 +++++++++++++++++++++++ src/libsyntax/parse/parser.rs | 2 +- 2 files changed, 24 insertions(+), 1 deletion(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index e7be876edbb..6e368bfa803 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -755,6 +755,7 @@ mod test { use ast; use abi; use attr::{first_attr_value_str_by_name, AttrMetaMethods}; + use parse; use parse::parser::Parser; use parse::token::{str_to_ident}; use print::pprust::item_to_string; @@ -1214,4 +1215,26 @@ mod test { let doc = first_attr_value_str_by_name(item.attrs.as_slice(), "doc").unwrap(); assert_eq!(doc.get(), "/** doc comment\n * with CRLF */"); } + + #[test] + fn ttdelim_span() { + let sess = parse::new_parse_sess(); + let expr = parse::parse_expr_from_source_str("foo".to_string(), + "foo!( fn main() { body } )".to_string(), vec![], &sess); + + let tts = match expr.node { + ast::ExprMac(ref mac) => { + let ast::MacInvocTT(_, ref tts, _) = mac.node; + tts.clone() + } + _ => panic!("not a macro"), + }; + + let span = tts.iter().rev().next().unwrap().get_span(); + + match sess.span_diagnostic.cm.span_to_snippet(span) { + Some(s) => assert_eq!(&s[], "{ body }"), + None => panic!("could not get snippet"), + } + } } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index d99095eeba3..8e88f5a5679 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2735,7 +2735,7 @@ impl<'a> Parser<'a> { self.open_braces.pop().unwrap(); // Expand to cover the entire delimited token tree - let span = Span { hi: self.span.hi, ..pre_span }; + let span = Span { hi: close_span.hi, ..pre_span }; TtDelimited(span, Rc::new(Delimited { delim: delim, -- cgit 1.4.1-3-g733a5 From 0828efd72f0c1a1823426f327cddfbced535117a Mon Sep 17 00:00:00 2001 From: Potpourri Date: Sun, 1 Feb 2015 00:59:58 +0300 Subject: Reject syntax like `use foo::bar::;` and `use foo:: as bar;` and keywords in view path idents --- src/libsyntax/parse/parser.rs | 11 ++++++++--- src/test/compile-fail/use-as-where-use-ends-with-mod-sep.rs | 11 +++++++++++ src/test/compile-fail/use-ends-with-mod-sep.rs | 11 +++++++++++ 3 files changed, 30 insertions(+), 3 deletions(-) create mode 100644 src/test/compile-fail/use-as-where-use-ends-with-mod-sep.rs create mode 100644 src/test/compile-fail/use-ends-with-mod-sep.rs (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index d99095eeba3..e2b58e6d87e 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -5912,9 +5912,9 @@ impl<'a> Parser<'a> { self.bump(); match self.token { - token::Ident(i, _) => { - self.bump(); - path.push(i); + token::Ident(..) => { + let ident = self.parse_ident(); + path.push(ident); } // foo::bar::{a,b,c} @@ -5954,6 +5954,11 @@ impl<'a> Parser<'a> { return P(spanned(lo, self.span.hi, ViewPathGlob(path))); } + // fall-through for case foo::bar::; + token::Semi => { + self.span_err(self.span, "expected identifier or `{` or `*`, found `;`"); + } + _ => break } } diff --git a/src/test/compile-fail/use-as-where-use-ends-with-mod-sep.rs b/src/test/compile-fail/use-as-where-use-ends-with-mod-sep.rs new file mode 100644 index 00000000000..ef443fc125d --- /dev/null +++ b/src/test/compile-fail/use-as-where-use-ends-with-mod-sep.rs @@ -0,0 +1,11 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::any:: as foo; //~ ERROR expected identifier or `{` or `*`, found `as` diff --git a/src/test/compile-fail/use-ends-with-mod-sep.rs b/src/test/compile-fail/use-ends-with-mod-sep.rs new file mode 100644 index 00000000000..a375a5962a5 --- /dev/null +++ b/src/test/compile-fail/use-ends-with-mod-sep.rs @@ -0,0 +1,11 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::any::; //~ ERROR expected identifier or `{` or `*`, found `;` -- cgit 1.4.1-3-g733a5 From 0e4448409ef61c703b98e4c5b2fd99447308942d Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sun, 1 Feb 2015 12:15:36 -0800 Subject: std: Remove extra type params on iter adaptors Now that associated types are fully implemented the iterator adaptors only need type parameters which are associated with actual storage. All other type parameters can either be derived from these (e.g. they are an associated type) or can be bare on the `impl` block itself. This is a breaking change due to the removal of type parameters on these iterator adaptors, but code can fairly easily migrate by just deleting the relevant type parameters for each adaptor. Other behavior should not be affected. Closes #21839 [breaking-change] --- src/libcollections/btree/map.rs | 4 +- src/libcollections/btree/set.rs | 20 +- src/libcollections/vec_map.rs | 8 +- src/libcore/iter.rs | 350 ++++++++++---------------------- src/libcore/str/mod.rs | 4 +- src/librustc_trans/trans/basic_block.rs | 7 +- src/libstd/collections/hash/map.rs | 18 +- src/libstd/collections/hash/set.rs | 4 +- src/libstd/path/posix.rs | 2 +- src/libstd/path/windows.rs | 4 +- src/libsyntax/parse/mod.rs | 4 +- src/libunicode/u_str.rs | 2 +- 12 files changed, 137 insertions(+), 290 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index ce5e8f07be1..b007f275980 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -116,13 +116,13 @@ pub struct IntoIter { /// An iterator over a BTreeMap's keys. #[stable(feature = "rust1", since = "1.0.0")] pub struct Keys<'a, K: 'a, V: 'a> { - inner: Map<(&'a K, &'a V), &'a K, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a K> + inner: Map, fn((&'a K, &'a V)) -> &'a K> } /// An iterator over a BTreeMap's values. #[stable(feature = "rust1", since = "1.0.0")] pub struct Values<'a, K: 'a, V: 'a> { - inner: Map<(&'a K, &'a V), &'a V, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V> + inner: Map, fn((&'a K, &'a V)) -> &'a V> } /// An iterator over a sub-range of BTreeMap's entries. diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 72d5bf6d799..1445db12a90 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -45,40 +45,40 @@ pub struct Iter<'a, T: 'a> { /// An owning iterator over a BTreeSet's items. #[stable(feature = "rust1", since = "1.0.0")] pub struct IntoIter { - iter: Map<(T, ()), T, ::btree_map::IntoIter, fn((T, ())) -> T> + iter: Map<::btree_map::IntoIter, fn((T, ())) -> T> } /// An iterator over a sub-range of BTreeSet's items. pub struct Range<'a, T: 'a> { - iter: Map<(&'a T, &'a ()), &'a T, ::btree_map::Range<'a, T, ()>, fn((&'a T, &'a ())) -> &'a T> + iter: Map<::btree_map::Range<'a, T, ()>, fn((&'a T, &'a ())) -> &'a T> } /// A lazy iterator producing elements in the set difference (in-order). #[stable(feature = "rust1", since = "1.0.0")] pub struct Difference<'a, T:'a> { - a: Peekable<&'a T, Iter<'a, T>>, - b: Peekable<&'a T, Iter<'a, T>>, + a: Peekable>, + b: Peekable>, } /// A lazy iterator producing elements in the set symmetric difference (in-order). #[stable(feature = "rust1", since = "1.0.0")] pub struct SymmetricDifference<'a, T:'a> { - a: Peekable<&'a T, Iter<'a, T>>, - b: Peekable<&'a T, Iter<'a, T>>, + a: Peekable>, + b: Peekable>, } /// A lazy iterator producing elements in the set intersection (in-order). #[stable(feature = "rust1", since = "1.0.0")] pub struct Intersection<'a, T:'a> { - a: Peekable<&'a T, Iter<'a, T>>, - b: Peekable<&'a T, Iter<'a, T>>, + a: Peekable>, + b: Peekable>, } /// A lazy iterator producing elements in the set union (in-order). #[stable(feature = "rust1", since = "1.0.0")] pub struct Union<'a, T:'a> { - a: Peekable<&'a T, Iter<'a, T>>, - b: Peekable<&'a T, Iter<'a, T>>, + a: Peekable>, + b: Peekable>, } impl BTreeSet { diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index f2a9bb4392c..b677b361300 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -687,7 +687,7 @@ double_ended_iterator! { impl IterMut -> (uint, &'a mut V), as_mut } /// An iterator over the keys of a map. #[stable(feature = "rust1", since = "1.0.0")] pub struct Keys<'a, V: 'a> { - iter: Map<(uint, &'a V), uint, Iter<'a, V>, fn((uint, &'a V)) -> uint> + iter: Map, fn((uint, &'a V)) -> uint> } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -702,7 +702,7 @@ impl<'a, V> Clone for Keys<'a, V> { /// An iterator over the values of a map. #[stable(feature = "rust1", since = "1.0.0")] pub struct Values<'a, V: 'a> { - iter: Map<(uint, &'a V), &'a V, Iter<'a, V>, fn((uint, &'a V)) -> &'a V> + iter: Map, fn((uint, &'a V)) -> &'a V> } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -718,8 +718,6 @@ impl<'a, V> Clone for Values<'a, V> { #[stable(feature = "rust1", since = "1.0.0")] pub struct IntoIter { iter: FilterMap< - (uint, Option), - (uint, V), Enumerate>>, fn((uint, Option)) -> Option<(uint, V)>> } @@ -727,8 +725,6 @@ pub struct IntoIter { #[unstable(feature = "collections")] pub struct Drain<'a, V> { iter: FilterMap< - (uint, Option), - (uint, V), Enumerate>>, fn((uint, Option)) -> Option<(uint, V)>> } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 751b5959d8b..84db07266b8 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -239,9 +239,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn zip(self, other: U) -> Zip where - U: Iterator, - { + fn zip(self, other: U) -> Zip { Zip{a: self, b: other} } @@ -259,7 +257,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn map(self, f: F) -> Map where + fn map(self, f: F) -> Map where F: FnMut(Self::Item) -> B, { Map{iter: self, f: f} @@ -279,7 +277,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn filter

(self, predicate: P) -> Filter where + fn filter

(self, predicate: P) -> Filter where P: FnMut(&Self::Item) -> bool, { Filter{iter: self, predicate: predicate} @@ -299,7 +297,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn filter_map(self, f: F) -> FilterMap where + fn filter_map(self, f: F) -> FilterMap where F: FnMut(Self::Item) -> Option, { FilterMap { iter: self, f: f } @@ -342,7 +340,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn peekable(self) -> Peekable { + fn peekable(self) -> Peekable { Peekable{iter: self, peeked: None} } @@ -362,7 +360,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn skip_while

(self, predicate: P) -> SkipWhile where + fn skip_while

(self, predicate: P) -> SkipWhile where P: FnMut(&Self::Item) -> bool, { SkipWhile{iter: self, flag: false, predicate: predicate} @@ -383,7 +381,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn take_while

(self, predicate: P) -> TakeWhile where + fn take_while

(self, predicate: P) -> TakeWhile where P: FnMut(&Self::Item) -> bool, { TakeWhile{iter: self, flag: false, predicate: predicate} @@ -448,12 +446,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn scan( - self, - initial_state: St, - f: F, - ) -> Scan where - F: FnMut(&mut St, Self::Item) -> Option, + fn scan(self, initial_state: St, f: F) -> Scan + where F: FnMut(&mut St, Self::Item) -> Option, { Scan{iter: self, f: f, state: initial_state} } @@ -474,9 +468,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn flat_map(self, f: F) -> FlatMap where - U: Iterator, - F: FnMut(Self::Item) -> U, + fn flat_map(self, f: F) -> FlatMap + where U: Iterator, F: FnMut(Self::Item) -> U, { FlatMap{iter: self, f: f, frontiter: None, backiter: None } } @@ -534,7 +527,7 @@ pub trait IteratorExt: Iterator + Sized { /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] - fn inspect(self, f: F) -> Inspect where + fn inspect(self, f: F) -> Inspect where F: FnMut(&Self::Item), { Inspect{iter: self, f: f} @@ -1077,16 +1070,14 @@ pub trait ExactSizeIterator: Iterator { #[stable(feature = "rust1", since = "1.0.0")] impl ExactSizeIterator for Enumerate where I: ExactSizeIterator {} #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for Inspect where - I: ExactSizeIterator, - F: FnMut(&A), +impl ExactSizeIterator for Inspect where + F: FnMut(&I::Item), {} #[stable(feature = "rust1", since = "1.0.0")] impl ExactSizeIterator for Rev where I: ExactSizeIterator + DoubleEndedIterator {} #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for Map where - I: ExactSizeIterator, - F: FnMut(A) -> B, +impl ExactSizeIterator for Map where + F: FnMut(I::Item) -> B, {} #[stable(feature = "rust1", since = "1.0.0")] impl ExactSizeIterator for Zip where A: ExactSizeIterator, B: ExactSizeIterator {} @@ -1561,28 +1552,15 @@ impl RandomAccessIterator for Zip where /// An iterator that maps the values of `iter` with `f` #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct Map, F: FnMut(A) -> B> { +#[derive(Clone)] +pub struct Map { iter: I, f: F, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` -#[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Map where - I: Clone + Iterator, - F: Clone + FnMut(A) -> B, -{ - fn clone(&self) -> Map { - Map { - iter: self.iter.clone(), - f: self.f.clone(), - } - } -} - -impl Map where I: Iterator, F: FnMut(A) -> B { +impl Map where F: FnMut(I::Item) -> B { #[inline] - fn do_map(&mut self, elt: Option) -> Option { + fn do_map(&mut self, elt: Option) -> Option { match elt { Some(a) => Some((self.f)(a)), _ => None @@ -1591,7 +1569,7 @@ impl Map where I: Iterator, F: FnMut(A) -> B { } #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for Map where I: Iterator, F: FnMut(A) -> B { +impl Iterator for Map where F: FnMut(I::Item) -> B { type Item = B; #[inline] @@ -1607,9 +1585,8 @@ impl Iterator for Map where I: Iterator, F: FnMu } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for Map where - I: DoubleEndedIterator, - F: FnMut(A) -> B, +impl DoubleEndedIterator for Map where + F: FnMut(I::Item) -> B, { #[inline] fn next_back(&mut self) -> Option { @@ -1619,9 +1596,8 @@ impl DoubleEndedIterator for Map where } #[unstable(feature = "core", reason = "trait is experimental")] -impl RandomAccessIterator for Map where - I: RandomAccessIterator, - F: FnMut(A) -> B, +impl RandomAccessIterator for Map where + F: FnMut(I::Item) -> B, { #[inline] fn indexable(&self) -> usize { @@ -1638,31 +1614,18 @@ impl RandomAccessIterator for Map where /// An iterator that filters the elements of `iter` with `predicate` #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct Filter where I: Iterator, P: FnMut(&A) -> bool { +#[derive(Clone)] +pub struct Filter { iter: I, predicate: P, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` -#[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Filter where - I: Clone + Iterator, - P: Clone + FnMut(&A) -> bool, -{ - fn clone(&self) -> Filter { - Filter { - iter: self.iter.clone(), - predicate: self.predicate.clone(), - } - } -} - #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for Filter where I: Iterator, P: FnMut(&A) -> bool { - type Item = A; +impl Iterator for Filter where P: FnMut(&I::Item) -> bool { + type Item = I::Item; #[inline] - fn next(&mut self) -> Option { + fn next(&mut self) -> Option { for x in self.iter.by_ref() { if (self.predicate)(&x) { return Some(x); @@ -1681,12 +1644,11 @@ impl Iterator for Filter where I: Iterator, P: FnMut(& } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for Filter where - I: DoubleEndedIterator, - P: FnMut(&A) -> bool, +impl DoubleEndedIterator for Filter + where P: FnMut(&I::Item) -> bool, { #[inline] - fn next_back(&mut self) -> Option { + fn next_back(&mut self) -> Option { for x in self.iter.by_ref().rev() { if (self.predicate)(&x) { return Some(x); @@ -1699,29 +1661,15 @@ impl DoubleEndedIterator for Filter where /// An iterator that uses `f` to both filter and map elements from `iter` #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct FilterMap where I: Iterator, F: FnMut(A) -> Option { +#[derive(Clone)] +pub struct FilterMap { iter: I, f: F, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for FilterMap where - I: Clone + Iterator, - F: Clone + FnMut(A) -> Option, -{ - fn clone(&self) -> FilterMap { - FilterMap { - iter: self.iter.clone(), - f: self.f.clone(), - } - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for FilterMap where - I: Iterator, - F: FnMut(A) -> Option, +impl Iterator for FilterMap + where F: FnMut(I::Item) -> Option, { type Item = B; @@ -1744,9 +1692,8 @@ impl Iterator for FilterMap where } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for FilterMap where - I: DoubleEndedIterator, - F: FnMut(A) -> Option, +impl DoubleEndedIterator for FilterMap + where F: FnMut(I::Item) -> Option, { #[inline] fn next_back(&mut self) -> Option { @@ -1824,20 +1771,28 @@ impl RandomAccessIterator for Enumerate where I: RandomAccessIterator { } /// An iterator with a `peek()` that returns an optional reference to the next element. -#[derive(Clone)] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct Peekable where I: Iterator { +pub struct Peekable { iter: I, - peeked: Option, + peeked: Option, +} + +impl Clone for Peekable where I::Item: Clone { + fn clone(&self) -> Peekable { + Peekable { + iter: self.iter.clone(), + peeked: self.peeked.clone(), + } + } } #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for Peekable where I: Iterator { - type Item = T; +impl Iterator for Peekable { + type Item = I::Item; #[inline] - fn next(&mut self) -> Option { + fn next(&mut self) -> Option { if self.peeked.is_some() { self.peeked.take() } else { self.iter.next() } } @@ -1859,14 +1814,14 @@ impl Iterator for Peekable where I: Iterator { } #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for Peekable where I: ExactSizeIterator {} +impl ExactSizeIterator for Peekable {} #[stable(feature = "rust1", since = "1.0.0")] -impl Peekable where I: Iterator { - /// Return a reference to the next element of the iterator with out advancing it, - /// or None if the iterator is exhausted. +impl Peekable { + /// Return a reference to the next element of the iterator with out + /// advancing it, or None if the iterator is exhausted. #[inline] - pub fn peek(&mut self) -> Option<&T> { + pub fn peek(&mut self) -> Option<&I::Item> { if self.peeked.is_none() { self.peeked = self.iter.next(); } @@ -1886,33 +1841,21 @@ impl Peekable where I: Iterator { /// An iterator that rejects elements while `predicate` is true #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct SkipWhile where I: Iterator, P: FnMut(&A) -> bool { +#[derive(Clone)] +pub struct SkipWhile { iter: I, flag: bool, predicate: P, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for SkipWhile where - I: Clone + Iterator, - P: Clone + FnMut(&A) -> bool, +impl Iterator for SkipWhile + where P: FnMut(&I::Item) -> bool { - fn clone(&self) -> SkipWhile { - SkipWhile { - iter: self.iter.clone(), - flag: self.flag, - predicate: self.predicate.clone(), - } - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for SkipWhile where I: Iterator, P: FnMut(&A) -> bool { - type Item = A; + type Item = I::Item; #[inline] - fn next(&mut self) -> Option { + fn next(&mut self) -> Option { for x in self.iter.by_ref() { if self.flag || !(self.predicate)(&x) { self.flag = true; @@ -1932,33 +1875,21 @@ impl Iterator for SkipWhile where I: Iterator, P: FnMu /// An iterator that only accepts elements while `predicate` is true #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct TakeWhile where I: Iterator, P: FnMut(&A) -> bool { +#[derive(Clone)] +pub struct TakeWhile { iter: I, flag: bool, predicate: P, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for TakeWhile where - I: Clone + Iterator, - P: Clone + FnMut(&A) -> bool, +impl Iterator for TakeWhile + where P: FnMut(&I::Item) -> bool { - fn clone(&self) -> TakeWhile { - TakeWhile { - iter: self.iter.clone(), - flag: self.flag, - predicate: self.predicate.clone(), - } - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for TakeWhile where I: Iterator, P: FnMut(&A) -> bool { - type Item = A; + type Item = I::Item; #[inline] - fn next(&mut self) -> Option { + fn next(&mut self) -> Option { if self.flag { None } else { @@ -2118,7 +2049,8 @@ impl ExactSizeIterator for Take where I: ExactSizeIterator {} /// An iterator to maintain state while iterating another iterator #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct Scan where I: Iterator, F: FnMut(&mut St, A) -> Option { +#[derive(Clone)] +pub struct Scan { iter: I, f: F, @@ -2126,26 +2058,9 @@ pub struct Scan where I: Iterator, F: FnMut(&mut St, A) -> Optio pub state: St, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Scan where - I: Clone + Iterator, - St: Clone, - F: Clone + FnMut(&mut St, A) -> Option, -{ - fn clone(&self) -> Scan { - Scan { - iter: self.iter.clone(), - f: self.f.clone(), - state: self.state.clone(), - } - } -} - -#[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for Scan where - I: Iterator, - F: FnMut(&mut St, A) -> Option, +impl Iterator for Scan where + F: FnMut(&mut St, I::Item) -> Option, { type Item = B; @@ -2166,44 +2081,22 @@ impl Iterator for Scan where /// #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct FlatMap where - I: Iterator, - U: Iterator, - F: FnMut(A) -> U, -{ +#[derive(Clone)] +pub struct FlatMap { iter: I, f: F, frontiter: Option, backiter: Option, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` -#[stable(feature = "rust1", since = "1.0.0")] -impl Clone for FlatMap where - I: Clone + Iterator, - U: Clone + Iterator, - F: Clone + FnMut(A) -> U, -{ - fn clone(&self) -> FlatMap { - FlatMap { - iter: self.iter.clone(), - f: self.f.clone(), - frontiter: self.frontiter.clone(), - backiter: self.backiter.clone(), - } - } -} - #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for FlatMap where - I: Iterator, - U: Iterator, - F: FnMut(A) -> U, +impl Iterator for FlatMap + where F: FnMut(I::Item) -> U, { - type Item = B; + type Item = U::Item; #[inline] - fn next(&mut self) -> Option { + fn next(&mut self) -> Option { loop { for inner in self.frontiter.iter_mut() { for x in inner.by_ref() { @@ -2230,13 +2123,12 @@ impl Iterator for FlatMap where } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for FlatMap where - I: DoubleEndedIterator, - U: DoubleEndedIterator, - F: FnMut(A) -> U, +impl DoubleEndedIterator + for FlatMap + where F: FnMut(I::Item) -> U { #[inline] - fn next_back(&mut self) -> Option { + fn next_back(&mut self) -> Option { loop { for inner in self.backiter.iter_mut() { match inner.next_back() { @@ -2340,28 +2232,15 @@ impl Fuse { /// element before yielding it. #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] -pub struct Inspect where I: Iterator, F: FnMut(&A) { +#[derive(Clone)] +pub struct Inspect { iter: I, f: F, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` -#[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Inspect where - I: Clone + Iterator, - F: Clone + FnMut(&A), -{ - fn clone(&self) -> Inspect { - Inspect { - iter: self.iter.clone(), - f: self.f.clone(), - } - } -} - -impl Inspect where I: Iterator, F: FnMut(&A) { +impl Inspect where F: FnMut(&I::Item) { #[inline] - fn do_inspect(&mut self, elt: Option) -> Option { + fn do_inspect(&mut self, elt: Option) -> Option { match elt { Some(ref a) => (self.f)(a), None => () @@ -2372,11 +2251,11 @@ impl Inspect where I: Iterator, F: FnMut(&A) { } #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for Inspect where I: Iterator, F: FnMut(&A) { - type Item = A; +impl Iterator for Inspect where F: FnMut(&I::Item) { + type Item = I::Item; #[inline] - fn next(&mut self) -> Option { + fn next(&mut self) -> Option { let next = self.iter.next(); self.do_inspect(next) } @@ -2388,21 +2267,19 @@ impl Iterator for Inspect where I: Iterator, F: FnMut( } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for Inspect where - I: DoubleEndedIterator, - F: FnMut(&A), +impl DoubleEndedIterator for Inspect + where F: FnMut(&I::Item), { #[inline] - fn next_back(&mut self) -> Option { + fn next_back(&mut self) -> Option { let next = self.iter.next_back(); self.do_inspect(next) } } #[unstable(feature = "core", reason = "trait is experimental")] -impl RandomAccessIterator for Inspect where - I: RandomAccessIterator, - F: FnMut(&A), +impl RandomAccessIterator for Inspect + where F: FnMut(&I::Item), { #[inline] fn indexable(&self) -> usize { @@ -2410,7 +2287,7 @@ impl RandomAccessIterator for Inspect where } #[inline] - fn idx(&mut self, index: usize) -> Option { + fn idx(&mut self, index: usize) -> Option { let element = self.iter.idx(index); self.do_inspect(element) } @@ -2426,9 +2303,11 @@ impl RandomAccessIterator for Inspect where /// use std::iter::Unfold; /// use std::num::Int; // For `.checked_add()` /// -/// // This iterator will yield up to the last Fibonacci number before the max value of `u32`. -/// // You can simply change `u32` to `u64` in this line if you want higher values than that. -/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), |&mut (ref mut x2, ref mut x1)| { +/// // This iterator will yield up to the last Fibonacci number before the max +/// // value of `u32`. You can simply change `u32` to `u64` in this line if +/// // you want higher values than that. +/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), +/// |&mut (ref mut x2, ref mut x1)| { /// // Attempt to get the next Fibonacci number /// // `x1` will be `None` if previously overflowed. /// let next = match (*x2, *x1) { @@ -2449,32 +2328,19 @@ impl RandomAccessIterator for Inspect where /// } /// ``` #[unstable(feature = "core")] -pub struct Unfold where F: FnMut(&mut St) -> Option { +#[derive(Clone)] +pub struct Unfold { f: F, /// Internal state that will be passed to the closure on the next iteration pub state: St, } -// FIXME(#19839) Remove in favor of `#[derive(Clone)]` -#[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Unfold where - F: Clone + FnMut(&mut St) -> Option, - St: Clone, -{ - fn clone(&self) -> Unfold { - Unfold { - f: self.f.clone(), - state: self.state.clone(), - } - } -} - #[unstable(feature = "core")] -impl Unfold where F: FnMut(&mut St) -> Option { +impl Unfold where F: FnMut(&mut St) -> Option { /// Creates a new iterator with the specified closure as the "iterator /// function" and an initial state to eventually pass to the closure #[inline] - pub fn new(initial_state: St, f: F) -> Unfold { + pub fn new(initial_state: St, f: F) -> Unfold { Unfold { f: f, state: initial_state @@ -2483,7 +2349,7 @@ impl Unfold where F: FnMut(&mut St) -> Option { } #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for Unfold where F: FnMut(&mut St) -> Option { +impl Iterator for Unfold where F: FnMut(&mut St) -> Option { type Item = A; #[inline] @@ -2921,7 +2787,7 @@ type IterateState = (F, Option, bool); /// An iterator that repeatedly applies a given function, starting /// from a given seed value. #[unstable(feature = "core")] -pub type Iterate = Unfold, fn(&mut IterateState) -> Option>; +pub type Iterate = Unfold, fn(&mut IterateState) -> Option>; /// Create a new iterator that produces an infinite sequence of /// repeated applications of the given function `f`. diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index cb7af3b3d35..85b4a202644 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -478,7 +478,7 @@ impl<'a> DoubleEndedIterator for CharIndices<'a> { /// Created with `StrExt::bytes` #[stable(feature = "rust1", since = "1.0.0")] #[derive(Clone)] -pub struct Bytes<'a>(Map<&'a u8, u8, slice::Iter<'a, u8>, BytesDeref>); +pub struct Bytes<'a>(Map, BytesDeref>); delegate_iter!{exact u8 : Bytes<'a>} /// A temporary fn new type that ensures that the `Bytes` iterator @@ -526,7 +526,7 @@ pub struct Lines<'a> { /// An iterator over the lines of a string, separated by either `\n` or (`\r\n`). #[stable(feature = "rust1", since = "1.0.0")] pub struct LinesAny<'a> { - inner: Map<&'a str, &'a str, Lines<'a>, fn(&str) -> &str>, + inner: Map, fn(&str) -> &str>, } impl<'a, Sep> CharSplits<'a, Sep> { diff --git a/src/librustc_trans/trans/basic_block.rs b/src/librustc_trans/trans/basic_block.rs index d3ff432b5e4..f11c3154274 100644 --- a/src/librustc_trans/trans/basic_block.rs +++ b/src/librustc_trans/trans/basic_block.rs @@ -16,12 +16,7 @@ use std::iter::{Filter, Map}; #[derive(Copy)] pub struct BasicBlock(pub BasicBlockRef); -pub type Preds = Map< - Value, - BasicBlock, - Filter bool>, - fn(Value) -> BasicBlock, ->; +pub type Preds = Map bool>, fn(Value) -> BasicBlock>; /// Wrapper for LLVM BasicBlockRef impl BasicBlock { diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 3e2c7627dbe..852d5a86fc0 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -1300,18 +1300,13 @@ pub struct IterMut<'a, K: 'a, V: 'a> { /// HashMap move iterator. #[stable(feature = "rust1", since = "1.0.0")] pub struct IntoIter { - inner: iter::Map< - (SafeHash, K, V), - (K, V), - table::IntoIter, - fn((SafeHash, K, V)) -> (K, V), - > + inner: iter::Map, fn((SafeHash, K, V)) -> (K, V)> } /// HashMap keys iterator. #[stable(feature = "rust1", since = "1.0.0")] pub struct Keys<'a, K: 'a, V: 'a> { - inner: Map<(&'a K, &'a V), &'a K, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a K> + inner: Map, fn((&'a K, &'a V)) -> &'a K> } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -1326,7 +1321,7 @@ impl<'a, K, V> Clone for Keys<'a, K, V> { /// HashMap values iterator. #[stable(feature = "rust1", since = "1.0.0")] pub struct Values<'a, K: 'a, V: 'a> { - inner: Map<(&'a K, &'a V), &'a V, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V> + inner: Map, fn((&'a K, &'a V)) -> &'a V> } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` @@ -1342,12 +1337,7 @@ impl<'a, K, V> Clone for Values<'a, K, V> { #[unstable(feature = "std_misc", reason = "matches collection reform specification, waiting for dust to settle")] pub struct Drain<'a, K: 'a, V: 'a> { - inner: iter::Map< - (SafeHash, K, V), - (K, V), - table::Drain<'a, K, V>, - fn((SafeHash, K, V)) -> (K, V), - > + inner: iter::Map, fn((SafeHash, K, V)) -> (K, V)> } /// A view into a single occupied location in a HashMap. diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index c6dcb0d230f..e6b06e5ef1f 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -794,13 +794,13 @@ pub struct Iter<'a, K: 'a> { /// HashSet move iterator #[stable(feature = "rust1", since = "1.0.0")] pub struct IntoIter { - iter: Map<(K, ()), K, map::IntoIter, fn((K, ())) -> K> + iter: Map, fn((K, ())) -> K> } /// HashSet drain iterator #[stable(feature = "rust1", since = "1.0.0")] pub struct Drain<'a, K: 'a> { - iter: Map<(K, ()), K, map::Drain<'a, K, ()>, fn((K, ())) -> K>, + iter: Map, fn((K, ())) -> K>, } /// Intersection iterator diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 6a0c8a93010..69f815e3f8b 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -31,7 +31,7 @@ pub type Components<'a> = Split<'a, u8, fn(&u8) -> bool>; /// Iterator that yields successive components of a Path as Option<&str> pub type StrComponents<'a> = - Map<&'a [u8], Option<&'a str>, Components<'a>, fn(&[u8]) -> Option<&str>>; + Map, fn(&[u8]) -> Option<&str>>; /// Represents a POSIX file path #[derive(Clone)] diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index b524b89ef9f..750af47ff8c 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -40,11 +40,11 @@ use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe}; /// Each component is yielded as Option<&str> for compatibility with PosixPath, but /// every component in WindowsPath is guaranteed to be Some. pub type StrComponents<'a> = - Map<&'a str, Option<&'a str>, SplitTerminator<'a, char>, fn(&'a str) -> Option<&'a str>>; + Map, fn(&'a str) -> Option<&'a str>>; /// Iterator that yields successive components of a Path as &[u8] pub type Components<'a> = - Map, &'a [u8], StrComponents<'a>, fn(Option<&str>) -> &[u8]>; + Map, fn(Option<&str>) -> &[u8]>; /// Represents a Windows path // Notes for Windows path impl: diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 8ac5b6e5274..3e8eab39d88 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -436,7 +436,7 @@ pub fn str_lit(lit: &str) -> String { let error = |&: i| format!("lexer should have rejected {} at {}", lit, i); /// Eat everything up to a non-whitespace - fn eat<'a>(it: &mut iter::Peekable<(usize, char), str::CharIndices<'a>>) { + fn eat<'a>(it: &mut iter::Peekable>) { loop { match it.peek().map(|x| x.1) { Some(' ') | Some('\n') | Some('\r') | Some('\t') => { @@ -605,7 +605,7 @@ pub fn binary_lit(lit: &str) -> Rc> { let error = |&: i| format!("lexer should have rejected {} at {}", lit, i); /// Eat everything up to a non-whitespace - fn eat<'a, I: Iterator>(it: &mut iter::Peekable<(usize, u8), I>) { + fn eat<'a, I: Iterator>(it: &mut iter::Peekable) { loop { match it.peek().map(|x| x.1) { Some(b' ') | Some(b'\n') | Some(b'\r') | Some(b'\t') => { diff --git a/src/libunicode/u_str.rs b/src/libunicode/u_str.rs index 9a757c0c980..0e3aacbc09a 100644 --- a/src/libunicode/u_str.rs +++ b/src/libunicode/u_str.rs @@ -32,7 +32,7 @@ use tables::grapheme::GraphemeCat; /// An iterator over the words of a string, separated by a sequence of whitespace #[stable(feature = "rust1", since = "1.0.0")] pub struct Words<'a> { - inner: Filter<&'a str, Split<'a, fn(char) -> bool>, fn(&&str) -> bool>, + inner: Filter bool>, fn(&&str) -> bool>, } /// Methods for Unicode string slices -- cgit 1.4.1-3-g733a5 From 597b4fa984d866154f5e23244a4a48c787af43fd Mon Sep 17 00:00:00 2001 From: P1start Date: Fri, 16 Jan 2015 16:04:28 +1300 Subject: Tweak some ‘expected…’ error messages MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes #21153. --- src/libsyntax/parse/attr.rs | 9 +- src/libsyntax/parse/parser.rs | 117 +++++++++++---------- src/libsyntax/parse/token.rs | 2 +- src/test/compile-fail/better-expected.rs | 2 +- src/test/compile-fail/empty-impl-semicolon.rs | 2 +- src/test/compile-fail/extern-no-fn.rs | 3 +- src/test/compile-fail/issue-20711-2.rs | 2 +- src/test/compile-fail/issue-20711.rs | 2 +- src/test/compile-fail/issue-21153.rs | 13 +++ src/test/compile-fail/multitrait.rs | 3 +- src/test/compile-fail/pat-range-bad-dots.rs | 2 +- .../removed-syntax-closure-lifetime.rs | 2 +- .../compile-fail/removed-syntax-enum-newtype.rs | 2 +- .../compile-fail/removed-syntax-extern-const.rs | 3 +- src/test/compile-fail/removed-syntax-fixed-vec.rs | 2 +- src/test/compile-fail/removed-syntax-mut-vec-ty.rs | 2 +- .../compile-fail/removed-syntax-ptr-lifetime.rs | 2 +- src/test/compile-fail/removed-syntax-static-fn.rs | 3 +- .../compile-fail/removed-syntax-uniq-mut-ty.rs | 2 +- .../struct-literal-in-match-discriminant.rs | 2 +- 20 files changed, 100 insertions(+), 77 deletions(-) create mode 100644 src/test/compile-fail/issue-21153.rs (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 54ec9c7b146..06e8728d236 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -13,7 +13,7 @@ use ast; use codemap::{spanned, Spanned, mk_sp, Span}; use parse::common::*; //resolve bug? use parse::token; -use parse::parser::Parser; +use parse::parser::{Parser, TokenType}; use ptr::P; /// A parser that can parse attributes. @@ -69,7 +69,9 @@ impl<'a> ParserAttr for Parser<'a> { let lo = self.span.lo; self.bump(); - let style = if self.eat(&token::Not) { + if permit_inner { self.expected_tokens.push(TokenType::Token(token::Not)); } + let style = if self.token == token::Not { + self.bump(); if !permit_inner { let span = self.span; self.span_err(span, @@ -96,7 +98,8 @@ impl<'a> ParserAttr for Parser<'a> { } }; - if permit_inner && self.eat(&token::Semi) { + if permit_inner && self.token == token::Semi { + self.bump(); self.span_warn(span, "this inner attribute syntax is deprecated. \ The new syntax is `#![foo]`, with a bang and no semicolon"); style = ast::AttrInner; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index d99095eeba3..66f5cdfd1e3 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -290,6 +290,7 @@ pub struct Parser<'a> { #[derive(PartialEq, Eq, Clone)] pub enum TokenType { Token(token::Token), + Keyword(keywords::Keyword), Operator, } @@ -298,6 +299,7 @@ impl TokenType { match *self { TokenType::Token(ref t) => format!("`{}`", Parser::token_to_string(t)), TokenType::Operator => "an operator".to_string(), + TokenType::Keyword(kw) => format!("`{}`", token::get_name(kw.to_name())), } } } @@ -365,9 +367,9 @@ impl<'a> Parser<'a> { token_str)[]); } - pub fn unexpected(&self) -> ! { - let this_token = self.this_token_to_string(); - self.fatal(&format!("unexpected token: `{}`", this_token)[]); + pub fn unexpected(&mut self) -> ! { + self.expect_one_of(&[], &[]); + unreachable!() } /// Expect and consume the token t. Signal an error if @@ -425,10 +427,13 @@ impl<'a> Parser<'a> { let expect = tokens_to_string(&expected[]); let actual = self.this_token_to_string(); self.fatal( - &(if expected.len() != 1 { + &(if expected.len() > 1 { (format!("expected one of {}, found `{}`", expect, actual)) + } else if expected.len() == 0 { + (format!("unexpected token: `{}`", + actual)) } else { (format!("expected {}, found `{}`", expect, @@ -515,7 +520,7 @@ impl<'a> Parser<'a> { pub fn parse_path_list_item(&mut self) -> ast::PathListItem { let lo = self.span.lo; - let node = if self.eat_keyword(keywords::Mod) { + let node = if self.eat_keyword_noexpect(keywords::Mod) { let span = self.last_span; self.span_warn(span, "deprecated syntax; use the `self` keyword now"); ast::PathListMod { id: ast::DUMMY_NODE_ID } @@ -547,9 +552,23 @@ impl<'a> Parser<'a> { is_present } + pub fn check_keyword(&mut self, kw: keywords::Keyword) -> bool { + self.expected_tokens.push(TokenType::Keyword(kw)); + self.token.is_keyword(kw) + } + /// If the next token is the given keyword, eat it and return /// true. Otherwise, return false. pub fn eat_keyword(&mut self, kw: keywords::Keyword) -> bool { + if self.check_keyword(kw) { + self.bump(); + true + } else { + false + } + } + + pub fn eat_keyword_noexpect(&mut self, kw: keywords::Keyword) -> bool { if self.token.is_keyword(kw) { self.bump(); true @@ -563,10 +582,7 @@ impl<'a> Parser<'a> { /// Otherwise, eat it. pub fn expect_keyword(&mut self, kw: keywords::Keyword) { if !self.eat_keyword(kw) { - let id_interned_str = token::get_name(kw.to_name()); - let token_str = self.this_token_to_string(); - self.fatal(&format!("expected `{}`, found `{}`", - id_interned_str, token_str)[]) + self.expect_one_of(&[], &[]); } } @@ -593,6 +609,7 @@ impl<'a> Parser<'a> { /// Expect and consume an `&`. If `&&` is seen, replace it with a single /// `&` and continue. If an `&` is not seen, signal an error. fn expect_and(&mut self) { + self.expected_tokens.push(TokenType::Token(token::BinOp(token::And))); match self.token { token::BinOp(token::And) => self.bump(), token::AndAnd => { @@ -601,12 +618,7 @@ impl<'a> Parser<'a> { self.replace_token(token::BinOp(token::And), lo, span.hi) } _ => { - let token_str = self.this_token_to_string(); - let found_token = - Parser::token_to_string(&token::BinOp(token::And)); - self.fatal(&format!("expected `{}`, found `{}`", - found_token, - token_str)[]) + self.expect_one_of(&[], &[]); } } } @@ -614,6 +626,7 @@ impl<'a> Parser<'a> { /// Expect and consume a `|`. If `||` is seen, replace it with a single /// `|` and continue. If a `|` is not seen, signal an error. fn expect_or(&mut self) { + self.expected_tokens.push(TokenType::Token(token::BinOp(token::Or))); match self.token { token::BinOp(token::Or) => self.bump(), token::OrOr => { @@ -622,12 +635,7 @@ impl<'a> Parser<'a> { self.replace_token(token::BinOp(token::Or), lo, span.hi) } _ => { - let found_token = self.this_token_to_string(); - let token_str = - Parser::token_to_string(&token::BinOp(token::Or)); - self.fatal(&format!("expected `{}`, found `{}`", - token_str, - found_token)[]) + self.expect_one_of(&[], &[]); } } } @@ -652,6 +660,7 @@ impl<'a> Parser<'a> { /// This is meant to be used when parsing generics on a path to get the /// starting token. fn eat_lt(&mut self) -> bool { + self.expected_tokens.push(TokenType::Token(token::Lt)); match self.token { token::Lt => { self.bump(); true } token::BinOp(token::Shl) => { @@ -666,11 +675,7 @@ impl<'a> Parser<'a> { fn expect_lt(&mut self) { if !self.eat_lt() { - let found_token = self.this_token_to_string(); - let token_str = Parser::token_to_string(&token::Lt); - self.fatal(&format!("expected `{}`, found `{}`", - token_str, - found_token)[]) + self.expect_one_of(&[], &[]); } } @@ -700,6 +705,7 @@ impl<'a> Parser<'a> { /// with a single > and continue. If a GT is not seen, /// signal an error. pub fn expect_gt(&mut self) { + self.expected_tokens.push(TokenType::Token(token::Gt)); match self.token { token::Gt => self.bump(), token::BinOp(token::Shr) => { @@ -998,14 +1004,14 @@ impl<'a> Parser<'a> { /// Is the current token one of the keywords that signals a bare function /// type? pub fn token_is_bare_fn_keyword(&mut self) -> bool { - self.token.is_keyword(keywords::Fn) || - self.token.is_keyword(keywords::Unsafe) || - self.token.is_keyword(keywords::Extern) + self.check_keyword(keywords::Fn) || + self.check_keyword(keywords::Unsafe) || + self.check_keyword(keywords::Extern) } /// Is the current token one of the keywords that signals a closure type? pub fn token_is_closure_keyword(&mut self) -> bool { - self.token.is_keyword(keywords::Unsafe) + self.check_keyword(keywords::Unsafe) } pub fn get_lifetime(&mut self) -> ast::Ident { @@ -1035,7 +1041,7 @@ impl<'a> Parser<'a> { let lifetime_defs = self.parse_late_bound_lifetime_defs(); // examine next token to decide to do - if self.eat_keyword(keywords::Proc) { + if self.eat_keyword_noexpect(keywords::Proc) { self.parse_proc_type(lifetime_defs) } else if self.token_is_bare_fn_keyword() || self.token_is_closure_keyword() { self.parse_ty_bare_fn_or_ty_closure(lifetime_defs) @@ -1166,11 +1172,11 @@ impl<'a> Parser<'a> { // Closure: [unsafe] <'lt> |S| [:Bounds] -> T // Fn: [unsafe] [extern "ABI"] fn <'lt> (S) -> T - if self.token.is_keyword(keywords::Fn) { + if self.check_keyword(keywords::Fn) { self.parse_ty_bare_fn(lifetime_defs) - } else if self.token.is_keyword(keywords::Extern) { + } else if self.check_keyword(keywords::Extern) { self.parse_ty_bare_fn(lifetime_defs) - } else if self.token.is_keyword(keywords::Unsafe) { + } else if self.check_keyword(keywords::Unsafe) { if self.look_ahead(1, |t| t.is_keyword(keywords::Fn) || t.is_keyword(keywords::Extern)) { self.parse_ty_bare_fn(lifetime_defs) @@ -1480,7 +1486,7 @@ impl<'a> Parser<'a> { // BORROWED POINTER self.expect_and(); self.parse_borrowed_pointee() - } else if self.token.is_keyword(keywords::For) { + } else if self.check_keyword(keywords::For) { self.parse_for_in_type() } else if self.token_is_bare_fn_keyword() || self.token_is_closure_keyword() { @@ -1494,14 +1500,14 @@ impl<'a> Parser<'a> { })) { // CLOSURE self.parse_ty_closure(Vec::new()) - } else if self.eat_keyword(keywords::Typeof) { + } else if self.eat_keyword_noexpect(keywords::Typeof) { // TYPEOF // In order to not be ambiguous, the type must be surrounded by parens. self.expect(&token::OpenDelim(token::Paren)); let e = self.parse_expr(); self.expect(&token::CloseDelim(token::Paren)); TyTypeof(e) - } else if self.eat_keyword(keywords::Proc) { + } else if self.eat_keyword_noexpect(keywords::Proc) { self.parse_proc_type(Vec::new()) } else if self.eat_lt() { // QUALIFIED PATH `::item` @@ -2092,6 +2098,7 @@ impl<'a> Parser<'a> { } fn expect_open_delim(&mut self) -> token::DelimToken { + self.expected_tokens.push(TokenType::Token(token::Gt)); match self.token { token::OpenDelim(delim) => { self.bump(); @@ -2233,7 +2240,7 @@ impl<'a> Parser<'a> { if self.eat_keyword(keywords::Move) { return self.parse_lambda_expr(CaptureByValue); } - if self.eat_keyword(keywords::Proc) { + if self.eat_keyword_noexpect(keywords::Proc) { let span = self.last_span; let _ = self.parse_proc_decl(); let _ = self.parse_expr(); @@ -2307,8 +2314,8 @@ impl<'a> Parser<'a> { hi = self.span.hi; } else if self.check(&token::ModSep) || self.token.is_ident() && - !self.token.is_keyword(keywords::True) && - !self.token.is_keyword(keywords::False) { + !self.check_keyword(keywords::True) && + !self.check_keyword(keywords::False) { let pth = self.parse_path(LifetimeAndTypesWithColons); @@ -2792,7 +2799,7 @@ impl<'a> Parser<'a> { ex = ExprAddrOf(m, e); } token::Ident(_, _) => { - if !self.token.is_keyword(keywords::Box) { + if !self.check_keyword(keywords::Box) { return self.parse_dot_or_call_expr(); } @@ -2879,7 +2886,7 @@ impl<'a> Parser<'a> { } } None => { - if AS_PREC >= min_prec && self.eat_keyword(keywords::As) { + if AS_PREC >= min_prec && self.eat_keyword_noexpect(keywords::As) { let rhs = self.parse_ty(); let _as = self.mk_expr(lhs.span.lo, rhs.span.hi, @@ -3002,7 +3009,7 @@ impl<'a> Parser<'a> { /// Parse an 'if' or 'if let' expression ('if' token already eaten) pub fn parse_if_expr(&mut self) -> P { - if self.token.is_keyword(keywords::Let) { + if self.check_keyword(keywords::Let) { return self.parse_if_let_expr(); } let lo = self.last_span.lo; @@ -3655,7 +3662,7 @@ impl<'a> Parser<'a> { } let lo = self.span.lo; - if self.token.is_keyword(keywords::Let) { + if self.check_keyword(keywords::Let) { check_expected_item(self, &item_attrs[]); self.expect_keyword(keywords::Let); let decl = self.parse_let(); @@ -5302,7 +5309,7 @@ impl<'a> Parser<'a> { let (maybe_path, ident) = match self.token { token::Ident(..) => { let the_ident = self.parse_ident(); - let path = if self.eat_keyword(keywords::As) { + let path = if self.eat_keyword_noexpect(keywords::As) { // skip the ident if there is one if self.token.is_ident() { self.bump(); } @@ -5595,14 +5602,13 @@ impl<'a> Parser<'a> { token_str)[]); } - if self.eat_keyword(keywords::Virtual) { + if self.eat_keyword_noexpect(keywords::Virtual) { let span = self.span; self.span_err(span, "`virtual` structs have been removed from the language"); } - if self.token.is_keyword(keywords::Static) { + if self.eat_keyword(keywords::Static) { // STATIC ITEM - self.bump(); let m = if self.eat_keyword(keywords::Mut) {MutMutable} else {MutImmutable}; let (ident, item_, extra_attrs) = self.parse_item_const(Some(m)); let last_span = self.last_span; @@ -5614,9 +5620,8 @@ impl<'a> Parser<'a> { maybe_append(attrs, extra_attrs)); return Ok(item); } - if self.token.is_keyword(keywords::Const) { + if self.eat_keyword(keywords::Const) { // CONST ITEM - self.bump(); if self.eat_keyword(keywords::Mut) { let last_span = self.last_span; self.span_err(last_span, "const globals cannot be mutable"); @@ -5632,7 +5637,7 @@ impl<'a> Parser<'a> { maybe_append(attrs, extra_attrs)); return Ok(item); } - if self.token.is_keyword(keywords::Unsafe) && + if self.check_keyword(keywords::Unsafe) && self.look_ahead(1us, |t| t.is_keyword(keywords::Trait)) { // UNSAFE TRAIT ITEM @@ -5649,7 +5654,7 @@ impl<'a> Parser<'a> { maybe_append(attrs, extra_attrs)); return Ok(item); } - if self.token.is_keyword(keywords::Unsafe) && + if self.check_keyword(keywords::Unsafe) && self.look_ahead(1us, |t| t.is_keyword(keywords::Impl)) { // IMPL ITEM @@ -5665,7 +5670,7 @@ impl<'a> Parser<'a> { maybe_append(attrs, extra_attrs)); return Ok(item); } - if self.token.is_keyword(keywords::Fn) { + if self.check_keyword(keywords::Fn) { // FUNCTION ITEM self.bump(); let (ident, item_, extra_attrs) = @@ -5679,7 +5684,7 @@ impl<'a> Parser<'a> { maybe_append(attrs, extra_attrs)); return Ok(item); } - if self.token.is_keyword(keywords::Unsafe) + if self.check_keyword(keywords::Unsafe) && self.look_ahead(1us, |t| *t != token::OpenDelim(token::Brace)) { // UNSAFE FUNCTION ITEM self.bump(); @@ -5784,11 +5789,11 @@ impl<'a> Parser<'a> { let visibility = self.parse_visibility(); - if self.token.is_keyword(keywords::Static) { + if self.check_keyword(keywords::Static) { // FOREIGN STATIC ITEM return Ok(self.parse_item_foreign_static(visibility, attrs)); } - if self.token.is_keyword(keywords::Fn) || self.token.is_keyword(keywords::Unsafe) { + if self.check_keyword(keywords::Fn) || self.check_keyword(keywords::Unsafe) { // FOREIGN FUNCTION ITEM return Ok(self.parse_item_foreign_fn(visibility, attrs)); } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 5531ce7b119..5c3892e49c0 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -456,7 +456,7 @@ macro_rules! declare_special_idents_and_keywords {( pub use self::Keyword::*; use ast; - #[derive(Copy)] + #[derive(Copy, Clone, PartialEq, Eq)] pub enum Keyword { $( $sk_variant, )* $( $rk_variant, )* diff --git a/src/test/compile-fail/better-expected.rs b/src/test/compile-fail/better-expected.rs index 0d84a5e7d02..e07f4b8e549 100644 --- a/src/test/compile-fail/better-expected.rs +++ b/src/test/compile-fail/better-expected.rs @@ -9,5 +9,5 @@ // except according to those terms. fn main() { - let x: [isize 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `3` + let x: [isize 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `3` } diff --git a/src/test/compile-fail/empty-impl-semicolon.rs b/src/test/compile-fail/empty-impl-semicolon.rs index a598252f1b6..70c7d42feb5 100644 --- a/src/test/compile-fail/empty-impl-semicolon.rs +++ b/src/test/compile-fail/empty-impl-semicolon.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -impl Foo; //~ ERROR expected one of `(`, `+`, `::`, or `{`, found `;` +impl Foo; //~ ERROR expected one of `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `;` diff --git a/src/test/compile-fail/extern-no-fn.rs b/src/test/compile-fail/extern-no-fn.rs index 164cbe54174..69e2f3ae60b 100644 --- a/src/test/compile-fail/extern-no-fn.rs +++ b/src/test/compile-fail/extern-no-fn.rs @@ -8,9 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// error-pattern:unexpected token extern { - f(); + f(); //~ ERROR expected one of `fn`, `pub`, `static`, `unsafe`, or `}`, found `f` } fn main() { diff --git a/src/test/compile-fail/issue-20711-2.rs b/src/test/compile-fail/issue-20711-2.rs index 9f0e81a662f..a6c4570c60f 100644 --- a/src/test/compile-fail/issue-20711-2.rs +++ b/src/test/compile-fail/issue-20711-2.rs @@ -14,7 +14,7 @@ impl Foo { fn foo() {} #[stable(feature = "rust1", since = "1.0.0")] -} //~ ERROR expected `fn`, found `}` +} //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}` fn main() {} diff --git a/src/test/compile-fail/issue-20711.rs b/src/test/compile-fail/issue-20711.rs index 5f0f0fc05a9..3b329d78237 100644 --- a/src/test/compile-fail/issue-20711.rs +++ b/src/test/compile-fail/issue-20711.rs @@ -12,6 +12,6 @@ struct Foo; impl Foo { #[stable(feature = "rust1", since = "1.0.0")] -} //~ ERROR expected `fn`, found `}` +} //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `}` fn main() {} diff --git a/src/test/compile-fail/issue-21153.rs b/src/test/compile-fail/issue-21153.rs new file mode 100644 index 00000000000..e2b6deb0ad9 --- /dev/null +++ b/src/test/compile-fail/issue-21153.rs @@ -0,0 +1,13 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +trait MyTrait: Iterator { + Item = T; //~ ERROR expected one of `extern`, `fn`, `pub`, `type`, or `unsafe`, found `Item` +} diff --git a/src/test/compile-fail/multitrait.rs b/src/test/compile-fail/multitrait.rs index a0e210aed40..f182eb8fa5b 100644 --- a/src/test/compile-fail/multitrait.rs +++ b/src/test/compile-fail/multitrait.rs @@ -12,7 +12,8 @@ struct S { y: isize } -impl Cmp, ToString for S { //~ ERROR: expected one of `(`, `+`, `::`, or `{`, found `,` +impl Cmp, ToString for S { +//~^ ERROR: expected one of `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `,` fn eq(&&other: S) { false } fn to_string(&self) -> String { "hi".to_string() } } diff --git a/src/test/compile-fail/pat-range-bad-dots.rs b/src/test/compile-fail/pat-range-bad-dots.rs index b48d3e8871b..c52fb8c9b67 100644 --- a/src/test/compile-fail/pat-range-bad-dots.rs +++ b/src/test/compile-fail/pat-range-bad-dots.rs @@ -10,7 +10,7 @@ pub fn main() { match 22 { - 0 .. 3 => {} //~ ERROR expected one of `...`, `=>`, or `|`, found `..` + 0 .. 3 => {} //~ ERROR expected one of `...`, `=>`, `if`, or `|`, found `..` _ => {} } } diff --git a/src/test/compile-fail/removed-syntax-closure-lifetime.rs b/src/test/compile-fail/removed-syntax-closure-lifetime.rs index a07832d5bb7..0cea87dba19 100644 --- a/src/test/compile-fail/removed-syntax-closure-lifetime.rs +++ b/src/test/compile-fail/removed-syntax-closure-lifetime.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -type closure = Box; //~ ERROR expected one of `(`, `+`, `,`, `::`, or `>`, found `/` +type closure = Box; //~ ERROR expected one of `(`, `+`, `,`, `::`, `<`, or `>`, found `/` diff --git a/src/test/compile-fail/removed-syntax-enum-newtype.rs b/src/test/compile-fail/removed-syntax-enum-newtype.rs index 3b45fd81288..b067cee03d2 100644 --- a/src/test/compile-fail/removed-syntax-enum-newtype.rs +++ b/src/test/compile-fail/removed-syntax-enum-newtype.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -enum e = isize; //~ ERROR expected one of `<` or `{`, found `=` +enum e = isize; //~ ERROR expected one of `<`, `where`, or `{`, found `=` diff --git a/src/test/compile-fail/removed-syntax-extern-const.rs b/src/test/compile-fail/removed-syntax-extern-const.rs index 98eec0977e0..a0e1d04a3dc 100644 --- a/src/test/compile-fail/removed-syntax-extern-const.rs +++ b/src/test/compile-fail/removed-syntax-extern-const.rs @@ -9,5 +9,6 @@ // except according to those terms. extern { - const i: isize; //~ ERROR unexpected token: `const` + const i: isize; + //~^ ERROR expected one of `fn`, `pub`, `static`, `unsafe`, or `}`, found `const` } diff --git a/src/test/compile-fail/removed-syntax-fixed-vec.rs b/src/test/compile-fail/removed-syntax-fixed-vec.rs index 0ca2380ef68..0e8e20b3891 100644 --- a/src/test/compile-fail/removed-syntax-fixed-vec.rs +++ b/src/test/compile-fail/removed-syntax-fixed-vec.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -type v = [isize * 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `*` +type v = [isize * 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `*` diff --git a/src/test/compile-fail/removed-syntax-mut-vec-ty.rs b/src/test/compile-fail/removed-syntax-mut-vec-ty.rs index 0f67a1d04ee..9a7570a92f0 100644 --- a/src/test/compile-fail/removed-syntax-mut-vec-ty.rs +++ b/src/test/compile-fail/removed-syntax-mut-vec-ty.rs @@ -10,4 +10,4 @@ type v = [mut isize]; //~^ ERROR expected identifier, found keyword `mut` - //~^^ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `isize` + //~^^ ERROR expected one of `(`, `+`, `::`, `;`, `<`, or `]`, found `isize` diff --git a/src/test/compile-fail/removed-syntax-ptr-lifetime.rs b/src/test/compile-fail/removed-syntax-ptr-lifetime.rs index d94f2ec1e07..44c65d98c0b 100644 --- a/src/test/compile-fail/removed-syntax-ptr-lifetime.rs +++ b/src/test/compile-fail/removed-syntax-ptr-lifetime.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -type bptr = &lifetime/isize; //~ ERROR expected one of `(`, `+`, `::`, or `;`, found `/` +type bptr = &lifetime/isize; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `<`, found `/` diff --git a/src/test/compile-fail/removed-syntax-static-fn.rs b/src/test/compile-fail/removed-syntax-static-fn.rs index e3e1cb0f3ca..caf939e7b8a 100644 --- a/src/test/compile-fail/removed-syntax-static-fn.rs +++ b/src/test/compile-fail/removed-syntax-static-fn.rs @@ -11,5 +11,6 @@ struct S; impl S { - static fn f() {} //~ ERROR expected `fn`, found `static` + static fn f() {} + //~^ ERROR expected one of `extern`, `fn`, `pub`, `type`, `unsafe`, or `}`, found `static` } diff --git a/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs b/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs index c051059aee6..d1c2fc69f52 100644 --- a/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs +++ b/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs @@ -10,4 +10,4 @@ type mut_box = Box; //~^ ERROR expected identifier, found keyword `mut` - //~^^ ERROR expected one of `(`, `+`, `,`, `::`, or `>`, found `isize` + //~^^ ERROR expected one of `(`, `+`, `,`, `::`, `<`, or `>`, found `isize` diff --git a/src/test/compile-fail/struct-literal-in-match-discriminant.rs b/src/test/compile-fail/struct-literal-in-match-discriminant.rs index 8f50940806a..e6948b7c7c9 100644 --- a/src/test/compile-fail/struct-literal-in-match-discriminant.rs +++ b/src/test/compile-fail/struct-literal-in-match-discriminant.rs @@ -14,7 +14,7 @@ struct Foo { fn main() { match Foo { - x: 3 //~ ERROR expected one of `!`, `=>`, `@`, or `|`, found `:` + x: 3 //~ ERROR expected one of `!`, `=>`, `@`, `if`, or `|`, found `:` } { Foo { x: x -- cgit 1.4.1-3-g733a5 From 9683745fed09daf7f8acc55d679b41d3bc660ec4 Mon Sep 17 00:00:00 2001 From: Alfie John Date: Wed, 28 Jan 2015 01:01:48 +0000 Subject: Omit integer suffix when unnecessary See PR # 21378 for context --- src/libsyntax/ast_util.rs | 20 +++++----- src/libsyntax/codemap.rs | 18 ++++----- src/libsyntax/diagnostic.rs | 32 ++++++++-------- src/libsyntax/ext/deriving/generic/mod.rs | 16 ++++---- src/libsyntax/ext/expand.rs | 4 +- src/libsyntax/ext/quote.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 34 ++++++++--------- src/libsyntax/ext/tt/transcribe.rs | 2 +- src/libsyntax/parse/lexer/comments.rs | 6 +-- src/libsyntax/parse/lexer/mod.rs | 26 ++++++------- src/libsyntax/parse/mod.rs | 10 ++--- src/libsyntax/parse/parser.rs | 16 ++++---- src/libsyntax/print/pp.rs | 32 ++++++++-------- src/libsyntax/print/pprust.rs | 62 +++++++++++++++---------------- src/libsyntax/test.rs | 4 +- 15 files changed, 142 insertions(+), 142 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 7f1264ac9a1..252dbfd964a 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -322,21 +322,21 @@ pub fn struct_field_visibility(field: ast::StructField) -> Visibility { pub fn operator_prec(op: ast::BinOp_) -> usize { match op { // 'as' sits here with 12 - BiMul | BiDiv | BiRem => 11us, - BiAdd | BiSub => 10us, - BiShl | BiShr => 9us, - BiBitAnd => 8us, - BiBitXor => 7us, - BiBitOr => 6us, - BiLt | BiLe | BiGe | BiGt | BiEq | BiNe => 3us, - BiAnd => 2us, - BiOr => 1us + BiMul | BiDiv | BiRem => 11, + BiAdd | BiSub => 10, + BiShl | BiShr => 9, + BiBitAnd => 8, + BiBitXor => 7, + BiBitOr => 6, + BiLt | BiLe | BiGe | BiGt | BiEq | BiNe => 3, + BiAnd => 2, + BiOr => 1 } } /// Precedence of the `as` operator, which is a binary operator /// not appearing in the prior table. -pub const AS_PREC: usize = 12us; +pub const AS_PREC: usize = 12; pub fn empty_generics() -> Generics { Generics { diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 8adb9b24222..13b6a7a037a 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -431,7 +431,7 @@ impl CodeMap { let lo = self.lookup_char_pos(sp.lo); let hi = self.lookup_char_pos(sp.hi); let mut lines = Vec::new(); - for i in lo.line - 1us..hi.line as usize { + for i in lo.line - 1..hi.line as usize { lines.push(i); }; FileLines {file: lo.file, lines: lines} @@ -499,10 +499,10 @@ impl CodeMap { let files = self.files.borrow(); let files = &*files; let len = files.len(); - let mut a = 0us; + let mut a = 0; let mut b = len; - while b - a > 1us { - let m = (a + b) / 2us; + while b - a > 1 { + let m = (a + b) / 2; if files[m].start_pos > pos { b = m; } else { @@ -538,12 +538,12 @@ impl CodeMap { let files = self.files.borrow(); let f = (*files)[idx].clone(); - let mut a = 0us; + let mut a = 0; { let lines = f.lines.borrow(); let mut b = lines.len(); - while b - a > 1us { - let m = (a + b) / 2us; + while b - a > 1 { + let m = (a + b) / 2; if (*lines)[m] > pos { b = m; } else { a = m; } } } @@ -552,7 +552,7 @@ impl CodeMap { fn lookup_pos(&self, pos: BytePos) -> Loc { let FileMapAndLine {fm: f, line: a} = self.lookup_line(pos); - let line = a + 1us; // Line numbers start at 1 + let line = a + 1; // Line numbers start at 1 let chpos = self.bytepos_to_file_charpos(pos); let linebpos = (*f.lines.borrow())[a]; let linechpos = self.bytepos_to_file_charpos(linebpos); @@ -763,7 +763,7 @@ mod test { assert_eq!(file_lines.file.name, "blork.rs"); assert_eq!(file_lines.lines.len(), 1); - assert_eq!(file_lines.lines[0], 1us); + assert_eq!(file_lines.lines[0], 1); } #[test] diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 821ac8e2f89..f920ca9e233 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -25,7 +25,7 @@ use term::WriterWrapper; use term; /// maximum number of lines we will print for each error; arbitrary. -static MAX_LINES: usize = 6us; +static MAX_LINES: usize = 6; #[derive(Clone, Copy)] pub enum RenderSpan { @@ -155,19 +155,19 @@ impl Handler { self.bump_err_count(); } pub fn bump_err_count(&self) { - self.err_count.set(self.err_count.get() + 1us); + self.err_count.set(self.err_count.get() + 1); } pub fn err_count(&self) -> usize { self.err_count.get() } pub fn has_errors(&self) -> bool { - self.err_count.get() > 0us + self.err_count.get() > 0 } pub fn abort_if_errors(&self) { let s; match self.err_count.get() { - 0us => return, - 1us => s = "aborting due to previous error".to_string(), + 0 => return, + 1 => s = "aborting due to previous error".to_string(), _ => { s = format!("aborting due to {} previous errors", self.err_count.get()); @@ -457,7 +457,7 @@ fn highlight_lines(err: &mut EmitterWriter, let mut elided = false; let mut display_lines = &lines.lines[]; if display_lines.len() > MAX_LINES { - display_lines = &display_lines[0us..MAX_LINES]; + display_lines = &display_lines[0..MAX_LINES]; elided = true; } // Print the offending lines @@ -468,32 +468,32 @@ fn highlight_lines(err: &mut EmitterWriter, } } if elided { - let last_line = display_lines[display_lines.len() - 1us]; - let s = format!("{}:{} ", fm.name, last_line + 1us); + let last_line = display_lines[display_lines.len() - 1]; + let s = format!("{}:{} ", fm.name, last_line + 1); try!(write!(&mut err.dst, "{0:1$}...\n", "", s.len())); } // FIXME (#3260) // If there's one line at fault we can easily point to the problem - if lines.lines.len() == 1us { + if lines.lines.len() == 1 { let lo = cm.lookup_char_pos(sp.lo); - let mut digits = 0us; - let mut num = (lines.lines[0] + 1us) / 10us; + let mut digits = 0; + let mut num = (lines.lines[0] + 1) / 10; // how many digits must be indent past? - while num > 0us { num /= 10us; digits += 1us; } + while num > 0 { num /= 10; digits += 1; } // indent past |name:## | and the 0-offset column location - let left = fm.name.len() + digits + lo.col.to_usize() + 3us; + let left = fm.name.len() + digits + lo.col.to_usize() + 3; let mut s = String::new(); // Skip is the number of characters we need to skip because they are // part of the 'filename:line ' part of the previous line. - let skip = fm.name.len() + digits + 3us; + let skip = fm.name.len() + digits + 3; for _ in 0..skip { s.push(' '); } if let Some(orig) = fm.get_line(lines.lines[0]) { - for pos in 0us..left - skip { + for pos in 0..left - skip { let cur_char = orig.as_bytes()[pos] as char; // Whenever a tab occurs on the previous line, we insert one on // the error-point-squiggly-line as well (instead of a space). @@ -511,7 +511,7 @@ fn highlight_lines(err: &mut EmitterWriter, let hi = cm.lookup_char_pos(sp.hi); if hi.col != lo.col { // the ^ already takes up one space - let num_squigglies = hi.col.to_usize() - lo.col.to_usize() - 1us; + let num_squigglies = hi.col.to_usize() - lo.col.to_usize() - 1; for _ in 0..num_squigglies { s.push('~'); } diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 1b84d93738d..dc88ce6d190 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -770,7 +770,7 @@ impl<'a> MethodDef<'a> { let mut raw_fields = Vec::new(); // ~[[fields of self], // [fields of next Self arg], [etc]] let mut patterns = Vec::new(); - for i in 0us..self_args.len() { + for i in 0..self_args.len() { let struct_path= cx.path(DUMMY_SP, vec!( type_ident )); let (pat, ident_expr) = trait_.create_struct_pattern(cx, @@ -859,8 +859,8 @@ impl<'a> MethodDef<'a> { /// (&A2(ref __self_0), /// &A2(ref __arg_1_0)) => (*__self_0).eq(&(*__arg_1_0)), /// _ => { - /// let __self_vi = match *self { A1(..) => 0us, A2(..) => 1us }; - /// let __arg_1_vi = match *__arg_1 { A1(..) => 0us, A2(..) => 1us }; + /// let __self_vi = match *self { A1(..) => 0, A2(..) => 1 }; + /// let __arg_1_vi = match *__arg_1 { A1(..) => 0, A2(..) => 1 }; /// false /// } /// } @@ -904,8 +904,8 @@ impl<'a> MethodDef<'a> { /// (Variant2, Variant2, Variant2) => ... // delegate Matching on Variant2 /// ... /// _ => { - /// let __this_vi = match this { Variant1 => 0us, Variant2 => 1us, ... }; - /// let __that_vi = match that { Variant1 => 0us, Variant2 => 1us, ... }; + /// let __this_vi = match this { Variant1 => 0, Variant2 => 1, ... }; + /// let __that_vi = match that { Variant1 => 0, Variant2 => 1, ... }; /// ... // catch-all remainder can inspect above variant index values. /// } /// } @@ -1067,13 +1067,13 @@ impl<'a> MethodDef<'a> { // // ``` // let __self0_vi = match self { - // A => 0us, B(..) => 1us, C(..) => 2us + // A => 0, B(..) => 1, C(..) => 2 // }; // let __self1_vi = match __arg1 { - // A => 0us, B(..) => 1us, C(..) => 2us + // A => 0, B(..) => 1, C(..) => 2 // }; // let __self2_vi = match __arg2 { - // A => 0us, B(..) => 1us, C(..) => 2us + // A => 0, B(..) => 1, C(..) => 2 // }; // ``` let mut index_let_stmts: Vec> = Vec::new(); diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 5736400313e..68723d32739 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -362,7 +362,7 @@ fn expand_mac_invoc(mac: ast::Mac, span: codemap::Span, // in this file. // Token-tree macros: MacInvocTT(pth, tts, _) => { - if pth.segments.len() > 1us { + if pth.segments.len() > 1 { fld.cx.span_err(pth.span, "expected macro name without module \ separators"); @@ -931,7 +931,7 @@ fn expand_pat(p: P, fld: &mut MacroExpander) -> P { }, _ => unreachable!() }; - if pth.segments.len() > 1us { + if pth.segments.len() > 1 { fld.cx.span_err(pth.span, "expected macro name without module separators"); return DummyResult::raw_pat(span); } diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 0f617302c92..1d22f79bfb2 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -709,7 +709,7 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree]) // try removing it when enough of them are gone. let mut p = cx.new_parser_from_tts(tts); - p.quote_depth += 1us; + p.quote_depth += 1; let cx_expr = p.parse_expr(); if !p.eat(&token::Comma) { diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index e3211c7c337..69c7d10a82c 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -171,11 +171,11 @@ pub fn initial_matcher_pos(ms: Rc>, sep: Option, lo: ByteP stack: vec![], top_elts: TtSeq(ms), sep: sep, - idx: 0us, + idx: 0, up: None, matches: matches, - match_lo: 0us, - match_cur: 0us, + match_lo: 0, + match_cur: 0, match_hi: match_idx_hi, sp_lo: lo } @@ -238,7 +238,7 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc]) } } let mut ret_val = HashMap::new(); - let mut idx = 0us; + let mut idx = 0; for m in ms.iter() { n_rec(p_s, m, res, &mut ret_val, &mut idx) } ret_val } @@ -383,7 +383,7 @@ pub fn parse(sess: &ParseSess, if seq.op == ast::ZeroOrMore { let mut new_ei = ei.clone(); new_ei.match_cur += seq.num_captures; - new_ei.idx += 1us; + new_ei.idx += 1; //we specifically matched zero repeats. for idx in ei.match_cur..ei.match_cur + seq.num_captures { (&mut new_ei.matches[idx]).push(Rc::new(MatchedSeq(vec![], sp))); @@ -398,7 +398,7 @@ pub fn parse(sess: &ParseSess, cur_eis.push(box MatcherPos { stack: vec![], sep: seq.separator.clone(), - idx: 0us, + idx: 0, matches: matches, match_lo: ei_t.match_cur, match_cur: ei_t.match_cur, @@ -442,20 +442,20 @@ pub fn parse(sess: &ParseSess, /* error messages here could be improved with links to orig. rules */ if token_name_eq(&tok, &token::Eof) { - if eof_eis.len() == 1us { + if eof_eis.len() == 1 { let mut v = Vec::new(); for dv in (&mut eof_eis[0]).matches.iter_mut() { v.push(dv.pop().unwrap()); } return Success(nameize(sess, ms, &v[])); - } else if eof_eis.len() > 1us { + } else if eof_eis.len() > 1 { return Error(sp, "ambiguity: multiple successful parses".to_string()); } else { return Failure(sp, "unexpected end of macro invocation".to_string()); } } else { - if (bb_eis.len() > 0us && next_eis.len() > 0us) - || bb_eis.len() > 1us { + if (bb_eis.len() > 0 && next_eis.len() > 0) + || bb_eis.len() > 1 { let nts = bb_eis.iter().map(|ei| { match ei.top_elts.get_tt(ei.idx) { TtToken(_, MatchNt(bind, name, _, _)) => { @@ -469,12 +469,12 @@ pub fn parse(sess: &ParseSess, "local ambiguity: multiple parsing options: \ built-in NTs {} or {} other options.", nts, next_eis.len()).to_string()); - } else if bb_eis.len() == 0us && next_eis.len() == 0us { + } else if bb_eis.len() == 0 && next_eis.len() == 0 { return Failure(sp, format!("no rules expected the token `{}`", pprust::token_to_string(&tok)).to_string()); - } else if next_eis.len() > 0us { + } else if next_eis.len() > 0 { /* Now process the next token */ - while next_eis.len() > 0us { + while next_eis.len() > 0 { cur_eis.push(next_eis.pop().unwrap()); } rdr.next_token(); @@ -488,7 +488,7 @@ pub fn parse(sess: &ParseSess, let match_cur = ei.match_cur; (&mut ei.matches[match_cur]).push(Rc::new(MatchedNonterminal( parse_nt(&mut rust_parser, span, name_string.get())))); - ei.idx += 1us; + ei.idx += 1; ei.match_cur += 1; } _ => panic!() @@ -501,16 +501,16 @@ pub fn parse(sess: &ParseSess, } } - assert!(cur_eis.len() > 0us); + assert!(cur_eis.len() > 0); } } pub fn parse_nt(p: &mut Parser, sp: Span, name: &str) -> Nonterminal { match name { "tt" => { - p.quote_depth += 1us; //but in theory, non-quoted tts might be useful + p.quote_depth += 1; //but in theory, non-quoted tts might be useful let res = token::NtTT(P(p.parse_token_tree())); - p.quote_depth -= 1us; + p.quote_depth -= 1; return res; } _ => {} diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 0bf20b8f3e1..83234e3b7a5 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -223,7 +223,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { r.repeat_len.pop(); } } else { /* repeat */ - *r.repeat_idx.last_mut().unwrap() += 1us; + *r.repeat_idx.last_mut().unwrap() += 1; r.stack.last_mut().unwrap().idx = 0; match r.stack.last().unwrap().sep.clone() { Some(tk) => { diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index 926385ccd11..a026b8feee1 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -62,7 +62,7 @@ pub fn doc_comment_style(comment: &str) -> ast::AttrStyle { pub fn strip_doc_comment_decoration(comment: &str) -> String { /// remove whitespace-only lines from the start/end of lines fn vertical_trim(lines: Vec ) -> Vec { - let mut i = 0us; + let mut i = 0; let mut j = lines.len(); // first line of all-stars should be omitted if lines.len() > 0 && @@ -158,7 +158,7 @@ fn push_blank_line_comment(rdr: &StringReader, comments: &mut Vec) { fn consume_whitespace_counting_blank_lines(rdr: &mut StringReader, comments: &mut Vec) { while is_whitespace(rdr.curr) && !rdr.is_eof() { - if rdr.col == CharPos(0us) && rdr.curr_is('\n') { + if rdr.col == CharPos(0) && rdr.curr_is('\n') { push_blank_line_comment(rdr, &mut *comments); } rdr.bump(); @@ -305,7 +305,7 @@ fn read_block_comment(rdr: &mut StringReader, let mut style = if code_to_the_left { Trailing } else { Isolated }; rdr.consume_non_eol_whitespace(); - if !rdr.is_eof() && !rdr.curr_is('\n') && lines.len() == 1us { + if !rdr.is_eof() && !rdr.curr_is('\n') && lines.len() == 1 { style = Mixed; } debug!("<<< block comment"); diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 2cf6058a433..65051ff8360 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -279,7 +279,7 @@ impl<'a> StringReader<'a> { /// Converts CRLF to LF in the given string, raising an error on bare CR. fn translate_crlf<'b>(&self, start: BytePos, s: &'b str, errmsg: &'b str) -> CowString<'b> { - let mut i = 0us; + let mut i = 0; while i < s.len() { let str::CharRange { ch, next } = s.char_range_at(i); if ch == '\r' { @@ -331,10 +331,10 @@ impl<'a> StringReader<'a> { let byte_offset_diff = next.next - current_byte_offset; self.pos = self.pos + Pos::from_usize(byte_offset_diff); self.curr = Some(next.ch); - self.col = self.col + CharPos(1us); + self.col = self.col + CharPos(1); if last_char == '\n' { self.filemap.next_line(self.last_pos); - self.col = CharPos(0us); + self.col = CharPos(0); } if byte_offset_diff > 1 { @@ -472,7 +472,7 @@ impl<'a> StringReader<'a> { cmap.files.borrow_mut().push(self.filemap.clone()); let loc = cmap.lookup_char_pos_adj(self.last_pos); debug!("Skipping a shebang"); - if loc.line == 1us && loc.col == CharPos(0us) { + if loc.line == 1 && loc.col == CharPos(0) { // FIXME: Add shebang "token", return it let start = self.last_pos; while !self.curr_is('\n') && !self.is_eof() { self.bump(); } @@ -646,7 +646,7 @@ impl<'a> StringReader<'a> { /// Scan through any digits (base `radix`) or underscores, and return how /// many digits there were. fn scan_digits(&mut self, radix: usize) -> usize { - let mut len = 0us; + let mut len = 0; loop { let c = self.curr; if c == Some('_') { debug!("skipping a _"); self.bump(); continue; } @@ -799,14 +799,14 @@ impl<'a> StringReader<'a> { if self.curr == Some('{') { self.scan_unicode_escape(delim) } else { - let res = self.scan_hex_digits(4us, delim, false); + let res = self.scan_hex_digits(4, delim, false); let sp = codemap::mk_sp(escaped_pos, self.last_pos); self.old_escape_warning(sp); res } } 'U' if !ascii_only => { - let res = self.scan_hex_digits(8us, delim, false); + let res = self.scan_hex_digits(8, delim, false); let sp = codemap::mk_sp(escaped_pos, self.last_pos); self.old_escape_warning(sp); res @@ -877,7 +877,7 @@ impl<'a> StringReader<'a> { fn scan_unicode_escape(&mut self, delim: char) -> bool { self.bump(); // past the { let start_bpos = self.last_pos; - let mut count = 0us; + let mut count = 0; let mut accum_int = 0; while !self.curr_is('}') && count <= 6 { @@ -937,10 +937,10 @@ impl<'a> StringReader<'a> { /// error if it isn't. fn check_float_base(&mut self, start_bpos: BytePos, last_bpos: BytePos, base: usize) { match base { - 16us => self.err_span_(start_bpos, last_bpos, "hexadecimal float literal is not \ + 16 => self.err_span_(start_bpos, last_bpos, "hexadecimal float literal is not \ supported"), - 8us => self.err_span_(start_bpos, last_bpos, "octal float literal is not supported"), - 2us => self.err_span_(start_bpos, last_bpos, "binary float literal is not supported"), + 8 => self.err_span_(start_bpos, last_bpos, "octal float literal is not supported"), + 2 => self.err_span_(start_bpos, last_bpos, "binary float literal is not supported"), _ => () } } @@ -1189,7 +1189,7 @@ impl<'a> StringReader<'a> { 'r' => { let start_bpos = self.last_pos; self.bump(); - let mut hash_count = 0us; + let mut hash_count = 0; while self.curr_is('#') { self.bump(); hash_count += 1; @@ -1374,7 +1374,7 @@ impl<'a> StringReader<'a> { fn scan_raw_byte_string(&mut self) -> token::Lit { let start_bpos = self.last_pos; self.bump(); - let mut hash_count = 0us; + let mut hash_count = 0; while self.curr_is('#') { self.bump(); hash_count += 1; diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 8ac5b6e5274..af594ce7ca2 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -181,7 +181,7 @@ pub fn parse_tts_from_source_str(name: String, name, source ); - p.quote_depth += 1us; + p.quote_depth += 1; // right now this is re-creating the token trees from ... token trees. maybe_aborted(p.parse_all_token_trees(),p) } @@ -324,7 +324,7 @@ pub mod with_hygiene { name, source ); - p.quote_depth += 1us; + p.quote_depth += 1; // right now this is re-creating the token trees from ... token trees. maybe_aborted(p.parse_all_token_trees(),p) } @@ -683,9 +683,9 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> match suffix { Some(suf) if looks_like_width_suffix(&['f'], suf) => { match base { - 16us => sd.span_err(sp, "hexadecimal float literal is not supported"), - 8us => sd.span_err(sp, "octal float literal is not supported"), - 2us => sd.span_err(sp, "binary float literal is not supported"), + 16 => sd.span_err(sp, "hexadecimal float literal is not supported"), + 8 => sd.span_err(sp, "octal float literal is not supported"), + 2 => sd.span_err(sp, "binary float literal is not supported"), _ => () } let ident = token::intern_and_get_ident(&*s); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index d99095eeba3..de12e370381 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -740,7 +740,7 @@ impl<'a> Parser<'a> { // would encounter a `>` and stop. This lets the parser handle trailing // commas in generic parameters, because it can stop either after // parsing a type or after parsing a comma. - for i in iter::count(0us, 1) { + for i in iter::count(0, 1) { if self.check(&token::Gt) || self.token == token::BinOp(token::Shr) || self.token == token::Ge @@ -917,7 +917,7 @@ impl<'a> Parser<'a> { }; self.span = next.sp; self.token = next.tok; - self.tokens_consumed += 1us; + self.tokens_consumed += 1; self.expected_tokens.clear(); // check after each token self.check_unknown_macro_variable(); @@ -2625,7 +2625,7 @@ impl<'a> Parser<'a> { } pub fn check_unknown_macro_variable(&mut self) { - if self.quote_depth == 0us { + if self.quote_depth == 0 { match self.token { token::SubstNt(name, _) => self.fatal(&format!("unknown macro variable `{}`", @@ -2694,7 +2694,7 @@ impl<'a> Parser<'a> { token_str)[]) }, /* we ought to allow different depths of unquotation */ - token::Dollar | token::SubstNt(..) if p.quote_depth > 0us => { + token::Dollar | token::SubstNt(..) if p.quote_depth > 0 => { p.parse_unquoted() } _ => { @@ -5633,7 +5633,7 @@ impl<'a> Parser<'a> { return Ok(item); } if self.token.is_keyword(keywords::Unsafe) && - self.look_ahead(1us, |t| t.is_keyword(keywords::Trait)) + self.look_ahead(1, |t| t.is_keyword(keywords::Trait)) { // UNSAFE TRAIT ITEM self.expect_keyword(keywords::Unsafe); @@ -5650,7 +5650,7 @@ impl<'a> Parser<'a> { return Ok(item); } if self.token.is_keyword(keywords::Unsafe) && - self.look_ahead(1us, |t| t.is_keyword(keywords::Impl)) + self.look_ahead(1, |t| t.is_keyword(keywords::Impl)) { // IMPL ITEM self.expect_keyword(keywords::Unsafe); @@ -5680,7 +5680,7 @@ impl<'a> Parser<'a> { return Ok(item); } if self.token.is_keyword(keywords::Unsafe) - && self.look_ahead(1us, |t| *t != token::OpenDelim(token::Brace)) { + && self.look_ahead(1, |t| *t != token::OpenDelim(token::Brace)) { // UNSAFE FUNCTION ITEM self.bump(); let abi = if self.eat_keyword(keywords::Extern) { @@ -5958,7 +5958,7 @@ impl<'a> Parser<'a> { } } } - let mut rename_to = path[path.len() - 1us]; + let mut rename_to = path[path.len() - 1]; let path = ast::Path { span: mk_sp(lo, self.last_span.hi), global: false, diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 70d6a5f695a..707b3c72ecd 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -132,15 +132,15 @@ pub fn buf_str(toks: &[Token], let mut i = left; let mut l = lim; let mut s = string::String::from_str("["); - while i != right && l != 0us { - l -= 1us; + while i != right && l != 0 { + l -= 1; if i != left { s.push_str(", "); } s.push_str(&format!("{}={}", szs[i], tok_str(&toks[i]))[]); - i += 1us; + i += 1; i %= n; } s.push(']'); @@ -326,8 +326,8 @@ impl Printer { if self.scan_stack_empty { self.left_total = 1; self.right_total = 1; - self.left = 0us; - self.right = 0us; + self.left = 0; + self.right = 0; } else { self.advance_right(); } debug!("pp Begin({})/buffer ~[{},{}]", b.offset, self.left, self.right); @@ -355,8 +355,8 @@ impl Printer { if self.scan_stack_empty { self.left_total = 1; self.right_total = 1; - self.left = 0us; - self.right = 0us; + self.left = 0; + self.right = 0; } else { self.advance_right(); } debug!("pp Break({})/buffer ~[{},{}]", b.offset, self.left, self.right); @@ -410,7 +410,7 @@ impl Printer { if self.scan_stack_empty { self.scan_stack_empty = false; } else { - self.top += 1us; + self.top += 1; self.top %= self.buf_len; assert!((self.top != self.bottom)); } @@ -422,7 +422,7 @@ impl Printer { if self.top == self.bottom { self.scan_stack_empty = true; } else { - self.top += self.buf_len - 1us; self.top %= self.buf_len; + self.top += self.buf_len - 1; self.top %= self.buf_len; } return x; } @@ -436,12 +436,12 @@ impl Printer { if self.top == self.bottom { self.scan_stack_empty = true; } else { - self.bottom += 1us; self.bottom %= self.buf_len; + self.bottom += 1; self.bottom %= self.buf_len; } return x; } pub fn advance_right(&mut self) { - self.right += 1us; + self.right += 1; self.right %= self.buf_len; assert!((self.right != self.left)); } @@ -471,7 +471,7 @@ impl Printer { break; } - self.left += 1us; + self.left += 1; self.left %= self.buf_len; left_size = self.size[self.left]; @@ -520,7 +520,7 @@ impl Printer { pub fn get_top(&mut self) -> PrintStackElem { let print_stack = &mut self.print_stack; let n = print_stack.len(); - if n != 0us { + if n != 0 { (*print_stack)[n - 1] } else { PrintStackElem { @@ -565,7 +565,7 @@ impl Printer { Token::End => { debug!("print End -> pop End"); let print_stack = &mut self.print_stack; - assert!((print_stack.len() != 0us)); + assert!((print_stack.len() != 0)); print_stack.pop().unwrap(); Ok(()) } @@ -667,11 +667,11 @@ pub fn spaces(p: &mut Printer, n: usize) -> old_io::IoResult<()> { } pub fn zerobreak(p: &mut Printer) -> old_io::IoResult<()> { - spaces(p, 0us) + spaces(p, 0) } pub fn space(p: &mut Printer) -> old_io::IoResult<()> { - spaces(p, 1us) + spaces(p, 1) } pub fn hardbreak(p: &mut Printer) -> old_io::IoResult<()> { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 5367ccc1357..a7ff486c634 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -92,10 +92,10 @@ pub fn rust_printer_annotated<'a>(writer: Box, } #[allow(non_upper_case_globals)] -pub const indent_unit: usize = 4us; +pub const indent_unit: usize = 4; #[allow(non_upper_case_globals)] -pub const default_columns: usize = 78us; +pub const default_columns: usize = 78; /// Requires you to pass an input filename and reader so that /// it can scan the input text for comments and literals to @@ -377,7 +377,7 @@ pub fn block_to_string(blk: &ast::Block) -> String { // containing cbox, will be closed by print-block at } try!(s.cbox(indent_unit)); // head-ibox, will be closed by print-block after { - try!(s.ibox(0us)); + try!(s.ibox(0)); s.print_block(blk) }) } @@ -516,7 +516,7 @@ impl<'a> State<'a> { pub fn bclose_maybe_open (&mut self, span: codemap::Span, indented: usize, close_box: bool) -> IoResult<()> { try!(self.maybe_print_comment(span.hi)); - try!(self.break_offset_if_not_bol(1us, -(indented as isize))); + try!(self.break_offset_if_not_bol(1, -(indented as isize))); try!(word(&mut self.s, "}")); if close_box { try!(self.end()); // close the outer-box @@ -591,7 +591,7 @@ impl<'a> State<'a> { pub fn commasep(&mut self, b: Breaks, elts: &[T], mut op: F) -> IoResult<()> where F: FnMut(&mut State, &T) -> IoResult<()>, { - try!(self.rbox(0us, b)); + try!(self.rbox(0, b)); let mut first = true; for elt in elts.iter() { if first { first = false; } else { try!(self.word_space(",")); } @@ -609,13 +609,13 @@ impl<'a> State<'a> { F: FnMut(&mut State, &T) -> IoResult<()>, G: FnMut(&T) -> codemap::Span, { - try!(self.rbox(0us, b)); + try!(self.rbox(0, b)); let len = elts.len(); - let mut i = 0us; + let mut i = 0; for elt in elts.iter() { try!(self.maybe_print_comment(get_span(elt).hi)); try!(op(self, elt)); - i += 1us; + i += 1; if i < len { try!(word(&mut self.s, ",")); try!(self.maybe_print_trailing_comment(get_span(elt), @@ -660,7 +660,7 @@ impl<'a> State<'a> { pub fn print_type(&mut self, ty: &ast::Ty) -> IoResult<()> { try!(self.maybe_print_comment(ty.span.lo)); - try!(self.ibox(0us)); + try!(self.ibox(0)); match ty.node { ast::TyVec(ref ty) => { try!(word(&mut self.s, "[")); @@ -880,7 +880,7 @@ impl<'a> State<'a> { } ast::ItemTy(ref ty, ref params) => { try!(self.ibox(indent_unit)); - try!(self.ibox(0us)); + try!(self.ibox(0)); try!(self.word_nbsp(&visibility_qualified(item.vis, "type")[])); try!(self.print_ident(item.ident)); try!(self.print_generics(params)); @@ -1277,7 +1277,7 @@ impl<'a> State<'a> { pub fn print_outer_attributes(&mut self, attrs: &[ast::Attribute]) -> IoResult<()> { - let mut count = 0us; + let mut count = 0; for attr in attrs.iter() { match attr.node.style { ast::AttrOuter => { @@ -1295,7 +1295,7 @@ impl<'a> State<'a> { pub fn print_inner_attributes(&mut self, attrs: &[ast::Attribute]) -> IoResult<()> { - let mut count = 0us; + let mut count = 0; for attr in attrs.iter() { match attr.node.style { ast::AttrInner => { @@ -1416,8 +1416,8 @@ impl<'a> State<'a> { match _else.node { // "another else-if" ast::ExprIf(ref i, ref then, ref e) => { - try!(self.cbox(indent_unit - 1us)); - try!(self.ibox(0us)); + try!(self.cbox(indent_unit - 1)); + try!(self.ibox(0)); try!(word(&mut self.s, " else if ")); try!(self.print_expr(&**i)); try!(space(&mut self.s)); @@ -1426,8 +1426,8 @@ impl<'a> State<'a> { } // "another else-if-let" ast::ExprIfLet(ref pat, ref expr, ref then, ref e) => { - try!(self.cbox(indent_unit - 1us)); - try!(self.ibox(0us)); + try!(self.cbox(indent_unit - 1)); + try!(self.ibox(0)); try!(word(&mut self.s, " else if let ")); try!(self.print_pat(&**pat)); try!(space(&mut self.s)); @@ -1439,8 +1439,8 @@ impl<'a> State<'a> { } // "final else" ast::ExprBlock(ref b) => { - try!(self.cbox(indent_unit - 1us)); - try!(self.ibox(0us)); + try!(self.cbox(indent_unit - 1)); + try!(self.ibox(0)); try!(word(&mut self.s, " else ")); self.print_block(&**b) } @@ -1606,7 +1606,7 @@ impl<'a> State<'a> { try!(self.print_expr(&*args[0])); try!(word(&mut self.s, ".")); try!(self.print_ident(ident.node)); - if tys.len() > 0us { + if tys.len() > 0 { try!(word(&mut self.s, "::<")); try!(self.commasep(Inconsistent, tys, |s, ty| s.print_type(&**ty))); @@ -1777,7 +1777,7 @@ impl<'a> State<'a> { // containing cbox, will be closed by print-block at } try!(self.cbox(indent_unit)); // head-box, will be closed by print-block after { - try!(self.ibox(0us)); + try!(self.ibox(0)); try!(self.print_block(&**blk)); } ast::ExprAssign(ref lhs, ref rhs) => { @@ -2154,7 +2154,7 @@ impl<'a> State<'a> { }, |f| f.node.pat.span)); if etc { - if fields.len() != 0us { try!(self.word_space(",")); } + if fields.len() != 0 { try!(self.word_space(",")); } try!(word(&mut self.s, "..")); } try!(space(&mut self.s)); @@ -2221,7 +2221,7 @@ impl<'a> State<'a> { try!(space(&mut self.s)); } try!(self.cbox(indent_unit)); - try!(self.ibox(0us)); + try!(self.ibox(0)); try!(self.print_outer_attributes(&arm.attrs[])); let mut first = true; for p in arm.pats.iter() { @@ -2307,7 +2307,7 @@ impl<'a> State<'a> { -> IoResult<()> { // It is unfortunate to duplicate the commasep logic, but we want the // self type and the args all in the same box. - try!(self.rbox(0us, Inconsistent)); + try!(self.rbox(0, Inconsistent)); let mut first = true; for &explicit_self in opt_explicit_self.iter() { let m = match explicit_self { @@ -2457,7 +2457,7 @@ impl<'a> State<'a> { try!(word(&mut self.s, "<")); let mut ints = Vec::new(); - for i in 0us..total { + for i in 0..total { ints.push(i); } @@ -2707,7 +2707,7 @@ impl<'a> State<'a> { if span.hi < (*cmnt).pos && (*cmnt).pos < next && span_line.line == comment_line.line { try!(self.print_comment(cmnt)); - self.cur_cmnt_and_lit.cur_cmnt += 1us; + self.cur_cmnt_and_lit.cur_cmnt += 1; } } _ => () @@ -2725,7 +2725,7 @@ impl<'a> State<'a> { match self.next_comment() { Some(ref cmnt) => { try!(self.print_comment(cmnt)); - self.cur_cmnt_and_lit.cur_cmnt += 1us; + self.cur_cmnt_and_lit.cur_cmnt += 1; } _ => break } @@ -2807,7 +2807,7 @@ impl<'a> State<'a> { while self.cur_cmnt_and_lit.cur_lit < lits.len() { let ltrl = (*lits)[self.cur_cmnt_and_lit.cur_lit].clone(); if ltrl.pos > pos { return None; } - self.cur_cmnt_and_lit.cur_lit += 1us; + self.cur_cmnt_and_lit.cur_lit += 1; if ltrl.pos == pos { return Some(ltrl); } } None @@ -2822,7 +2822,7 @@ impl<'a> State<'a> { Some(ref cmnt) => { if (*cmnt).pos < pos { try!(self.print_comment(cmnt)); - self.cur_cmnt_and_lit.cur_cmnt += 1us; + self.cur_cmnt_and_lit.cur_cmnt += 1; } else { break; } } _ => break @@ -2835,7 +2835,7 @@ impl<'a> State<'a> { cmnt: &comments::Comment) -> IoResult<()> { match cmnt.style { comments::Mixed => { - assert_eq!(cmnt.lines.len(), 1us); + assert_eq!(cmnt.lines.len(), 1); try!(zerobreak(&mut self.s)); try!(word(&mut self.s, &cmnt.lines[0][])); zerobreak(&mut self.s) @@ -2854,11 +2854,11 @@ impl<'a> State<'a> { } comments::Trailing => { try!(word(&mut self.s, " ")); - if cmnt.lines.len() == 1us { + if cmnt.lines.len() == 1 { try!(word(&mut self.s, &cmnt.lines[0][])); hardbreak(&mut self.s) } else { - try!(self.ibox(0us)); + try!(self.ibox(0)); for line in cmnt.lines.iter() { if !line.is_empty() { try!(word(&mut self.s, &line[])); diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index a7679adca2e..61ce664d2c7 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -356,8 +356,8 @@ fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool { let tparm_cnt = generics.ty_params.len(); // NB: inadequate check, but we're running // well before resolve, can't get too deep. - input_cnt == 1us - && no_output && tparm_cnt == 0us + input_cnt == 1 + && no_output && tparm_cnt == 0 } _ => false } -- cgit 1.4.1-3-g733a5 From d5d7e6565a4034b93d19be1edafd20730a4276bc Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Sat, 31 Jan 2015 12:20:46 -0500 Subject: `for x in xs.iter()` -> `for x in &xs` --- src/compiletest/compiletest.rs | 6 +- src/compiletest/procsrv.rs | 4 +- src/compiletest/runtest.rs | 18 ++-- src/compiletest/util.rs | 2 +- src/libarena/lib.rs | 2 +- src/libcollections/bench.rs | 2 +- src/libcollections/binary_heap.rs | 4 +- src/libcollections/bit.rs | 16 ++-- src/libcollections/btree/map.rs | 4 +- src/libcollections/btree/node.rs | 6 +- src/libcollections/btree/set.rs | 6 +- src/libcollections/dlist.rs | 2 +- src/libcollections/enum_set.rs | 2 +- src/libcollections/ring_buf.rs | 4 +- src/libcollections/slice.rs | 12 +-- src/libcollections/str.rs | 10 +-- src/libcollections/string.rs | 2 +- src/libcollections/vec.rs | 4 +- src/libcollections/vec_map.rs | 4 +- src/libcore/fmt/mod.rs | 2 +- src/libcore/hash/mod.rs | 2 +- src/libcoretest/cmp.rs | 8 +- src/libcoretest/hash/mod.rs | 2 +- src/libcoretest/hash/sip.rs | 4 +- src/libgetopts/lib.rs | 10 +-- src/libgraphviz/lib.rs | 6 +- src/librand/distributions/mod.rs | 2 +- src/librand/distributions/range.rs | 4 +- src/librand/isaac.rs | 4 +- src/librand/reseeding.rs | 2 +- src/librustc/lint/builtin.rs | 26 +++--- src/librustc/lint/context.rs | 12 +-- src/librustc/metadata/creader.rs | 6 +- src/librustc/metadata/csearch.rs | 2 +- src/librustc/metadata/cstore.rs | 8 +- src/librustc/metadata/decoder.rs | 6 +- src/librustc/metadata/encoder.rs | 74 +++++++-------- src/librustc/metadata/filesearch.rs | 5 +- src/librustc/metadata/loader.rs | 2 +- src/librustc/metadata/tydecode.rs | 2 +- src/librustc/metadata/tyencode.rs | 16 ++-- src/librustc/middle/astencode.rs | 32 +++---- src/librustc/middle/cfg/construct.rs | 10 +-- src/librustc/middle/check_const.rs | 4 +- src/librustc/middle/check_match.rs | 12 +-- src/librustc/middle/const_eval.rs | 2 +- src/librustc/middle/dataflow.rs | 4 +- src/librustc/middle/dead.rs | 14 +-- src/librustc/middle/dependency_format.rs | 4 +- src/librustc/middle/entry.rs | 2 +- src/librustc/middle/expr_use_visitor.rs | 34 +++---- src/librustc/middle/infer/combine.rs | 6 +- src/librustc/middle/infer/error_reporting.rs | 28 +++--- src/librustc/middle/infer/higher_ranked/mod.rs | 10 +-- src/librustc/middle/infer/mod.rs | 4 +- src/librustc/middle/infer/region_inference/mod.rs | 16 ++-- src/librustc/middle/infer/type_variable.rs | 4 +- src/librustc/middle/lang_items.rs | 4 +- src/librustc/middle/liveness.rs | 24 ++--- src/librustc/middle/mem_categorization.rs | 10 +-- src/librustc/middle/reachable.rs | 4 +- src/librustc/middle/recursion_limit.rs | 2 +- src/librustc/middle/region.rs | 4 +- src/librustc/middle/resolve_lifetime.rs | 22 ++--- src/librustc/middle/stability.rs | 8 +- src/librustc/middle/subst.rs | 2 +- src/librustc/middle/traits/doc.rs | 2 +- src/librustc/middle/traits/error_reporting.rs | 4 +- src/librustc/middle/traits/object_safety.rs | 2 +- src/librustc/middle/traits/project.rs | 2 +- src/librustc/middle/traits/select.rs | 2 +- src/librustc/middle/traits/util.rs | 2 +- src/librustc/middle/ty.rs | 42 ++++----- src/librustc/middle/weak_lang_items.rs | 2 +- src/librustc/plugin/build.rs | 2 +- src/librustc/plugin/load.rs | 10 +-- src/librustc/session/config.rs | 12 +-- src/librustc/util/common.rs | 2 +- src/librustc/util/nodemap.rs | 2 +- src/librustc/util/ppaux.rs | 16 ++-- src/librustc_back/archive.rs | 6 +- src/librustc_back/rpath.rs | 8 +- src/librustc_back/sha2.rs | 4 +- src/librustc_back/svh.rs | 4 +- src/librustc_back/target/mod.rs | 2 +- src/librustc_borrowck/borrowck/check_loans.rs | 8 +- src/librustc_borrowck/borrowck/fragments.rs | 14 +-- .../borrowck/gather_loans/move_error.rs | 6 +- src/librustc_borrowck/borrowck/move_data.rs | 12 +-- src/librustc_borrowck/graphviz.rs | 2 +- src/librustc_driver/driver.rs | 6 +- src/librustc_driver/lib.rs | 10 +-- src/librustc_driver/test.rs | 4 +- src/librustc_llvm/lib.rs | 4 +- src/librustc_privacy/lib.rs | 54 +++++------ src/librustc_resolve/build_reduced_graph.rs | 18 ++-- src/librustc_resolve/check_unused.rs | 2 +- src/librustc_resolve/lib.rs | 66 +++++++------- src/librustc_resolve/record_exports.rs | 8 +- src/librustc_trans/back/link.rs | 14 +-- src/librustc_trans/back/lto.rs | 2 +- src/librustc_trans/back/write.rs | 10 +-- src/librustc_trans/save/mod.rs | 56 ++++++------ src/librustc_trans/trans/_match.rs | 24 ++--- src/librustc_trans/trans/adt.rs | 8 +- src/librustc_trans/trans/base.rs | 22 ++--- src/librustc_trans/trans/cabi_aarch64.rs | 2 +- src/librustc_trans/trans/cabi_arm.rs | 2 +- src/librustc_trans/trans/cabi_mips.rs | 2 +- src/librustc_trans/trans/cabi_powerpc.rs | 2 +- src/librustc_trans/trans/cabi_x86.rs | 2 +- src/librustc_trans/trans/cabi_x86_64.rs | 6 +- src/librustc_trans/trans/cabi_x86_win64.rs | 2 +- src/librustc_trans/trans/cleanup.rs | 2 +- src/librustc_trans/trans/common.rs | 2 +- src/librustc_trans/trans/controlflow.rs | 2 +- src/librustc_trans/trans/debuginfo.rs | 58 ++++++------ src/librustc_trans/trans/expr.rs | 8 +- src/librustc_trans/trans/foreign.rs | 8 +- src/librustc_trans/trans/glue.rs | 2 +- src/librustc_trans/trans/intrinsic.rs | 2 +- src/librustc_trans/trans/meth.rs | 4 +- src/librustc_trans/trans/tvec.rs | 2 +- src/librustc_trans/trans/type_of.rs | 2 +- src/librustc_typeck/astconv.rs | 8 +- src/librustc_typeck/check/_match.rs | 20 ++--- src/librustc_typeck/check/method/probe.rs | 16 ++-- src/librustc_typeck/check/mod.rs | 42 ++++----- src/librustc_typeck/check/regionck.rs | 34 +++---- src/librustc_typeck/check/regionmanip.rs | 10 +-- src/librustc_typeck/check/upvar.rs | 2 +- src/librustc_typeck/check/vtable.rs | 6 +- src/librustc_typeck/check/wf.rs | 8 +- src/librustc_typeck/check/writeback.rs | 10 +-- src/librustc_typeck/coherence/mod.rs | 20 ++--- src/librustc_typeck/coherence/overlap.rs | 4 +- src/librustc_typeck/collect.rs | 32 +++---- src/librustc_typeck/variance.rs | 20 ++--- src/librustdoc/clean/mod.rs | 28 +++--- src/librustdoc/externalfiles.rs | 2 +- src/librustdoc/html/format.rs | 18 ++-- src/librustdoc/html/render.rs | 66 +++++++------- src/librustdoc/html/toc.rs | 2 +- src/librustdoc/lib.rs | 14 +-- src/librustdoc/markdown.rs | 2 +- src/librustdoc/passes.rs | 4 +- src/librustdoc/plugins.rs | 2 +- src/librustdoc/visit_ast.rs | 4 +- src/libserialize/collection_impls.rs | 10 +-- src/libserialize/hex.rs | 2 +- src/libserialize/json.rs | 14 +-- src/libstd/ascii.rs | 2 +- src/libstd/collections/hash/map.rs | 4 +- src/libstd/collections/hash/set.rs | 6 +- src/libstd/old_io/extensions.rs | 12 +-- src/libstd/old_io/fs.rs | 2 +- src/libstd/old_io/net/addrinfo.rs | 2 +- src/libstd/old_io/process.rs | 6 +- src/libstd/old_io/test.rs | 2 +- src/libstd/os.rs | 14 +-- src/libstd/path/mod.rs | 4 +- src/libstd/rand/mod.rs | 2 +- src/libstd/rand/os.rs | 2 +- src/libstd/rt/unwind.rs | 2 +- src/libstd/sys/common/net.rs | 2 +- src/libstd/sys/unix/process.rs | 2 +- src/libstd/sys/windows/os.rs | 2 +- src/libstd/sys/windows/process.rs | 6 +- src/libstd/sys/windows/thread_local.rs | 2 +- src/libstd/thread_local/mod.rs | 2 +- src/libsyntax/ast_map/mod.rs | 12 +-- src/libsyntax/ast_util.rs | 12 +-- src/libsyntax/attr.rs | 6 +- src/libsyntax/codemap.rs | 4 +- src/libsyntax/diagnostic.rs | 4 +- src/libsyntax/ext/deriving/generic/mod.rs | 4 +- src/libsyntax/ext/deriving/hash.rs | 2 +- src/libsyntax/ext/deriving/primitive.rs | 2 +- src/libsyntax/ext/expand.rs | 12 +-- src/libsyntax/ext/format.rs | 4 +- src/libsyntax/ext/quote.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 6 +- src/libsyntax/ext/tt/macro_rules.rs | 2 +- src/libsyntax/feature_gate.rs | 6 +- src/libsyntax/parse/lexer/comments.rs | 4 +- src/libsyntax/parse/lexer/mod.rs | 2 +- src/libsyntax/parse/mod.rs | 2 +- src/libsyntax/parse/parser.rs | 4 +- src/libsyntax/print/pprust.rs | 82 ++++++++--------- src/libsyntax/util/interner.rs | 4 +- src/libsyntax/visit.rs | 100 ++++++++++----------- src/libterm/terminfo/parm.rs | 8 +- src/libterm/terminfo/searcher.rs | 2 +- src/libtest/lib.rs | 8 +- src/libtest/stats.rs | 4 +- src/libunicode/normalize.rs | 4 +- src/rustbook/book.rs | 2 +- src/test/auxiliary/cci_nested_lib.rs | 2 +- src/test/bench/shootout-chameneos-redux.rs | 6 +- src/test/bench/shootout-fasta-redux.rs | 4 +- src/test/bench/shootout-k-nucleotide-pipes.rs | 4 +- src/test/bench/shootout-k-nucleotide.rs | 2 +- src/test/bench/shootout-mandelbrot.rs | 2 +- src/test/bench/shootout-meteor.rs | 4 +- src/test/bench/shootout-nbody.rs | 2 +- .../borrowck-for-loop-correct-cmt-for-pattern.rs | 2 +- .../compile-fail/borrowck-for-loop-head-linkage.rs | 2 +- .../compile-fail/borrowck-insert-during-each.rs | 2 +- .../compile-fail/drop-with-active-borrows-1.rs | 2 +- src/test/compile-fail/issue-15480.rs | 2 +- src/test/compile-fail/issue-18400.rs | 2 +- src/test/compile-fail/issue-2149.rs | 2 +- src/test/compile-fail/issue-2150.rs | 2 +- src/test/compile-fail/issue-5100.rs | 2 +- src/test/compile-fail/issue-7573.rs | 4 +- .../debuginfo/destructured-for-loop-variable.rs | 4 +- src/test/debuginfo/lexical-scope-in-for-loop.rs | 2 +- src/test/debuginfo/unreachable-locals.rs | 10 +-- src/test/pretty/block-comment-wchar.pp | 2 +- src/test/pretty/block-comment-wchar.rs | 2 +- src/test/pretty/for-comment.rs | 2 +- src/test/run-pass/auto-loop.rs | 2 +- src/test/run-pass/block-arg.rs | 2 +- src/test/run-pass/block-iter-1.rs | 2 +- src/test/run-pass/block-iter-2.rs | 2 +- src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs | 2 +- src/test/run-pass/break.rs | 4 +- .../run-pass/capture-clauses-boxed-closures.rs | 2 +- .../run-pass/capture-clauses-unboxed-closures.rs | 2 +- src/test/run-pass/cleanup-rvalue-for-scope.rs | 2 +- src/test/run-pass/coerce-reborrow-imm-vec-arg.rs | 2 +- src/test/run-pass/const-vec-of-fns.rs | 2 +- src/test/run-pass/explicit-self-closures.rs | 2 +- src/test/run-pass/fn-pattern-expected-type-2.rs | 2 +- src/test/run-pass/for-destruct.rs | 2 +- src/test/run-pass/for-loop-goofiness.rs | 2 +- src/test/run-pass/for-loop-panic.rs | 2 +- .../run-pass/foreach-external-iterators-break.rs | 2 +- ...ach-external-iterators-hashmap-break-restart.rs | 2 +- .../run-pass/foreach-external-iterators-hashmap.rs | 4 +- .../run-pass/foreach-external-iterators-nested.rs | 4 +- src/test/run-pass/foreach-external-iterators.rs | 2 +- src/test/run-pass/generic-static-methods.rs | 2 +- src/test/run-pass/hashmap-memory.rs | 2 +- src/test/run-pass/issue-10396.rs | 2 +- src/test/run-pass/issue-17068.rs | 2 +- src/test/run-pass/issue-2904.rs | 4 +- src/test/run-pass/issue-3389.rs | 2 +- src/test/run-pass/issue-3563-2.rs | 2 +- src/test/run-pass/issue-3563-3.rs | 2 +- src/test/run-pass/issue-4241.rs | 2 +- src/test/run-pass/issue-4542.rs | 2 +- src/test/run-pass/issue-5666.rs | 2 +- src/test/run-pass/issue-5688.rs | 2 +- src/test/run-pass/linear-for-loop.rs | 2 +- src/test/run-pass/loop-label-shadowing.rs | 2 +- src/test/run-pass/loop-scope.rs | 2 +- src/test/run-pass/monad.rs | 2 +- ...mutability-inherits-through-fixed-length-vec.rs | 2 +- src/test/run-pass/overloaded-index-assoc-list.rs | 2 +- src/test/run-pass/packed-struct-vec.rs | 2 +- src/test/run-pass/regions-mock-tcx.rs | 2 +- src/test/run-pass/repeated-vector-syntax.rs | 2 +- src/test/run-pass/shadow.rs | 2 +- src/test/run-pass/static-impl.rs | 4 +- src/test/run-pass/task-comm-3.rs | 2 +- src/test/run-pass/trait-bounds-in-arc.rs | 6 +- src/test/run-pass/trait-generic.rs | 2 +- src/test/run-pass/vector-sort-panic-safe.rs | 2 +- 269 files changed, 1063 insertions(+), 1064 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index b73623223fd..b16e9dea03d 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -276,7 +276,7 @@ pub fn make_tests(config: &Config) -> Vec { config.src_base.display()); let mut tests = Vec::new(); let dirs = fs::readdir(&config.src_base).unwrap(); - for file in dirs.iter() { + for file in &dirs { let file = file.clone(); debug!("inspecting file {:?}", file.display()); if is_test(config, &file) { @@ -304,13 +304,13 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool { let mut valid = false; - for ext in valid_extensions.iter() { + for ext in &valid_extensions { if name.ends_with(ext.as_slice()) { valid = true; } } - for pre in invalid_prefixes.iter() { + for pre in &invalid_prefixes { if name.starts_with(pre.as_slice()) { valid = false; } diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index 7f3865308da..57f4171f7c2 100644 --- a/src/compiletest/procsrv.rs +++ b/src/compiletest/procsrv.rs @@ -46,7 +46,7 @@ pub fn run(lib_path: &str, match cmd.spawn() { Ok(mut process) => { - for input in input.iter() { + if let Some(input) = input { process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap(); } let ProcessOutput { status, output, error } = @@ -78,7 +78,7 @@ pub fn run_background(lib_path: &str, match cmd.spawn() { Ok(mut process) => { - for input in input.iter() { + if let Some(input) = input { process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap(); } diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 18cb3d1d5b0..2143cf22e05 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -547,7 +547,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) { exe_file.as_str().unwrap().replace("\\", "\\\\"))[]); // Add line breakpoints - for line in breakpoint_lines.iter() { + for line in &breakpoint_lines { script_str.push_str(&format!("break '{}':{}\n", testfile.filename_display(), *line)[]); @@ -683,13 +683,13 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) script_str.push_str("type category enable Rust\n"); // Set breakpoints on every line that contains the string "#break" - for line in breakpoint_lines.iter() { + for line in &breakpoint_lines { script_str.push_str(format!("breakpoint set --line {}\n", line).as_slice()); } // Append the other commands - for line in commands.iter() { + for line in &commands { script_str.push_str(line.as_slice()); script_str.push_str("\n"); } @@ -847,7 +847,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String]) let mut rest = line.trim(); let mut first = true; let mut failed = false; - for frag in check_fragments[i].iter() { + for frag in &check_fragments[i] { let found = if first { if rest.starts_with(frag.as_slice()) { Some(0) @@ -915,7 +915,7 @@ fn check_error_patterns(props: &TestProps, missing_patterns[0]).as_slice(), proc_res); } else { - for pattern in missing_patterns.iter() { + for pattern in missing_patterns { error(format!("error pattern '{}' not found!", *pattern).as_slice()); } @@ -935,7 +935,7 @@ fn check_no_compiler_crash(proc_res: &ProcRes) { fn check_forbid_output(props: &TestProps, output_to_check: &str, proc_res: &ProcRes) { - for pat in props.forbid_output.iter() { + for pat in &props.forbid_output { if output_to_check.contains(pat.as_slice()) { fatal_proc_rec("forbidden pattern found in compiler output", proc_res); } @@ -1173,7 +1173,7 @@ fn compose_and_run_compiler( // FIXME (#9639): This needs to handle non-utf8 paths let extra_link_args = vec!("-L".to_string(), aux_dir.as_str().unwrap().to_string()); - for rel_ab in props.aux_builds.iter() { + for rel_ab in &props.aux_builds { let abs_ab = config.aux_base.join(rel_ab.as_slice()); let aux_props = header::load_props(&abs_ab); let mut crate_type = if aux_props.no_prefer_dynamic { @@ -1510,7 +1510,7 @@ fn _arm_exec_compiled_test(config: &Config, runargs.push(format!("{}", config.adb_test_dir)); runargs.push(format!("{}", prog_short)); - for tv in args.args.iter() { + for tv in &args.args { runargs.push(tv.to_string()); } procsrv::run("", @@ -1591,7 +1591,7 @@ fn _arm_push_aux_shared_library(config: &Config, testfile: &Path) { let tdir = aux_output_dir_name(config, testfile); let dirs = fs::readdir(&tdir).unwrap(); - for file in dirs.iter() { + for file in &dirs { if file.extension_str() == Some("so") { // FIXME (#9639): This needs to handle non-utf8 paths let copy_result = procsrv::run("", diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs index a116cc33690..b1e44ef34fe 100644 --- a/src/compiletest/util.rs +++ b/src/compiletest/util.rs @@ -26,7 +26,7 @@ static OS_TABLE: &'static [(&'static str, &'static str)] = &[ ]; pub fn get_os(triple: &str) -> &'static str { - for &(triple_os, os) in OS_TABLE.iter() { + for &(triple_os, os) in OS_TABLE { if triple.contains(triple_os) { return os } diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index 5ada51976ac..0ff6cf7b79a 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -127,7 +127,7 @@ impl Drop for Arena { fn drop(&mut self) { unsafe { destroy_chunk(&*self.head.borrow()); - for chunk in self.chunks.borrow().iter() { + for chunk in &*self.chunks.borrow() { if !chunk.is_copy.get() { destroy_chunk(chunk); } diff --git a/src/libcollections/bench.rs b/src/libcollections/bench.rs index d03fbf00847..9301bf5e4ab 100644 --- a/src/libcollections/bench.rs +++ b/src/libcollections/bench.rs @@ -73,7 +73,7 @@ pub fn find_rand_n(n: uint, let mut keys = (0..n).map(|_| rng.gen::() % n) .collect::>(); - for k in keys.iter() { + for k in &keys { insert(map, *k); } diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 8aa4c77f6f9..56bc573cbb4 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -696,7 +696,7 @@ mod tests { let iterout = [9, 5, 3]; let heap = BinaryHeap::from_vec(data); let mut i = 0; - for el in heap.iter() { + for el in &heap { assert_eq!(*el, iterout[i]); i += 1; } @@ -884,7 +884,7 @@ mod tests { let mut q: BinaryHeap = xs.iter().rev().map(|&x| x).collect(); - for &x in xs.iter() { + for &x in &xs { assert_eq!(q.pop().unwrap(), x); } } diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index ec2a274a45d..3d16dd4b166 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -976,7 +976,7 @@ impl Ord for Bitv { #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for Bitv { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - for bit in self.iter() { + for bit in self { try!(write!(fmt, "{}", if bit { 1u32 } else { 0u32 })); } Ok(()) @@ -1743,7 +1743,7 @@ impl fmt::Debug for BitvSet { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "BitvSet {{")); let mut first = true; - for n in self.iter() { + for n in self { if !first { try!(write!(fmt, ", ")); } @@ -1756,7 +1756,7 @@ impl fmt::Debug for BitvSet { impl hash::Hash for BitvSet { fn hash(&self, state: &mut S) { - for pos in self.iter() { + for pos in self { pos.hash(state); } } @@ -2600,7 +2600,7 @@ mod bitv_bench { b.iter(|| { let mut sum = 0u; for _ in 0u..10 { - for pres in bitv.iter() { + for pres in &bitv { sum += pres as uint; } } @@ -2613,7 +2613,7 @@ mod bitv_bench { let bitv = Bitv::from_elem(BENCH_BITS, false); b.iter(|| { let mut sum = 0u; - for pres in bitv.iter() { + for pres in &bitv { sum += pres as uint; } sum @@ -2674,8 +2674,8 @@ mod bitv_set_test { fn test_bitv_set_frombitv_init() { let bools = [true, false]; let lengths = [10, 64, 100]; - for &b in bools.iter() { - for &l in lengths.iter() { + for &b in &bools { + for &l in &lengths { let bitset = BitvSet::from_bitv(Bitv::from_elem(l, b)); assert_eq!(bitset.contains(&1u), b); assert_eq!(bitset.contains(&(l-1u)), b); @@ -3062,7 +3062,7 @@ mod bitv_set_bench { |idx| {idx % 3 == 0})); b.iter(|| { let mut sum = 0u; - for idx in bitv.iter() { + for idx in &bitv { sum += idx as uint; } sum diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index ce5e8f07be1..bc657a19d78 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -856,7 +856,7 @@ impl Extend<(K, V)> for BTreeMap { #[stable(feature = "rust1", since = "1.0.0")] impl, V: Hash> Hash for BTreeMap { fn hash(&self, state: &mut S) { - for elt in self.iter() { + for elt in self { elt.hash(state); } } @@ -1946,7 +1946,7 @@ mod bench { } b.iter(|| { - for entry in map.iter() { + for entry in &map { black_box(entry); } }); diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 8d6f06b25c5..8fdfe9ed56a 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -435,13 +435,13 @@ impl Clone for Node { let mut vals = RawItems::from_parts(ret.vals().as_ptr(), 0); let mut edges = RawItems::from_parts(ret.edges().as_ptr(), 0); - for key in self.keys().iter() { + for key in self.keys() { keys.push(key.clone()) } - for val in self.vals().iter() { + for val in self.vals() { vals.push(val.clone()) } - for edge in self.edges().iter() { + for edge in self.edges() { edges.push(edge.clone()) } diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 72d5bf6d799..a4e28d36a05 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -791,8 +791,8 @@ mod test { let mut set_a = BTreeSet::new(); let mut set_b = BTreeSet::new(); - for x in a.iter() { assert!(set_a.insert(*x)) } - for y in b.iter() { assert!(set_b.insert(*y)) } + for x in a { assert!(set_a.insert(*x)) } + for y in b { assert!(set_b.insert(*y)) } let mut i = 0; f(&set_a, &set_b, Counter { i: &mut i, expected: expected }); @@ -894,7 +894,7 @@ mod test { let set: BTreeSet = xs.iter().map(|&x| x).collect(); - for x in xs.iter() { + for x in &xs { assert!(set.contains(x)); } } diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index beb2973febc..e229cd8a961 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -917,7 +917,7 @@ impl fmt::Debug for DList { impl> Hash for DList { fn hash(&self, state: &mut S) { self.len().hash(state); - for elt in self.iter() { + for elt in self { elt.hash(state); } } diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 9765bb5875e..14a3a5a0990 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -36,7 +36,7 @@ impl fmt::Debug for EnumSet { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "EnumSet {{")); let mut first = true; - for e in self.iter() { + for e in self { if !first { try!(write!(fmt, ", ")); } diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 7032a3d9137..4b9f3980db2 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -1573,7 +1573,7 @@ impl Ord for RingBuf { impl> Hash for RingBuf { fn hash(&self, state: &mut S) { self.len().hash(state); - for elt in self.iter() { + for elt in self { elt.hash(state); } } @@ -1856,7 +1856,7 @@ mod tests { b.iter(|| { let mut sum = 0; - for &i in ring.iter() { + for &i in &ring { sum += i; } test::black_box(sum); diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index affa4898010..9be918dbe15 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -1118,7 +1118,7 @@ impl> SliceConcatExt> for [V] { fn concat(&self) -> Vec { let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len()); let mut result = Vec::with_capacity(size); - for v in self.iter() { + for v in self { result.push_all(v.as_slice()) } result @@ -1128,7 +1128,7 @@ impl> SliceConcatExt> for [V] { let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len()); let mut result = Vec::with_capacity(size + self.len()); let mut first = true; - for v in self.iter() { + for v in self { if first { first = false } else { result.push(sep.clone()) } result.push_all(v.as_slice()) } @@ -2681,13 +2681,13 @@ mod tests { assert_eq!(v.len(), 3); let mut cnt = 0u; - for f in v.iter() { + for f in &v { assert!(*f == Foo); cnt += 1; } assert_eq!(cnt, 3); - for f in v[1..3].iter() { + for f in &v[1..3] { assert!(*f == Foo); cnt += 1; } @@ -2707,7 +2707,7 @@ mod tests { let xs: [Foo; 3] = [Foo, Foo, Foo]; cnt = 0; - for f in xs.iter() { + for f in &xs { assert!(*f == Foo); cnt += 1; } @@ -2858,7 +2858,7 @@ mod bench { b.iter(|| { let mut sum = 0; - for x in v.iter() { + for x in &v { sum += *x; } // sum == 11806, to stop dead code elimination. diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 43b5d14cc86..75f7b812974 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -99,7 +99,7 @@ impl SliceConcatExt for [S] { let len = s.iter().map(|s| s.as_slice().len()).sum(); let mut result = String::with_capacity(len); - for s in s.iter() { + for s in s { result.push_str(s.as_slice()) } @@ -125,7 +125,7 @@ impl SliceConcatExt for [S] { let mut result = String::with_capacity(len); let mut first = true; - for s in s.iter() { + for s in s { if first { first = false; } else { @@ -2005,7 +2005,7 @@ mod tests { let s = "ศไทย中华Việt Nam"; let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; - for ch in v.iter() { + for ch in &v { assert!(s.char_at(pos) == *ch); pos += ch.to_string().len(); } @@ -2703,7 +2703,7 @@ mod tests { &["\u{378}\u{308}\u{903}"], &["\u{378}\u{308}", "\u{903}"]), ]; - for &(s, g) in test_same.iter() { + for &(s, g) in &test_same[] { // test forward iterator assert!(order::equals(s.graphemes(true), g.iter().map(|&x| x))); assert!(order::equals(s.graphemes(false), g.iter().map(|&x| x))); @@ -2713,7 +2713,7 @@ mod tests { assert!(order::equals(s.graphemes(false).rev(), g.iter().rev().map(|&x| x))); } - for &(s, gt, gf) in test_diff.iter() { + for &(s, gt, gf) in &test_diff { // test forward iterator assert!(order::equals(s.graphemes(true), gt.iter().map(|&x| x))); assert!(order::equals(s.graphemes(false), gf.iter().map(|&x| x))); diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index d0b89cfa2c3..b9857973946 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -1118,7 +1118,7 @@ mod tests { (String::from_str("\u{20000}"), vec![0xD840, 0xDC00])]; - for p in pairs.iter() { + for p in &pairs { let (s, u) = (*p).clone(); let s_as_utf16 = s.utf16_units().collect::>(); let u_as_string = String::from_utf16(u.as_slice()).unwrap(); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 82c1c37ab6a..e570d401609 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1547,7 +1547,7 @@ impl Drop for Vec { // zeroed (when moving out, because of #[unsafe_no_drop_flag]). if self.cap != 0 { unsafe { - for x in self.iter() { + for x in &*self { ptr::read(x); } dealloc(*self.ptr, self.cap) @@ -2129,7 +2129,7 @@ mod tests { v.push(()); assert_eq!(v.iter().count(), 2); - for &() in v.iter() {} + for &() in &v {} assert_eq!(v.iter_mut().count(), 2); v.push(()); diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index f2a9bb4392c..1adea45f630 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -90,7 +90,7 @@ impl> Hash for VecMap { // In order to not traverse the `VecMap` twice, count the elements // during iteration. let mut count: uint = 0; - for elt in self.iter() { + for elt in self { elt.hash(state); count += 1; } @@ -1112,7 +1112,7 @@ mod test_map { let map: VecMap = xs.iter().map(|&x| x).collect(); - for &(k, v) in xs.iter() { + for &(k, v) in &xs { assert_eq!(map.get(&k), Some(&v)); } } diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 694888bb2bc..20ef30b0a3e 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -888,7 +888,7 @@ impl Debug for [T] { try!(write!(f, "[")); } let mut is_first = true; - for x in self.iter() { + for x in self { if is_first { is_first = false; } else { diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index 5a4d2fffade..d73e6ed589f 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -205,7 +205,7 @@ impl> Hash for [T] { #[inline] fn hash(&self, state: &mut S) { self.len().hash(state); - for elt in self.iter() { + for elt in self { elt.hash(state); } } diff --git a/src/libcoretest/cmp.rs b/src/libcoretest/cmp.rs index 6bc1f14cc5a..2e5c6fe5a2f 100644 --- a/src/libcoretest/cmp.rs +++ b/src/libcoretest/cmp.rs @@ -66,11 +66,11 @@ fn test_partial_min() { (1.0f64, NAN, None) ]; - for &(a, b, result) in data_integer.iter() { + for &(a, b, result) in &data_integer { assert!(partial_min(a, b) == result); } - for &(a, b, result) in data_float.iter() { + for &(a, b, result) in &data_float { assert!(partial_min(a, b) == result); } } @@ -99,11 +99,11 @@ fn test_partial_max() { (1.0f64, NAN, None) ]; - for &(a, b, result) in data_integer.iter() { + for &(a, b, result) in &data_integer { assert!(partial_max(a, b) == result); } - for &(a, b, result) in data_float.iter() { + for &(a, b, result) in &data_float { assert!(partial_max(a, b) == result); } } diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs index 07f3ab4a5a7..2da3f370b40 100644 --- a/src/libcoretest/hash/mod.rs +++ b/src/libcoretest/hash/mod.rs @@ -25,7 +25,7 @@ impl Default for MyHasher { impl Writer for MyHasher { // Most things we'll just add up the bytes. fn write(&mut self, buf: &[u8]) { - for byte in buf.iter() { + for byte in buf { self.hash += *byte as u64; } } diff --git a/src/libcoretest/hash/sip.rs b/src/libcoretest/hash/sip.rs index 431f7e748f6..a493f71925e 100644 --- a/src/libcoretest/hash/sip.rs +++ b/src/libcoretest/hash/sip.rs @@ -109,7 +109,7 @@ fn test_siphash() { fn to_hex_str(r: &[u8; 8]) -> String { let mut s = String::new(); - for b in r.iter() { + for b in r { s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice()); } s @@ -130,7 +130,7 @@ fn test_siphash() { fn result_str(h: u64) -> String { let r = result_bytes(h); let mut s = String::new(); - for b in r.iter() { + for b in &r { s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice()); } s diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 055672df5d1..b4eb8e9902a 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -315,7 +315,7 @@ impl Matches { /// Returns true if any of several options were matched. pub fn opts_present(&self, names: &[String]) -> bool { - for nm in names.iter() { + for nm in names { match find_opt(self.opts.as_slice(), Name::from_str(&nm[])) { Some(id) if !self.vals[id].is_empty() => return true, _ => (), @@ -326,7 +326,7 @@ impl Matches { /// Returns the string argument supplied to one of several matching options or `None`. pub fn opts_str(&self, names: &[String]) -> Option { - for nm in names.iter() { + for nm in names { match self.opt_val(&nm[]) { Some(Val(ref s)) => return Some(s.clone()), _ => () @@ -342,7 +342,7 @@ impl Matches { pub fn opt_strs(&self, nm: &str) -> Vec { let mut acc: Vec = Vec::new(); let r = self.opt_vals(nm); - for v in r.iter() { + for v in &r { match *v { Val(ref s) => acc.push((*s).clone()), _ => () @@ -395,7 +395,7 @@ fn find_opt(opts: &[Opt], nm: Name) -> Option { } // Search in aliases. - for candidate in opts.iter() { + for candidate in opts { if candidate.aliases.iter().position(|opt| opt.name == nm).is_some() { return opts.iter().position(|opt| opt.name == candidate.name); } @@ -648,7 +648,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { } } let mut name_pos = 0; - for nm in names.iter() { + for nm in &names { name_pos += 1; let optid = match find_opt(opts.as_slice(), (*nm).clone()) { Some(id) => id, diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 3606387ad23..e9c7f837014 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -548,7 +548,7 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N options: &[RenderOption]) -> old_io::IoResult<()> { fn writeln(w: &mut W, arg: &[&str]) -> old_io::IoResult<()> { - for &s in arg.iter() { try!(w.write_str(s)); } + for &s in arg { try!(w.write_str(s)); } w.write_char('\n') } @@ -557,7 +557,7 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N } try!(writeln(w, &["digraph ", g.graph_id().as_slice(), " {"])); - for n in g.nodes().iter() { + for n in &*g.nodes() { try!(indent(w)); let id = g.node_id(n); if options.contains(&RenderOption::NoNodeLabels) { @@ -569,7 +569,7 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N } } - for e in g.edges().iter() { + for e in &*g.edges() { let escaped_label = g.edge_label(e).escape(); try!(indent(w)); let source = g.source(e); diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 1b5e5ae8398..fb543e3d549 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -305,7 +305,7 @@ mod tests { let mut rng = CountingRng { i: 0 }; - for &val in expected.iter() { + for &val in &expected { assert_eq!(wc.ind_sample(&mut rng), val) } }} diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index 16830c84c46..ab0b45e7d32 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -188,7 +188,7 @@ mod tests { let v: &[($ty, $ty)] = &[(0, 10), (10, 127), (Int::min_value(), Int::max_value())]; - for &(low, high) in v.iter() { + for &(low, high) in v { let mut sampler: Range<$ty> = Range::new(low, high); for _ in 0u..1000 { let v = sampler.sample(&mut rng); @@ -214,7 +214,7 @@ mod tests { (-1e35, -1e25), (1e-35, 1e-25), (-1e35, 1e35)]; - for &(low, high) in v.iter() { + for &(low, high) in v { let mut sampler: Range<$ty> = Range::new(low, high); for _ in 0u..1000 { let v = sampler.sample(&mut rng); diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index a22ef704fa5..d0f4afdde72 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -134,7 +134,7 @@ impl IsaacRng { } let r = [(0, MIDPOINT), (MIDPOINT, 0)]; - for &(mr_offset, m2_offset) in r.iter() { + for &(mr_offset, m2_offset) in &r { macro_rules! rngstepp { ($j:expr, $shift:expr) => {{ @@ -373,7 +373,7 @@ impl Isaac64Rng { } } - for &(mr_offset, m2_offset) in MP_VEC.iter() { + for &(mr_offset, m2_offset) in &MP_VEC { for base in (0..MIDPOINT / 4).map(|i| i * 4) { macro_rules! rngstepp { diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs index 57e90139876..75ac1b2cf44 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -225,7 +225,7 @@ mod test { // To test that `fill_bytes` actually did something, check that the // average of `v` is not 0. let mut sum = 0.0; - for &x in v.iter() { + for &x in &v { sum += x as f64; } assert!(sum / v.len() as f64 != 0.0); diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 904c9c3adb5..57380ec2797 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -459,7 +459,7 @@ impl LintPass for ImproperCTypes { } fn check_foreign_fn(cx: &Context, decl: &ast::FnDecl) { - for input in decl.inputs.iter() { + for input in &decl.inputs { check_ty(cx, &*input.ty); } if let ast::Return(ref ret_ty) = decl.output { @@ -469,7 +469,7 @@ impl LintPass for ImproperCTypes { match it.node { ast::ItemForeignMod(ref nmod) if nmod.abi != abi::RustIntrinsic => { - for ni in nmod.items.iter() { + for ni in &nmod.items { match ni.node { ast::ForeignItemFn(ref decl, _) => check_foreign_fn(cx, &**decl), ast::ForeignItemStatic(ref t, _) => check_ty(cx, &**t) @@ -532,7 +532,7 @@ impl LintPass for BoxPointers { // If it's a struct, we also have to check the fields' types match it.node { ast::ItemStruct(ref struct_def, _) => { - for struct_field in struct_def.fields.iter() { + for struct_field in &struct_def.fields { self.check_heap_type(cx, struct_field.span, ty::node_id_to_type(cx.tcx, struct_field.node.id)); } @@ -683,7 +683,7 @@ impl LintPass for UnusedAttributes { "no_builtins", ]; - for &name in ATTRIBUTE_WHITELIST.iter() { + for &name in ATTRIBUTE_WHITELIST { if attr.check_name(name) { break; } @@ -785,7 +785,7 @@ impl LintPass for UnusedResults { } fn check_must_use(cx: &Context, attrs: &[ast::Attribute], sp: Span) -> bool { - for attr in attrs.iter() { + for attr in attrs { if attr.check_name("must_use") { let mut msg = "unused result which must be used".to_string(); // check for #[must_use="..."] @@ -869,7 +869,7 @@ impl LintPass for NonCamelCaseTypes { ast::ItemEnum(ref enum_definition, _) => { if has_extern_repr { return } self.check_case(cx, "type", it.ident, it.span); - for variant in enum_definition.variants.iter() { + for variant in &enum_definition.variants { self.check_case(cx, "variant", variant.node.name, variant.span); } } @@ -878,7 +878,7 @@ impl LintPass for NonCamelCaseTypes { } fn check_generics(&mut self, cx: &Context, it: &ast::Generics) { - for gen in it.ty_params.iter() { + for gen in &*it.ty_params { self.check_case(cx, "type parameter", gen.ident, gen.span); } } @@ -1048,7 +1048,7 @@ impl LintPass for NonSnakeCase { fn check_struct_def(&mut self, cx: &Context, s: &ast::StructDef, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { - for sf in s.fields.iter() { + for sf in &s.fields { if let ast::StructField_ { kind: ast::NamedField(ident, _), .. } = sf.node { self.check_snake_case(cx, "structure field", ident, sf.span); } @@ -1346,7 +1346,7 @@ impl UnusedMut { // avoid false warnings in match arms with multiple patterns let mut mutables = FnvHashMap(); - for p in pats.iter() { + for p in pats { pat_util::pat_bindings(&cx.tcx.def_map, &**p, |mode, id, _, path1| { let ident = path1.node; if let ast::BindByValue(ast::MutMutable) = mode { @@ -1361,7 +1361,7 @@ impl UnusedMut { } let used_mutables = cx.tcx.used_mut_nodes.borrow(); - for (_, v) in mutables.iter() { + for (_, v) in &mutables { if !v.iter().any(|e| used_mutables.contains(e)) { cx.span_lint(UNUSED_MUT, cx.tcx.map.span(v[0]), "variable does not need to be mutable"); @@ -1377,7 +1377,7 @@ impl LintPass for UnusedMut { fn check_expr(&mut self, cx: &Context, e: &ast::Expr) { if let ast::ExprMatch(_, ref arms, _) = e.node { - for a in arms.iter() { + for a in arms { self.check_unused_mut_pat(cx, &a.pats[]) } } @@ -1394,7 +1394,7 @@ impl LintPass for UnusedMut { fn check_fn(&mut self, cx: &Context, _: visit::FnKind, decl: &ast::FnDecl, _: &ast::Block, _: Span, _: ast::NodeId) { - for a in decl.inputs.iter() { + for a in &decl.inputs { self.check_unused_mut_pat(cx, slice::ref_slice(&a.pat)); } } @@ -1871,7 +1871,7 @@ impl LintPass for UnconditionalRecursion { if cx.current_level(UNCONDITIONAL_RECURSION) != Level::Allow { let sess = cx.sess(); // offer some help to the programmer. - for call in self_call_spans.iter() { + for call in &self_call_spans { sess.span_note(*call, "recursive call site") } sess.span_help(sp, "a `loop` may express intention better if this is on purpose") diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index c649ff2635b..4ed61c6ffa1 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -116,7 +116,7 @@ impl LintStore { pub fn register_pass(&mut self, sess: Option<&Session>, from_plugin: bool, pass: LintPassObject) { - for &lint in pass.get_lints().iter() { + for &lint in pass.get_lints() { self.lints.push((*lint, from_plugin)); let id = LintId::of(*lint); @@ -260,7 +260,7 @@ impl LintStore { } pub fn process_command_line(&mut self, sess: &Session) { - for &(ref lint_name, level) in sess.opts.lint_opts.iter() { + for &(ref lint_name, level) in &sess.opts.lint_opts { match self.find_lint(&lint_name[], sess, None) { Some(lint_id) => self.set_level(lint_id, (level, CommandLine)), None => { @@ -340,7 +340,7 @@ macro_rules! run_lints { ($cx:expr, $f:ident, $($args:expr),*) => ({ pub fn gather_attrs(attrs: &[ast::Attribute]) -> Vec> { let mut out = vec!(); - for attr in attrs.iter() { + for attr in attrs { let level = match Level::from_str(attr.name().get()) { None => continue, Some(lvl) => lvl, @@ -357,7 +357,7 @@ pub fn gather_attrs(attrs: &[ast::Attribute]) } }; - for meta in metas.iter() { + for meta in metas { out.push(match meta.node { ast::MetaWord(ref lint_name) => Ok((lint_name.clone(), level, meta.span)), _ => Err(meta.span), @@ -794,8 +794,8 @@ pub fn check_crate(tcx: &ty::ctxt, // If we missed any lints added to the session, then there's a bug somewhere // in the iteration code. - for (id, v) in tcx.sess.lints.borrow().iter() { - for &(lint, span, ref msg) in v.iter() { + for (id, v) in &*tcx.sess.lints.borrow() { + for &(lint, span, ref msg) in v { tcx.sess.span_bug(span, format!("unprocessed lint {} at {}: {}", lint.as_str(), tcx.map.node_to_string(*id), *msg).as_slice()) diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 7b71120ba64..15229b6618f 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -162,7 +162,7 @@ impl<'a> CrateReader<'a> { dump_crates(&self.sess.cstore); } - for &(ref name, kind) in self.sess.opts.libs.iter() { + for &(ref name, kind) in &self.sess.opts.libs { register_native_lib(self.sess, None, name.clone(), kind); } } @@ -235,7 +235,7 @@ impl<'a> CrateReader<'a> { None }) .collect::>(); - for m in link_args.iter() { + for m in &link_args { match m.value_str() { Some(linkarg) => self.sess.cstore.add_used_link_args(linkarg.get()), None => { /* fallthrough */ } @@ -250,7 +250,7 @@ impl<'a> CrateReader<'a> { None }) .collect::>(); - for m in link_args.iter() { + for m in &link_args { match m.meta_item_list() { Some(items) => { let kind = items.iter().find(|k| { diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 1295970d667..619cfc1b52c 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -382,7 +382,7 @@ pub fn get_stability(cstore: &cstore::CStore, pub fn is_staged_api(cstore: &cstore::CStore, def: ast::DefId) -> bool { let cdata = cstore.get_crate_data(def.krate); let attrs = decoder::get_crate_attributes(cdata.data()); - for attr in attrs.iter() { + for attr in &attrs { if attr.name().get() == "staged_api" { match attr.node.value.node { ast::MetaWord(_) => return true, _ => (/*pass*/) } } diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 40242f52493..0a3e173b35e 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -113,7 +113,7 @@ impl CStore { pub fn iter_crate_data(&self, mut i: I) where I: FnMut(ast::CrateNum, &crate_metadata), { - for (&k, v) in self.metas.borrow().iter() { + for (&k, v) in &*self.metas.borrow() { i(k, &**v); } } @@ -122,7 +122,7 @@ impl CStore { pub fn iter_crate_data_origins(&self, mut i: I) where I: FnMut(ast::CrateNum, &crate_metadata, Option), { - for (&k, v) in self.metas.borrow().iter() { + for (&k, v) in &*self.metas.borrow() { let origin = self.get_used_crate_source(k); origin.as_ref().map(|cs| { assert!(k == cs.cnum); }); i(k, &**v, origin); @@ -167,12 +167,12 @@ impl CStore { ordering: &mut Vec) { if ordering.contains(&cnum) { return } let meta = cstore.get_crate_data(cnum); - for (_, &dep) in meta.cnum_map.iter() { + for (_, &dep) in &meta.cnum_map { visit(cstore, dep, ordering); } ordering.push(cnum); }; - for (&num, _) in self.metas.borrow().iter() { + for (&num, _) in &*self.metas.borrow() { visit(self, num, &mut ordering); } ordering.reverse(); diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 94fe99ff07d..3a70490771e 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -1022,7 +1022,7 @@ pub fn get_methods_if_impl(intr: Rc, }); let mut impl_methods = Vec::new(); - for impl_method_id in impl_method_ids.iter() { + for impl_method_id in &impl_method_ids { let impl_method_doc = lookup_item(impl_method_id.node, cdata.data()); let family = item_family(impl_method_doc); match family { @@ -1189,7 +1189,7 @@ fn list_crate_attributes(md: rbml::Doc, hash: &Svh, try!(write!(out, "=Crate Attributes ({})=\n", *hash)); let r = get_attributes(md); - for attr in r.iter() { + for attr in &r { try!(write!(out, "{}\n", pprust::attribute_to_string(attr))); } @@ -1232,7 +1232,7 @@ pub fn get_crate_deps(data: &[u8]) -> Vec { fn list_crate_deps(data: &[u8], out: &mut old_io::Writer) -> old_io::IoResult<()> { try!(write!(out, "=External Dependencies=\n")); - for dep in get_crate_deps(data).iter() { + for dep in &get_crate_deps(data) { try!(write!(out, "{} {}-{}\n", dep.cnum, dep.name, dep.hash)); } try!(write!(out, "\n")); diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 7ad91d4d71c..117ab4c8a5a 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -288,7 +288,7 @@ fn encode_parent_item(rbml_w: &mut Encoder, id: DefId) { fn encode_struct_fields(rbml_w: &mut Encoder, fields: &[ty::field_ty], origin: DefId) { - for f in fields.iter() { + for f in fields { if f.name == special_idents::unnamed_field.name { rbml_w.start_tag(tag_item_unnamed_field); } else { @@ -316,7 +316,7 @@ fn encode_enum_variant_info(ecx: &EncodeContext, let mut i = 0; let vi = ty::enum_variants(ecx.tcx, DefId { krate: ast::LOCAL_CRATE, node: id }); - for variant in variants.iter() { + for variant in variants { let def_id = local_def(variant.node.id); index.push(entry { val: variant.node.id as i64, @@ -367,7 +367,7 @@ fn encode_path>(rbml_w: &mut Encoder, path: PI) { let path = path.collect::>(); rbml_w.start_tag(tag_path); rbml_w.wr_tagged_u32(tag_path_len, path.len() as u32); - for pe in path.iter() { + for pe in &path { let tag = match *pe { ast_map::PathMod(_) => tag_path_elem_mod, ast_map::PathName(_) => tag_path_elem_name @@ -402,8 +402,8 @@ fn encode_reexported_static_base_methods(ecx: &EncodeContext, let impl_items = ecx.tcx.impl_items.borrow(); match ecx.tcx.inherent_impls.borrow().get(&exp.def_id) { Some(implementations) => { - for base_impl_did in implementations.iter() { - for &method_did in (*impl_items)[*base_impl_did].iter() { + for base_impl_did in &**implementations { + for &method_did in &*(*impl_items)[*base_impl_did] { let impl_item = ty::impl_or_trait_item( ecx.tcx, method_did.def_id()); @@ -431,7 +431,7 @@ fn encode_reexported_static_trait_methods(ecx: &EncodeContext, -> bool { match ecx.tcx.trait_items_cache.borrow().get(&exp.def_id) { Some(trait_items) => { - for trait_item in trait_items.iter() { + for trait_item in &**trait_items { if let ty::MethodTraitItem(ref m) = *trait_item { encode_reexported_static_method(rbml_w, exp, @@ -517,9 +517,9 @@ fn encode_reexports(ecx: &EncodeContext, path: PathElems) { debug!("(encoding info for module) encoding reexports for {}", id); match ecx.reexports.get(&id) { - Some(ref exports) => { + Some(exports) => { debug!("(encoding info for module) found reexports for {}", id); - for exp in exports.iter() { + for exp in exports { debug!("(encoding info for module) reexport '{}' ({}/{}) for \ {}", exp.name, @@ -559,7 +559,7 @@ fn encode_info_for_mod(ecx: &EncodeContext, debug!("(encoding info for module) encoding info for module ID {}", id); // Encode info about all the module children. - for item in md.items.iter() { + for item in &md.items { rbml_w.start_tag(tag_mod_child); rbml_w.wr_str(&def_to_string(local_def(item.id))[]); rbml_w.end_tag(); @@ -665,9 +665,9 @@ fn encode_parent_sort(rbml_w: &mut Encoder, sort: char) { fn encode_provided_source(rbml_w: &mut Encoder, source_opt: Option) { - for source in source_opt.iter() { + if let Some(source) = source_opt { rbml_w.start_tag(tag_item_method_provided_source); - let s = def_to_string(*source); + let s = def_to_string(source); rbml_w.writer.write_all(s.as_bytes()); rbml_w.end_tag(); } @@ -684,7 +684,7 @@ fn encode_info_for_struct(ecx: &EncodeContext, let mut index = Vec::new(); /* We encode both private and public fields -- need to include private fields to get the offsets right */ - for field in fields.iter() { + for field in fields { let nm = field.name; let id = field.id.node; @@ -783,7 +783,7 @@ fn encode_generics<'a, 'tcx>(rbml_w: &mut Encoder, rbml_w.wr_tagged_u64(tag_region_param_def_index, param.index as u64); - for &bound_region in param.bounds.iter() { + for &bound_region in ¶m.bounds { encode_region(ecx, rbml_w, bound_region); } @@ -911,7 +911,7 @@ fn encode_info_for_associated_type(ecx: &EncodeContext, fn encode_method_argument_names(rbml_w: &mut Encoder, decl: &ast::FnDecl) { rbml_w.start_tag(tag_method_argument_names); - for arg in decl.inputs.iter() { + for arg in &decl.inputs { rbml_w.start_tag(tag_method_argument_name); if let ast::PatIdent(_, ref path1, _) = arg.pat.node { let name = token::get_ident(path1.node); @@ -926,7 +926,7 @@ fn encode_repr_attrs(rbml_w: &mut Encoder, ecx: &EncodeContext, attrs: &[ast::Attribute]) { let mut repr_attrs = Vec::new(); - for attr in attrs.iter() { + for attr in attrs { repr_attrs.extend(attr::find_repr_attrs(ecx.tcx.sess.diagnostic(), attr).into_iter()); } @@ -962,7 +962,7 @@ fn encode_inherent_implementations(ecx: &EncodeContext, match ecx.tcx.inherent_impls.borrow().get(&def_id) { None => {} Some(implementations) => { - for &impl_def_id in implementations.iter() { + for &impl_def_id in &**implementations { rbml_w.start_tag(tag_items_data_item_inherent_impl); encode_def_id(rbml_w, impl_def_id); rbml_w.end_tag(); @@ -978,7 +978,7 @@ fn encode_extension_implementations(ecx: &EncodeContext, match ecx.tcx.trait_impls.borrow().get(&trait_def_id) { None => {} Some(implementations) => { - for &impl_def_id in implementations.borrow().iter() { + for &impl_def_id in &*implementations.borrow() { rbml_w.start_tag(tag_items_data_item_extension_impl); encode_def_id(rbml_w, impl_def_id); rbml_w.end_tag(); @@ -1091,7 +1091,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_path(rbml_w, path); // Encode all the items in this module. - for foreign_item in fm.items.iter() { + for foreign_item in &fm.items { rbml_w.start_tag(tag_mod_child); rbml_w.wr_str(&def_to_string(local_def(foreign_item.id))[]); rbml_w.end_tag(); @@ -1123,7 +1123,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_name(rbml_w, item.ident.name); encode_attributes(rbml_w, &item.attrs[]); encode_repr_attrs(rbml_w, ecx, &item.attrs[]); - for v in (*enum_definition).variants.iter() { + for v in &enum_definition.variants { encode_variant_id(rbml_w, local_def(v.node.id)); } encode_inlined_item(ecx, rbml_w, IIItemRef(item)); @@ -1216,7 +1216,7 @@ fn encode_info_for_item(ecx: &EncodeContext, } _ => {} } - for &item_def_id in items.iter() { + for &item_def_id in items { rbml_w.start_tag(tag_item_impl_item); match item_def_id { ty::MethodTraitItemId(item_def_id) => { @@ -1230,7 +1230,7 @@ fn encode_info_for_item(ecx: &EncodeContext, } rbml_w.end_tag(); } - for ast_trait_ref in opt_trait.iter() { + if let Some(ref ast_trait_ref) = *opt_trait { let trait_ref = ty::node_id_to_trait_ref( tcx, ast_trait_ref.ref_id); encode_trait_ref(rbml_w, ecx, &*trait_ref, tag_item_trait_ref); @@ -1314,7 +1314,7 @@ fn encode_info_for_item(ecx: &EncodeContext, encode_attributes(rbml_w, &item.attrs[]); encode_visibility(rbml_w, vis); encode_stability(rbml_w, stab); - for &method_def_id in ty::trait_item_def_ids(tcx, def_id).iter() { + for &method_def_id in &*ty::trait_item_def_ids(tcx, def_id) { rbml_w.start_tag(tag_item_trait_item); match method_def_id { ty::MethodTraitItemId(method_def_id) => { @@ -1599,10 +1599,10 @@ fn encode_index(rbml_w: &mut Encoder, index: Vec>, mut write_fn: rbml_w.start_tag(tag_index); let mut bucket_locs = Vec::new(); rbml_w.start_tag(tag_index_buckets); - for bucket in buckets.iter() { + for bucket in &buckets { bucket_locs.push(rbml_w.writer.tell().unwrap()); rbml_w.start_tag(tag_index_buckets_bucket); - for elt in bucket.iter() { + for elt in bucket { rbml_w.start_tag(tag_index_buckets_bucket_elt); assert!(elt.pos < 0xffff_ffff); { @@ -1616,7 +1616,7 @@ fn encode_index(rbml_w: &mut Encoder, index: Vec>, mut write_fn: } rbml_w.end_tag(); rbml_w.start_tag(tag_index_table); - for pos in bucket_locs.iter() { + for pos in &bucket_locs { assert!(*pos < 0xffff_ffff); let wr: &mut SeekableMemWriter = rbml_w.writer; wr.write_be_u32(*pos as u32); @@ -1660,7 +1660,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) { rbml_w.start_tag(tag_meta_item_name); rbml_w.writer.write_all(name.get().as_bytes()); rbml_w.end_tag(); - for inner_item in items.iter() { + for inner_item in items { encode_meta_item(rbml_w, &**inner_item); } rbml_w.end_tag(); @@ -1670,7 +1670,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) { fn encode_attributes(rbml_w: &mut Encoder, attrs: &[ast::Attribute]) { rbml_w.start_tag(tag_attributes); - for attr in attrs.iter() { + for attr in attrs { rbml_w.start_tag(tag_attribute); rbml_w.wr_tagged_u8(tag_attribute_is_sugared_doc, attr.node.is_sugared_doc as u8); encode_meta_item(rbml_w, &*attr.node.value); @@ -1694,7 +1694,7 @@ fn encode_paren_sugar(rbml_w: &mut Encoder, paren_sugar: bool) { fn encode_associated_type_names(rbml_w: &mut Encoder, names: &[ast::Name]) { rbml_w.start_tag(tag_associated_type_names); - for &name in names.iter() { + for &name in names { rbml_w.wr_tagged_str(tag_associated_type_name, token::get_name(name).get()); } rbml_w.end_tag(); @@ -1726,7 +1726,7 @@ fn encode_crate_deps(rbml_w: &mut Encoder, cstore: &cstore::CStore) { // Sanity-check the crate numbers let mut expected_cnum = 1; - for n in deps.iter() { + for n in &deps { assert_eq!(n.cnum, expected_cnum); expected_cnum += 1; } @@ -1740,7 +1740,7 @@ fn encode_crate_deps(rbml_w: &mut Encoder, cstore: &cstore::CStore) { // but is enough to get transitive crate dependencies working. rbml_w.start_tag(tag_crate_deps); let r = get_ordered_deps(cstore); - for dep in r.iter() { + for dep in &r { encode_crate_dep(rbml_w, (*dep).clone()); } rbml_w.end_tag(); @@ -1749,8 +1749,8 @@ fn encode_crate_deps(rbml_w: &mut Encoder, cstore: &cstore::CStore) { fn encode_lang_items(ecx: &EncodeContext, rbml_w: &mut Encoder) { rbml_w.start_tag(tag_lang_items); - for (i, def_id) in ecx.tcx.lang_items.items() { - for id in def_id.iter() { + for (i, &def_id) in ecx.tcx.lang_items.items() { + if let Some(id) = def_id { if id.krate == ast::LOCAL_CRATE { rbml_w.start_tag(tag_lang_items_item); @@ -1773,7 +1773,7 @@ fn encode_lang_items(ecx: &EncodeContext, rbml_w: &mut Encoder) { } } - for i in ecx.tcx.lang_items.missing.iter() { + for i in &ecx.tcx.lang_items.missing { rbml_w.wr_tagged_u32(tag_lang_items_missing, *i as u32); } @@ -1817,7 +1817,7 @@ fn encode_plugin_registrar_fn(ecx: &EncodeContext, rbml_w: &mut Encoder) { fn encode_macro_defs(rbml_w: &mut Encoder, krate: &ast::Crate) { rbml_w.start_tag(tag_macro_defs); - for def in krate.exported_macros.iter() { + for def in &krate.exported_macros { rbml_w.start_tag(tag_macro_def); encode_name(rbml_w, def.ident.name); @@ -1911,7 +1911,7 @@ fn encode_misc_info(ecx: &EncodeContext, rbml_w: &mut Encoder) { rbml_w.start_tag(tag_misc_info); rbml_w.start_tag(tag_misc_info_crate_items); - for item in krate.module.items.iter() { + for item in &krate.module.items { rbml_w.start_tag(tag_mod_child); rbml_w.wr_str(&def_to_string(local_def(item.id))[]); rbml_w.end_tag(); @@ -1935,7 +1935,7 @@ fn encode_misc_info(ecx: &EncodeContext, fn encode_reachable_extern_fns(ecx: &EncodeContext, rbml_w: &mut Encoder) { rbml_w.start_tag(tag_reachable_extern_fns); - for id in ecx.reachable.iter() { + for id in ecx.reachable { if let Some(ast_map::NodeItem(i)) = ecx.tcx.map.find(*id) { if let ast::ItemFn(_, _, abi, ref generics, _) = i.node { if abi != abi::Rust && !generics.is_type_parameterized() { @@ -2150,7 +2150,7 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter, stats.total_bytes = rbml_w.writer.tell().unwrap(); if tcx.sess.meta_stats() { - for e in rbml_w.writer.get_ref().iter() { + for e in rbml_w.writer.get_ref() { if *e == 0 { stats.zero_bytes += 1; } diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 26046cfb43d..6197846ec6f 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -66,7 +66,7 @@ impl<'a> FileSearch<'a> { // Try RUST_PATH if !found { let rustpath = rust_path(); - for path in rustpath.iter() { + for path in &rustpath { let tlib_path = make_rustpkg_lib_path( self.sysroot, path, self.triple); debug!("is {} in visited_dirs? {}", tlib_path.display(), @@ -243,8 +243,7 @@ pub fn rust_path() -> Vec { } cwd.pop(); } - let h = os::homedir(); - for h in h.iter() { + if let Some(h) = os::homedir() { let p = h.join(".rust"); if !env_rust_path.contains(&p) && p.exists() { env_rust_path.push(p); diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 09957f58bcc..f219bfffcb8 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -452,7 +452,7 @@ impl<'a> Context<'a> { &format!("multiple matching crates for `{}`", self.crate_name)[]); self.sess.note("candidates:"); - for lib in libraries.iter() { + for lib in &libraries { match lib.dylib { Some((ref p, _)) => { self.sess.note(&format!("path: {}", diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index ac6d2d0174c..4c0aefaf83d 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -249,7 +249,7 @@ fn parse_vec_per_param_space<'a, 'tcx, T, F>(st: &mut PState<'a, 'tcx>, F: FnMut(&mut PState<'a, 'tcx>) -> T, { let mut r = VecPerParamSpace::empty(); - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { assert_eq!(next(st), '['); while peek(st) != ']' { r.push(space, f(st)); diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 2dc334bfe95..f8081e2c309 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -97,7 +97,7 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t } ty::ty_tup(ref ts) => { mywrite!(w, "T["); - for t in ts.iter() { enc_ty(w, cx, *t); } + for t in ts { enc_ty(w, cx, *t); } mywrite!(w, "]"); } ty::ty_uniq(typ) => { mywrite!(w, "~"); enc_ty(w, cx, typ); } @@ -206,9 +206,9 @@ fn enc_vec_per_param_space<'a, 'tcx, T, F>(w: &mut SeekableMemWriter, mut op: F) where F: FnMut(&mut SeekableMemWriter, &ctxt<'a, 'tcx>, &T), { - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { mywrite!(w, "["); - for t in v.get_slice(space).iter() { + for t in v.get_slice(space) { op(w, cx, t); } mywrite!(w, "]"); @@ -337,7 +337,7 @@ pub fn enc_closure_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, fn enc_fn_sig<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, fsig: &ty::PolyFnSig<'tcx>) { mywrite!(w, "["); - for ty in fsig.0.inputs.iter() { + for ty in &fsig.0.inputs { enc_ty(w, cx, *ty); } mywrite!(w, "]"); @@ -357,7 +357,7 @@ fn enc_fn_sig<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, } pub fn enc_builtin_bounds(w: &mut SeekableMemWriter, _cx: &ctxt, bs: &ty::BuiltinBounds) { - for bound in bs.iter() { + for bound in bs { match bound { ty::BoundSend => mywrite!(w, "S"), ty::BoundSized => mywrite!(w, "Z"), @@ -383,17 +383,17 @@ pub fn enc_bounds<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, bs: &ty::ParamBounds<'tcx>) { enc_builtin_bounds(w, cx, &bs.builtin_bounds); - for &r in bs.region_bounds.iter() { + for &r in &bs.region_bounds { mywrite!(w, "R"); enc_region(w, cx, r); } - for tp in bs.trait_bounds.iter() { + for tp in &bs.trait_bounds { mywrite!(w, "I"); enc_trait_ref(w, cx, &*tp.0); } - for tp in bs.projection_bounds.iter() { + for tp in &bs.projection_bounds { mywrite!(w, "P"); enc_projection_predicate(w, cx, &tp.0); } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 6d9b9c23504..4130195ae40 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -766,7 +766,7 @@ fn encode_vec_per_param_space(rbml_w: &mut Encoder, mut f: F) where F: FnMut(&mut Encoder, &T), { - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { rbml_w.emit_from_vec(v.get_slice(space), |rbml_w, n| Ok(f(rbml_w, n))).unwrap(); } @@ -1156,14 +1156,14 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, debug!("Encoding side tables for id {}", id); - for def in tcx.def_map.borrow().get(&id).iter() { + if let Some(def) = tcx.def_map.borrow().get(&id) { rbml_w.tag(c::tag_table_def, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| (*def).encode(rbml_w).unwrap()); }) } - for &ty in tcx.node_types.borrow().get(&id).iter() { + if let Some(ty) = tcx.node_types.borrow().get(&id) { rbml_w.tag(c::tag_table_node_type, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1172,7 +1172,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &item_substs in tcx.item_substs.borrow().get(&id).iter() { + if let Some(item_substs) = tcx.item_substs.borrow().get(&id) { rbml_w.tag(c::tag_table_item_subst, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1181,7 +1181,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &fv in tcx.freevars.borrow().get(&id).iter() { + if let Some(fv) = tcx.freevars.borrow().get(&id) { rbml_w.tag(c::tag_table_freevars, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1191,7 +1191,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) }); - for freevar in fv.iter() { + for freevar in fv { rbml_w.tag(c::tag_table_upvar_capture_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1209,7 +1209,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, } let lid = ast::DefId { krate: ast::LOCAL_CRATE, node: id }; - for &type_scheme in tcx.tcache.borrow().get(&lid).iter() { + if let Some(type_scheme) = tcx.tcache.borrow().get(&lid) { rbml_w.tag(c::tag_table_tcache, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1218,7 +1218,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &type_param_def in tcx.ty_param_defs.borrow().get(&id).iter() { + if let Some(type_param_def) = tcx.ty_param_defs.borrow().get(&id) { rbml_w.tag(c::tag_table_param_defs, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1228,7 +1228,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, } let method_call = MethodCall::expr(id); - for &method in tcx.method_map.borrow().get(&method_call).iter() { + if let Some(method) = tcx.method_map.borrow().get(&method_call) { rbml_w.tag(c::tag_table_method_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1237,7 +1237,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &trait_ref in tcx.object_cast_map.borrow().get(&id).iter() { + if let Some(trait_ref) = tcx.object_cast_map.borrow().get(&id) { rbml_w.tag(c::tag_table_object_cast_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1246,11 +1246,11 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &adjustment in tcx.adjustments.borrow().get(&id).iter() { + if let Some(adjustment) = tcx.adjustments.borrow().get(&id) { match *adjustment { _ if ty::adjust_is_object(adjustment) => { let method_call = MethodCall::autoobject(id); - for &method in tcx.method_map.borrow().get(&method_call).iter() { + if let Some(method) = tcx.method_map.borrow().get(&method_call) { rbml_w.tag(c::tag_table_method_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1263,7 +1263,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, assert!(!ty::adjust_is_object(adjustment)); for autoderef in 0..adj.autoderefs { let method_call = MethodCall::autoderef(id, autoderef); - for &method in tcx.method_map.borrow().get(&method_call).iter() { + if let Some(method) = tcx.method_map.borrow().get(&method_call) { rbml_w.tag(c::tag_table_method_map, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1287,7 +1287,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &closure_type in tcx.closure_tys.borrow().get(&ast_util::local_def(id)).iter() { + if let Some(closure_type) = tcx.closure_tys.borrow().get(&ast_util::local_def(id)) { rbml_w.tag(c::tag_table_closure_tys, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { @@ -1296,11 +1296,11 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext, }) } - for &&closure_kind in tcx.closure_kinds.borrow().get(&ast_util::local_def(id)).iter() { + if let Some(closure_kind) = tcx.closure_kinds.borrow().get(&ast_util::local_def(id)) { rbml_w.tag(c::tag_table_closure_kinds, |rbml_w| { rbml_w.id(id); rbml_w.tag(c::tag_table_val, |rbml_w| { - encode_closure_kind(rbml_w, closure_kind) + encode_closure_kind(rbml_w, *closure_kind) }) }) } diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index 0a575a31ead..d39b94a202e 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -68,7 +68,7 @@ fn add_initial_dummy_node(g: &mut CFGGraph) -> CFGIndex { impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { fn block(&mut self, blk: &ast::Block, pred: CFGIndex) -> CFGIndex { let mut stmts_exit = pred; - for stmt in blk.stmts.iter() { + for stmt in &blk.stmts { stmts_exit = self.stmt(&**stmt, stmts_exit); } @@ -166,7 +166,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { self.pat(&*pats[0], pred) } else { let collect = self.add_dummy_node(&[]); - for pat in pats.iter() { + for pat in pats { let pat_exit = self.pat(&**pat, pred); self.add_contained_edge(pat_exit, collect); } @@ -325,7 +325,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let expr_exit = self.add_node(expr.id, &[]); let mut cond_exit = discr_exit; - for arm in arms.iter() { + for arm in arms { cond_exit = self.add_dummy_node(&[cond_exit]); // 2 let pats_exit = self.pats_any(&arm.pats[], cond_exit); // 3 @@ -522,7 +522,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { assert!(!self.exit_map.contains_key(&id)); self.exit_map.insert(id, node); } - for &pred in preds.iter() { + for &pred in preds { self.add_contained_edge(pred, node); } node @@ -574,7 +574,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { Some(_) => { match self.tcx.def_map.borrow().get(&expr.id) { Some(&def::DefLabel(loop_id)) => { - for l in self.loop_scopes.iter() { + for l in &self.loop_scopes { if l.loop_id == loop_id { return *l; } diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index 202020a9033..925bd5b6395 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -46,7 +46,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> { } ast::ItemEnum(ref enum_definition, _) => { self.inside_const(|v| { - for var in enum_definition.variants.iter() { + for var in &enum_definition.variants { if let Some(ref ex) = var.node.disr_expr { v.visit_expr(&**ex); } @@ -137,7 +137,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) { } ast::ExprBlock(ref block) => { // Check all statements in the block - for stmt in block.stmts.iter() { + for stmt in &block.stmts { let block_span_err = |&: span| span_err!(v.tcx.sess, span, E0016, "blocks in constants are limited to items and \ diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 6de517b2906..72551daa4e6 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -157,7 +157,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) { visit::walk_expr(cx, ex); match ex.node { ast::ExprMatch(ref scrut, ref arms, source) => { - for arm in arms.iter() { + for arm in arms { // First, check legality of move bindings. check_legality_of_move_bindings(cx, arm.guard.is_some(), @@ -285,8 +285,8 @@ fn check_arms(cx: &MatchCheckCtxt, source: ast::MatchSource) { let mut seen = Matrix(vec![]); let mut printed_if_let_err = false; - for &(ref pats, guard) in arms.iter() { - for pat in pats.iter() { + for &(ref pats, guard) in arms { + for pat in pats { let v = vec![&**pat]; match is_useful(cx, &seen, &v[], LeaveOutWitness) { @@ -979,7 +979,7 @@ fn check_fn(cx: &mut MatchCheckCtxt, visit::walk_fn(cx, kind, decl, body, sp); - for input in decl.inputs.iter() { + for input in &decl.inputs { is_refutable(cx, &*input.pat, |pat| { span_err!(cx.tcx.sess, input.pat.span, E0006, "refutable pattern in function argument: `{}` not covered", @@ -1012,7 +1012,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, let tcx = cx.tcx; let def_map = &tcx.def_map; let mut by_ref_span = None; - for pat in pats.iter() { + for pat in pats { pat_bindings(def_map, &**pat, |bm, _, span, _path| { match bm { ast::BindByRef(_) => { @@ -1039,7 +1039,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, } }; - for pat in pats.iter() { + for pat in pats { walk_pat(&**pat, |p| { if pat_is_binding(def_map, &*p) { match p.node { diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 00141903c7c..fa5d5227be5 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -104,7 +104,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt, -> Option<&'a Expr> { fn variant_expr<'a>(variants: &'a [P], id: ast::NodeId) -> Option<&'a Expr> { - for variant in variants.iter() { + for variant in variants { if variant.node.id == id { return variant.node.disr_expr.as_ref().map(|e| &**e); } diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 3e2e81077da..a06a57beb61 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -399,7 +399,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let mut orig_kills = self.kills[start.. end].to_vec(); let mut changed = false; - for &node_id in edge.data.exiting_scopes.iter() { + for &node_id in &edge.data.exiting_scopes { let opt_cfg_idx = self.nodeid_to_index.get(&node_id).map(|&i|i); match opt_cfg_idx { Some(cfg_idx) => { @@ -550,7 +550,7 @@ fn bits_to_string(words: &[uint]) -> String { // Note: this is a little endian printout of bytes. - for &word in words.iter() { + for &word in words { let mut v = word; for _ in 0..uint::BYTES { result.push(sep); diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 3db931002d2..6bad7f59441 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -173,7 +173,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { } }; let fields = ty::lookup_struct_fields(self.tcx, id); - for pat in pats.iter() { + for pat in pats { let field_id = fields.iter() .find(|field| field.name == pat.node.ident.name).unwrap().id; self.live_symbols.insert(field_id.node); @@ -356,7 +356,7 @@ impl<'v> Visitor<'v> for LifeSeeder { self.worklist.extend(enum_def.variants.iter().map(|variant| variant.node.id)); } ast::ItemImpl(_, _, _, Some(ref _trait_ref), _, ref impl_items) => { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { self.worklist.push(method.id); @@ -397,10 +397,10 @@ fn create_and_seed_worklist(tcx: &ty::ctxt, // depending on whether a crate is built as bin or lib, and we want // the warning to be consistent, we also seed the worklist with // exported symbols. - for id in exported_items.iter() { + for id in exported_items { worklist.push(*id); } - for id in reachable_symbols.iter() { + for id in reachable_symbols { worklist.push(*id); } @@ -499,8 +499,8 @@ impl<'a, 'tcx> DeadVisitor<'a, 'tcx> { match self.tcx.inherent_impls.borrow().get(&local_def(id)) { None => (), Some(impl_list) => { - for impl_did in impl_list.iter() { - for item_did in (*impl_items)[*impl_did].iter() { + for impl_did in &**impl_list { + for item_did in &(*impl_items)[*impl_did] { if self.live_symbols.contains(&item_did.def_id() .node) { return true; @@ -536,7 +536,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for DeadVisitor<'a, 'tcx> { } else { match item.node { ast::ItemEnum(ref enum_def, _) => { - for variant in enum_def.variants.iter() { + for variant in &enum_def.variants { if self.should_warn_about_variant(&variant.node) { self.warn_dead_code(variant.node.id, variant.span, variant.node.name, "variant"); diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 16b7d6134c3..6d35a82d153 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -85,7 +85,7 @@ pub type Dependencies = FnvHashMap; pub fn calculate(tcx: &ty::ctxt) { let mut fmts = tcx.dependency_formats.borrow_mut(); - for &ty in tcx.sess.crate_types.borrow().iter() { + for &ty in &*tcx.sess.crate_types.borrow() { fmts.insert(ty, calculate_type(&tcx.sess, ty)); } tcx.sess.abort_if_errors(); @@ -148,7 +148,7 @@ fn calculate_type(sess: &session::Session, debug!("adding dylib: {}", data.name); add_library(sess, cnum, cstore::RequireDynamic, &mut formats); let deps = csearch::get_dylib_dependency_formats(&sess.cstore, cnum); - for &(depnum, style) in deps.iter() { + for &(depnum, style) in &deps { debug!("adding {:?}: {}", style, sess.cstore.get_crate_data(depnum).name.clone()); add_library(sess, depnum, style, &mut formats); diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index 417e5336249..24073848edf 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -139,7 +139,7 @@ fn configure_main(this: &mut EntryContext) { but you have one or more functions named 'main' that are not \ defined at the crate level. Either move the definition or \ attach the `#[main]` attribute to override this behavior."); - for &(_, span) in this.non_main_fns.iter() { + for &(_, span) in &this.non_main_fns { this.session.span_note(span, "here is a function named 'main'"); } this.session.abort_if_errors(); diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 4a0bed57433..44a816eb2f8 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -342,7 +342,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fn walk_arg_patterns(&mut self, decl: &ast::FnDecl, body: &ast::Block) { - for arg in decl.inputs.iter() { + for arg in &decl.inputs { let arg_ty = return_if_err!(self.typer.node_ty(arg.pat.id)); let fn_body_scope = region::CodeExtent::from_node_id(body.id); @@ -372,7 +372,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } fn consume_exprs(&mut self, exprs: &Vec>) { - for expr in exprs.iter() { + for expr in exprs { self.consume_expr(&**expr); } } @@ -476,7 +476,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { ast::ExprIf(ref cond_expr, ref then_blk, ref opt_else_expr) => { self.consume_expr(&**cond_expr); self.walk_block(&**then_blk); - for else_expr in opt_else_expr.iter() { + if let Some(ref else_expr) = *opt_else_expr { self.consume_expr(&**else_expr); } } @@ -490,7 +490,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { self.borrow_expr(&**discr, ty::ReEmpty, ty::ImmBorrow, MatchDiscriminant); // treatment of the discriminant is handled while walking the arms. - for arm in arms.iter() { + for arm in arms { let mode = self.arm_move_mode(discr_cmt.clone(), arm); let mode = mode.match_mode(); self.walk_arm(discr_cmt.clone(), arm, mode); @@ -511,11 +511,11 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } ast::ExprInlineAsm(ref ia) => { - for &(_, ref input) in ia.inputs.iter() { + for &(_, ref input) in &ia.inputs { self.consume_expr(&**input); } - for &(_, ref output, is_rw) in ia.outputs.iter() { + for &(_, ref output, is_rw) in &ia.outputs { self.mutate_expr(expr, &**output, if is_rw { WriteAndRead } else { JustWrite }); } @@ -572,7 +572,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } ast::ExprRet(ref opt_expr) => { - for expr in opt_expr.iter() { + if let Some(ref expr) = *opt_expr { self.consume_expr(&**expr); } } @@ -715,11 +715,11 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fn walk_block(&mut self, blk: &ast::Block) { debug!("walk_block(blk.id={})", blk.id); - for stmt in blk.stmts.iter() { + for stmt in &blk.stmts { self.walk_stmt(&**stmt); } - for tail_expr in blk.expr.iter() { + if let Some(ref tail_expr) = blk.expr { self.consume_expr(&**tail_expr); } } @@ -729,7 +729,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fields: &Vec, opt_with: &Option>) { // Consume the expressions supplying values for each field. - for field in fields.iter() { + for field in fields { self.consume_expr(&*field.expr); } @@ -762,7 +762,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { }; // Consume those fields of the with expression that are needed. - for with_field in with_fields.iter() { + for with_field in &with_fields { if !contains_field_named(with_field, fields) { let cmt_field = self.mc.cat_field(&*with_expr, with_cmt.clone(), @@ -908,7 +908,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { match pass_args { PassArgs::ByValue => { self.consume_expr(receiver); - for &arg in rhs.iter() { + for &arg in &rhs { self.consume_expr(arg); } @@ -926,7 +926,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { let r = ty::ReScope(region::CodeExtent::from_node_id(expr.id)); let bk = ty::ImmBorrow; - for &arg in rhs.iter() { + for &arg in &rhs { self.borrow_expr(arg, r, bk, OverloadedOperator); } return true; @@ -934,18 +934,18 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { fn arm_move_mode(&mut self, discr_cmt: mc::cmt<'tcx>, arm: &ast::Arm) -> TrackMatchMode { let mut mode = Unknown; - for pat in arm.pats.iter() { + for pat in &arm.pats { self.determine_pat_move_mode(discr_cmt.clone(), &**pat, &mut mode); } mode } fn walk_arm(&mut self, discr_cmt: mc::cmt<'tcx>, arm: &ast::Arm, mode: MatchMode) { - for pat in arm.pats.iter() { + for pat in &arm.pats { self.walk_pat(discr_cmt.clone(), &**pat, mode); } - for guard in arm.guard.iter() { + if let Some(ref guard) = arm.guard { self.consume_expr(&**guard); } @@ -1195,7 +1195,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { debug!("walk_captures({})", closure_expr.repr(self.tcx())); ty::with_freevars(self.tcx(), closure_expr.id, |freevars| { - for freevar in freevars.iter() { + for freevar in freevars { let id_var = freevar.def.def_id().node; let upvar_id = ty::UpvarId { var_id: id_var, closure_expr_id: closure_expr.id }; diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs index 8b29ef9b880..8cb2774f7df 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -116,7 +116,7 @@ pub trait Combine<'tcx> : Sized { { let mut substs = subst::Substs::empty(); - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { let a_tps = a_subst.types.get_slice(space); let b_tps = b_subst.types.get_slice(space); let tps = try!(self.tps(space, a_tps, b_tps)); @@ -129,7 +129,7 @@ pub trait Combine<'tcx> : Sized { } (&NonerasedRegions(ref a), &NonerasedRegions(ref b)) => { - for &space in subst::ParamSpace::all().iter() { + for &space in &subst::ParamSpace::all() { let a_regions = a.get_slice(space); let b_regions = b.get_slice(space); @@ -139,7 +139,7 @@ pub trait Combine<'tcx> : Sized { variances.regions.get_slice(space) } None => { - for _ in a_regions.iter() { + for _ in a_regions { invariance.push(ty::Invariant); } &invariance[] diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index f0174c5b0c6..2efc07a4023 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -170,7 +170,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { errors: &Vec>) { let p_errors = self.process_errors(errors); let errors = if p_errors.is_empty() { errors } else { &p_errors }; - for error in errors.iter() { + for error in errors { match error.clone() { ConcreteFailure(origin, sub, sup) => { self.report_concrete_failure(origin, sub, sup); @@ -222,7 +222,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { let mut trace_origins = Vec::new(); let mut same_regions = Vec::new(); let mut processed_errors = Vec::new(); - for error in errors.iter() { + for error in errors { match error.clone() { ConcreteFailure(origin, sub, sup) => { debug!("processing ConcreteFailure"); @@ -257,7 +257,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { } if !same_regions.is_empty() { let common_scope_id = same_regions[0].scope_id; - for sr in same_regions.iter() { + for sr in &same_regions { // Since ProcessedErrors is used to reconstruct the function // declaration, we want to make sure that they are, in fact, // from the same scope @@ -796,11 +796,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { var_origins: &[RegionVariableOrigin], trace_origins: &[(TypeTrace<'tcx>, ty::type_err<'tcx>)], same_regions: &[SameRegions]) { - for vo in var_origins.iter() { + for vo in var_origins { self.report_inference_failure(vo.clone()); } self.give_suggestion(same_regions); - for &(ref trace, terr) in trace_origins.iter() { + for &(ref trace, terr) in trace_origins { self.report_type_error(trace.clone(), &terr); } } @@ -916,7 +916,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { let mut ty_params = self.generics.ty_params.clone(); let where_clause = self.generics.where_clause.clone(); let mut kept_lifetimes = HashSet::new(); - for sr in self.same_regions.iter() { + for sr in self.same_regions { self.cur_anon.set(0); self.offset_cur_anon(); let (anon_nums, region_names) = @@ -958,7 +958,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { // vector of string and then sort them. However, it makes the // choice of lifetime name deterministic and thus easier to test. let mut names = Vec::new(); - for rn in region_names.iter() { + for rn in region_names { let lt_name = token::get_name(*rn).get().to_string(); names.push(lt_name); } @@ -973,7 +973,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { -> (HashSet, HashSet) { let mut anon_nums = HashSet::new(); let mut region_names = HashSet::new(); - for br in same_regions.regions.iter() { + for br in &same_regions.regions { match *br { ty::BrAnon(i) => { anon_nums.insert(i); @@ -989,8 +989,8 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { fn extract_all_region_names(&self) -> HashSet { let mut all_region_names = HashSet::new(); - for sr in self.same_regions.iter() { - for br in sr.regions.iter() { + for sr in self.same_regions { + for br in &sr.regions { match *br { ty::BrNamed(_, name) => { all_region_names.insert(name); @@ -1123,11 +1123,11 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { where_clause: ast::WhereClause) -> ast::Generics { let mut lifetimes = Vec::new(); - for lt in add.iter() { + for lt in add { lifetimes.push(ast::LifetimeDef { lifetime: *lt, bounds: Vec::new() }); } - for lt in generics.lifetimes.iter() { + for lt in &generics.lifetimes { if keep.contains(<.lifetime.name) || !remove.contains(<.lifetime.name) { lifetimes.push((*lt).clone()); @@ -1147,7 +1147,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> { region_names: &HashSet) -> Vec { let mut new_inputs = Vec::new(); - for arg in inputs.iter() { + for arg in inputs { let new_ty = self.rebuild_arg_ty_or_output(&*arg.ty, lifetime, anon_nums, region_names); let possibly_new_arg = ast::Arg { @@ -1729,7 +1729,7 @@ struct LifeGiver { impl LifeGiver { fn with_taken(taken: &[ast::LifetimeDef]) -> LifeGiver { let mut taken_ = HashSet::new(); - for lt in taken.iter() { + for lt in taken { let lt_name = token::get_name(lt.lifetime.name).get().to_string(); taken_.insert(lt_name); } diff --git a/src/librustc/middle/infer/higher_ranked/mod.rs b/src/librustc/middle/infer/higher_ranked/mod.rs index 0df84323ae5..e4eecd919c8 100644 --- a/src/librustc/middle/infer/higher_ranked/mod.rs +++ b/src/librustc/middle/infer/higher_ranked/mod.rs @@ -176,7 +176,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C // in both A and B. Replace the variable with the "first" // bound region from A that we find it to be associated // with. - for (a_br, a_r) in a_map.iter() { + for (a_br, a_r) in a_map { if tainted.iter().any(|x| x == a_r) { debug!("generalize_region(r0={:?}): \ replacing with {:?}, tainted={:?}", @@ -258,7 +258,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C let mut a_r = None; let mut b_r = None; let mut only_new_vars = true; - for r in tainted.iter() { + for r in &tainted { if is_var_in_set(a_vars, *r) { if a_r.is_some() { return fresh_bound_variable(infcx, debruijn); @@ -315,7 +315,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C a_map: &FnvHashMap, r: ty::Region) -> ty::Region { - for (a_br, a_r) in a_map.iter() { + for (a_br, a_r) in a_map { if *a_r == r { return ty::ReLateBound(ty::DebruijnIndex::new(1), *a_br); } @@ -497,9 +497,9 @@ pub fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>, skol_map.repr(infcx.tcx)); let new_vars = infcx.region_vars_confined_to_snapshot(snapshot); - for (&skol_br, &skol) in skol_map.iter() { + for (&skol_br, &skol) in skol_map { let tainted = infcx.tainted_regions(snapshot, skol); - for &tainted_region in tainted.iter() { + for &tainted_region in &tainted { // Each skolemized should only be relatable to itself // or new variables: match tainted_region { diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 1665966a5e5..f8dae3e92da 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -998,8 +998,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty), error_str)[]); - for err in err.iter() { - ty::note_and_explain_type_err(self.tcx, *err) + if let Some(err) = err { + ty::note_and_explain_type_err(self.tcx, err) } } } diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 8952452cb4b..919ea0a2520 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -667,7 +667,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { a, b); } VerifyGenericBound(_, _, a, ref bs) => { - for &b in bs.iter() { + for &b in bs { consider_adding_bidirectional_edges( &mut result_set, r, a, b); @@ -1200,7 +1200,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { errors: &mut Vec>) { let mut reg_reg_dups = FnvHashSet(); - for verify in self.verifys.borrow().iter() { + for verify in &*self.verifys.borrow() { match *verify { VerifyRegSubReg(ref origin, sub, sup) => { if self.is_subregion_of(sub, sup) { @@ -1333,7 +1333,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { } let dummy_idx = graph.add_node(()); - for (constraint, _) in constraints.iter() { + for (constraint, _) in &*constraints { match *constraint { ConstrainVarSubVar(a_id, b_id) => { graph.add_edge(NodeIndex(a_id.index as uint), @@ -1393,8 +1393,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { lower_bounds.sort_by(|a, b| { free_regions_first(a, b) }); upper_bounds.sort_by(|a, b| { free_regions_first(a, b) }); - for lower_bound in lower_bounds.iter() { - for upper_bound in upper_bounds.iter() { + for lower_bound in &lower_bounds { + for upper_bound in &upper_bounds { if !self.is_subregion_of(lower_bound.region, upper_bound.region) { errors.push(SubSupConflict( @@ -1435,8 +1435,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { return; } - for upper_bound_1 in upper_bounds.iter() { - for upper_bound_2 in upper_bounds.iter() { + for upper_bound_1 in &upper_bounds { + for upper_bound_2 in &upper_bounds { match self.glb_concrete_regions(upper_bound_1.region, upper_bound_2.region) { Ok(_) => {} @@ -1554,7 +1554,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { changed = false; iteration += 1; debug!("---- {} Iteration {}{}", "#", tag, iteration); - for (constraint, _) in self.constraints.borrow().iter() { + for (constraint, _) in &*self.constraints.borrow() { let edge_changed = body(constraint); if edge_changed { debug!("Updated due to constraint {}", diff --git a/src/librustc/middle/infer/type_variable.rs b/src/librustc/middle/infer/type_variable.rs index 65061a29b78..9b8a4a84412 100644 --- a/src/librustc/middle/infer/type_variable.rs +++ b/src/librustc/middle/infer/type_variable.rs @@ -105,7 +105,7 @@ impl<'tcx> TypeVariableTable<'tcx> { already instantiated") }; - for &(dir, vid) in relations.iter() { + for &(dir, vid) in &relations { stack.push((ty, dir, vid)); } @@ -165,7 +165,7 @@ impl<'tcx> TypeVariableTable<'tcx> { let mut escaping_types = Vec::new(); let actions_since_snapshot = self.values.actions_since_snapshot(&s.snapshot); debug!("actions_since_snapshot.len() = {}", actions_since_snapshot.len()); - for action in actions_since_snapshot.iter() { + for action in actions_since_snapshot { match *action { sv::UndoLog::NewElem(index) => { // if any new variables were created during the diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 29a615f2b40..d9b90c1935a 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -120,7 +120,7 @@ impl LanguageItems { (self.fn_once_trait(), ty::FnOnceClosureKind), ]; - for &(opt_def_id, kind) in def_id_kinds.iter() { + for &(opt_def_id, kind) in &def_id_kinds { if Some(id) == opt_def_id { return Some(kind); } @@ -217,7 +217,7 @@ impl<'a> LanguageItemCollector<'a> { } pub fn extract(attrs: &[ast::Attribute]) -> Option { - for attribute in attrs.iter() { + for attribute in attrs { match attribute.value_str() { Some(ref value) if attribute.check_name("lang") => { return Some(value.clone()); diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index cb0157fed87..e40e04bdee8 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -378,7 +378,7 @@ fn visit_fn(ir: &mut IrMaps, debug!("creating fn_maps: {:?}", &fn_maps as *const IrMaps); - for arg in decl.inputs.iter() { + for arg in &decl.inputs { pat_util::pat_bindings(&ir.tcx.def_map, &*arg.pat, |_bm, arg_id, _x, path1| { @@ -427,7 +427,7 @@ fn visit_local(ir: &mut IrMaps, local: &ast::Local) { } fn visit_arm(ir: &mut IrMaps, arm: &ast::Arm) { - for pat in arm.pats.iter() { + for pat in &arm.pats { pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| { debug!("adding local variable {} from match with bm {:?}", p_id, bm); @@ -464,7 +464,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) { // construction site. let mut call_caps = Vec::new(); ty::with_freevars(ir.tcx, expr.id, |freevars| { - for fv in freevars.iter() { + for fv in freevars { if let DefLocal(rv) = fv.def { let fv_ln = ir.add_live_node(FreeVarNode(fv.span)); call_caps.push(CaptureInfo {ln: fv_ln, @@ -1049,7 +1049,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { let ln = self.live_node(expr.id, expr.span); self.init_empty(ln, succ); let mut first_merge = true; - for arm in arms.iter() { + for arm in arms { let body_succ = self.propagate_through_expr(&*arm.body, succ); let guard_succ = @@ -1445,12 +1445,12 @@ fn check_expr(this: &mut Liveness, expr: &Expr) { } ast::ExprInlineAsm(ref ia) => { - for &(_, ref input) in ia.inputs.iter() { + for &(_, ref input) in &ia.inputs { this.visit_expr(&**input); } // Output operands must be lvalues - for &(_, ref out, _) in ia.outputs.iter() { + for &(_, ref out, _) in &ia.outputs { this.check_lvalue(&**out); this.visit_expr(&**out); } @@ -1590,7 +1590,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { } fn warn_about_unused_args(&self, decl: &ast::FnDecl, entry_ln: LiveNode) { - for arg in decl.inputs.iter() { + for arg in &decl.inputs { pat_util::pat_bindings(&self.ir.tcx.def_map, &*arg.pat, |_bm, p_id, sp, path1| { @@ -1620,7 +1620,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { -> bool { if !self.used_on_entry(ln, var) { let r = self.should_warn(var); - for name in r.iter() { + if let Some(name) = r { // annoying: for parameters in funcs like `fn(x: int) // {ret}`, there is only one node, so asking about @@ -1634,10 +1634,10 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { if is_assigned { self.ir.tcx.sess.add_lint(lint::builtin::UNUSED_VARIABLES, id, sp, format!("variable `{}` is assigned to, but never used", - *name)); + name)); } else { self.ir.tcx.sess.add_lint(lint::builtin::UNUSED_VARIABLES, id, sp, - format!("unused variable: `{}`", *name)); + format!("unused variable: `{}`", name)); } } true @@ -1653,9 +1653,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { var: Variable) { if self.live_on_exit(ln, var).is_none() { let r = self.should_warn(var); - for name in r.iter() { + if let Some(name) = r { self.ir.tcx.sess.add_lint(lint::builtin::UNUSED_ASSIGNMENTS, id, sp, - format!("value assigned to `{}` is never read", *name)); + format!("value assigned to `{}` is never read", name)); } } } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 93daaa72843..1ae483be269 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -1208,7 +1208,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { } } Some(&def::DefConst(..)) => { - for subpat in subpats.iter() { + for subpat in subpats { try!(self.cat_pattern_(cmt.clone(), &**subpat, op)); } } @@ -1230,7 +1230,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { ast::PatStruct(_, ref field_pats, _) => { // {f1: p1, ..., fN: pN} - for fp in field_pats.iter() { + for fp in field_pats { let field_ty = try!(self.pat_ty(&*fp.node.pat)); // see (*2) let cmt_field = self.cat_field(pat, cmt.clone(), fp.node.ident.name, field_ty); try!(self.cat_pattern_(cmt_field, &*fp.node.pat, op)); @@ -1259,15 +1259,15 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { ast::PatVec(ref before, ref slice, ref after) => { let elt_cmt = try!(self.cat_index(pat, try!(self.deref_vec(pat, cmt)))); - for before_pat in before.iter() { + for before_pat in before { try!(self.cat_pattern_(elt_cmt.clone(), &**before_pat, op)); } - for slice_pat in slice.iter() { + if let Some(ref slice_pat) = *slice { let slice_ty = try!(self.pat_ty(&**slice_pat)); let slice_cmt = self.cat_rvalue_node(pat.id(), pat.span(), slice_ty); try!(self.cat_pattern_(slice_cmt, &**slice_pat, op)); } - for after_pat in after.iter() { + for after_pat in after { try!(self.cat_pattern_(elt_cmt.clone(), &**after_pat, op)); } } diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index b93cde4bf64..0af226de251 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -353,7 +353,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { // this properly would result in the necessity of computing *type* // reachability, which might result in a compile time loss. fn mark_destructors_reachable(&mut self) { - for (_, destructor_def_id) in self.tcx.destructor_for_type.borrow().iter() { + for (_, destructor_def_id) in &*self.tcx.destructor_for_type.borrow() { if destructor_def_id.krate == ast::LOCAL_CRATE { self.reachable_symbols.insert(destructor_def_id.node); } @@ -371,7 +371,7 @@ pub fn find_reachable(tcx: &ty::ctxt, // other crates link to us, they're going to expect to be able to // use the lang items, so we need to be sure to mark them as // exported. - for id in exported_items.iter() { + for id in exported_items { reachable_context.worklist.push(*id); } for (_, item) in tcx.lang_items.items() { diff --git a/src/librustc/middle/recursion_limit.rs b/src/librustc/middle/recursion_limit.rs index da83833fba3..7dcd358165c 100644 --- a/src/librustc/middle/recursion_limit.rs +++ b/src/librustc/middle/recursion_limit.rs @@ -20,7 +20,7 @@ use syntax::ast; use syntax::attr::AttrMetaMethods; pub fn update_recursion_limit(sess: &Session, krate: &ast::Crate) { - for attr in krate.attrs.iter() { + for attr in &krate.attrs { if !attr.check_name("recursion_limit") { continue; } diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 3f8b7e5a7b3..87d386d94c9 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -888,14 +888,14 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) { record_rvalue_scope(visitor, &**subexpr, blk_id); } ast::ExprStruct(_, ref fields, _) => { - for field in fields.iter() { + for field in fields { record_rvalue_scope_if_borrow_expr( visitor, &*field.expr, blk_id); } } ast::ExprVec(ref subexprs) | ast::ExprTup(ref subexprs) => { - for subexpr in subexprs.iter() { + for subexpr in subexprs { record_rvalue_scope_if_borrow_expr( visitor, &**subexpr, blk_id); } diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 9433f7b0a70..365355c4a2a 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -187,14 +187,14 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> { } fn visit_generics(&mut self, generics: &ast::Generics) { - for ty_param in generics.ty_params.iter() { + for ty_param in &*generics.ty_params { visit::walk_ty_param_bounds_helper(self, &ty_param.bounds); match ty_param.default { Some(ref ty) => self.visit_ty(&**ty), None => {} } } - for predicate in generics.where_clause.predicates.iter() { + for predicate in &generics.where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ ref bounded_ty, ref bounds, @@ -207,7 +207,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> { .. }) => { self.visit_lifetime_ref(lifetime); - for bound in bounds.iter() { + for bound in bounds { self.visit_lifetime_ref(bound); } } @@ -229,7 +229,7 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> { self.with(LateScope(&trait_ref.bound_lifetimes, self.scope), |old_scope, this| { this.check_lifetime_defs(old_scope, &trait_ref.bound_lifetimes); - for lifetime in trait_ref.bound_lifetimes.iter() { + for lifetime in &trait_ref.bound_lifetimes { this.visit_lifetime_def(lifetime); } this.visit_trait_ref(&trait_ref.trait_ref) @@ -408,7 +408,7 @@ impl<'a> LifetimeContext<'a> { let lifetime_i = &lifetimes[i]; let special_idents = [special_idents::static_lifetime]; - for lifetime in lifetimes.iter() { + for lifetime in lifetimes { if special_idents.iter().any(|&i| i.name == lifetime.lifetime.name) { span_err!(self.sess, lifetime.lifetime.span, E0262, "illegal lifetime parameter name: `{}`", @@ -431,7 +431,7 @@ impl<'a> LifetimeContext<'a> { // It is a soft error to shadow a lifetime within a parent scope. self.check_lifetime_def_for_shadowing(old_scope, &lifetime_i.lifetime); - for bound in lifetime_i.bounds.iter() { + for bound in &lifetime_i.bounds { self.resolve_lifetime_ref(bound); } } @@ -535,10 +535,10 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec { let mut collector = FreeLifetimeCollector { early_bound: &mut early_bound, late_bound: &mut late_bound }; - for ty_param in generics.ty_params.iter() { + for ty_param in &*generics.ty_params { visit::walk_ty_param_bounds_helper(&mut collector, &ty_param.bounds); } - for predicate in generics.where_clause.predicates.iter() { + for predicate in &generics.where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{ref bounds, ref bounded_ty, @@ -551,7 +551,7 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec { ..}) => { collector.visit_lifetime_ref(lifetime); - for bound in bounds.iter() { + for bound in bounds { collector.visit_lifetime_ref(bound); } } @@ -562,11 +562,11 @@ fn early_bound_lifetime_names(generics: &ast::Generics) -> Vec { // Any lifetime that either has a bound or is referenced by a // bound is early. - for lifetime_def in generics.lifetimes.iter() { + for lifetime_def in &generics.lifetimes { if !lifetime_def.bounds.is_empty() { shuffle(&mut early_bound, &mut late_bound, lifetime_def.lifetime.name); - for bound in lifetime_def.bounds.iter() { + for bound in &lifetime_def.bounds { shuffle(&mut early_bound, &mut late_bound, bound.name); } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 7b5af0ab1aa..5028a1322ca 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -148,7 +148,7 @@ impl Index { /// Construct the stability index for a crate being compiled. pub fn build(sess: &Session, krate: &Crate) -> Index { let mut staged_api = false; - for attr in krate.attrs.iter() { + for attr in &krate.attrs { if attr.name().get() == "staged_api" { match attr.node.value.node { ast::MetaWord(_) => { @@ -273,7 +273,7 @@ pub fn check_item(tcx: &ty::ctxt, item: &ast::Item, maybe_do_stability_check(tcx, id, item.span, cb); } ast::ItemTrait(_, _, ref supertraits, _) => { - for t in supertraits.iter() { + for t in &**supertraits { if let ast::TraitTyParamBound(ref t, _) = *t { let id = ty::trait_ref_to_def_id(tcx, &t.trait_ref); maybe_do_stability_check(tcx, id, t.trait_ref.path.span, cb); @@ -410,11 +410,11 @@ pub fn check_unused_features(sess: &Session, let mut active_lib_features: FnvHashMap = lib_features.clone().into_iter().collect(); - for used_feature in used_lib_features.iter() { + for used_feature in used_lib_features { active_lib_features.remove(used_feature); } - for (_, &span) in active_lib_features.iter() { + for (_, &span) in &active_lib_features { sess.add_lint(lint::builtin::UNUSED_FEATURES, ast::CRATE_NODE_ID, span, diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs index cbf65080a86..2cf8a83db9b 100644 --- a/src/librustc/middle/subst.rs +++ b/src/librustc/middle/subst.rs @@ -241,7 +241,7 @@ pub struct SeparateVecsPerParamSpace { impl fmt::Debug for VecPerParamSpace { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "VecPerParamSpace {{")); - for space in ParamSpace::all().iter() { + for space in &ParamSpace::all() { try!(write!(fmt, "{:?}: {:?}, ", *space, self.get_slice(*space))); } try!(write!(fmt, "}}")); diff --git a/src/librustc/middle/traits/doc.rs b/src/librustc/middle/traits/doc.rs index 4a01e964fd2..8ce4e38896e 100644 --- a/src/librustc/middle/traits/doc.rs +++ b/src/librustc/middle/traits/doc.rs @@ -35,7 +35,7 @@ provide an impl. To see what I mean, consider the body of `clone_slice`: fn clone_slice(x: &[T]) -> Vec { let mut v = Vec::new(); - for e in x.iter() { + for e in &x { v.push((*e).clone()); // (*) } } diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs index 5e7168b6735..b8886fa65ba 100644 --- a/src/librustc/middle/traits/error_reporting.rs +++ b/src/librustc/middle/traits/error_reporting.rs @@ -28,7 +28,7 @@ use util::ppaux::{Repr, UserString}; pub fn report_fulfillment_errors<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, errors: &Vec>) { - for error in errors.iter() { + for error in errors { report_fulfillment_error(infcx, error); } } @@ -68,7 +68,7 @@ fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, span: Span) -> Option { let def_id = trait_ref.def_id; let mut report = None; - for item in ty::get_attrs(infcx.tcx, def_id).iter() { + for item in &*ty::get_attrs(infcx.tcx, def_id) { if item.check_name("rustc_on_unimplemented") { let err_sp = if item.meta().span == DUMMY_SP { span diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs index 530190ddfc1..c88e58266a0 100644 --- a/src/librustc/middle/traits/object_safety.rs +++ b/src/librustc/middle/traits/object_safety.rs @@ -176,7 +176,7 @@ fn object_safety_violations_for_method<'tcx>(tcx: &ty::ctxt<'tcx>, // The `Self` type is erased, so it should not appear in list of // arguments or return type apart from the receiver. let ref sig = method.fty.sig; - for &input_ty in sig.0.inputs[1..].iter() { + for &input_ty in &sig.0.inputs[1..] { if contains_illegal_self_type_reference(tcx, trait_def_id, input_ty) { return Some(MethodViolationCode::ReferencesSelf); } diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index ce66f4d5b35..3ede6bbb965 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -802,7 +802,7 @@ fn confirm_impl_candidate<'cx,'tcx>( let impl_items = &impl_items_map[impl_vtable.impl_def_id]; let mut impl_ty = None; - for impl_item in impl_items.iter() { + for impl_item in impl_items { let assoc_type = match impl_or_trait_items_map[impl_item.def_id()] { ty::TypeTraitItem(ref assoc_type) => assoc_type.clone(), ty::MethodTraitItem(..) => { continue; } diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index 106c07baaa7..91eec4e4c45 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -1089,7 +1089,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { debug!("assemble_candidates_from_impls(self_ty={})", self_ty.repr(self.tcx())); let all_impls = self.all_impls(obligation.predicate.def_id()); - for &impl_def_id in all_impls.iter() { + for &impl_def_id in &all_impls { self.infcx.probe(|snapshot| { let (skol_obligation_trait_pred, skol_map) = self.infcx().skolemize_late_bound_regions(&obligation.predicate, snapshot); diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs index edeca83d569..45ce692bb07 100644 --- a/src/librustc/middle/traits/util.rs +++ b/src/librustc/middle/traits/util.rs @@ -343,7 +343,7 @@ pub fn get_vtable_index_of_object_method<'tcx>(tcx: &ty::ctxt<'tcx>, } let trait_items = ty::trait_items(tcx, bound_ref.def_id()); - for trait_item in trait_items.iter() { + for trait_item in &**trait_items { match *trait_item { ty::MethodTraitItem(_) => method_count += 1, ty::TypeTraitItem(_) => {} diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 1544db8ce4a..ec331d8f4b9 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -872,7 +872,7 @@ macro_rules! sty_debug_print { $(let mut $variant = total;)* - for (_, t) in tcx.interner.borrow().iter() { + for (_, t) in &*tcx.interner.borrow() { let variant = match t.sty { ty::ty_bool | ty::ty_char | ty::ty_int(..) | ty::ty_uint(..) | ty::ty_float(..) | ty::ty_str => continue, @@ -2579,7 +2579,7 @@ impl FlagComputation { &ty_trait(box TyTrait { ref principal, ref bounds }) => { let mut computation = FlagComputation::new(); computation.add_substs(principal.0.substs); - for projection_bound in bounds.projection_bounds.iter() { + for projection_bound in &bounds.projection_bounds { let mut proj_computation = FlagComputation::new(); proj_computation.add_projection_predicate(&projection_bound.0); computation.add_bound_computation(&proj_computation); @@ -2618,7 +2618,7 @@ impl FlagComputation { } fn add_tys(&mut self, tys: &[Ty]) { - for &ty in tys.iter() { + for &ty in tys { self.add_ty(ty); } } @@ -3530,7 +3530,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { // make no assumptions (other than that it cannot have an // in-scope type parameter within, which makes no sense). let mut tc = TC::All - TC::InteriorParam; - for bound in bounds.builtin_bounds.iter() { + for bound in &bounds.builtin_bounds { tc = tc - match bound { BoundSync | BoundSend | BoundCopy => TC::None, BoundSized => TC::Nonsized, @@ -4644,7 +4644,7 @@ pub fn stmt_node_id(s: &ast::Stmt) -> ast::NodeId { pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field]) -> uint { let mut i = 0; - for f in fields.iter() { if f.name == name { return i; } i += 1; } + for f in fields { if f.name == name { return i; } i += 1; } tcx.sess.bug(&format!( "no field named `{}` found in the list of fields `{:?}`", token::get_name(name), @@ -5468,25 +5468,25 @@ pub fn predicates<'tcx>( { let mut vec = Vec::new(); - for builtin_bound in bounds.builtin_bounds.iter() { + for builtin_bound in &bounds.builtin_bounds { match traits::trait_ref_for_builtin_bound(tcx, builtin_bound, param_ty) { Ok(trait_ref) => { vec.push(trait_ref.as_predicate()); } Err(ErrorReported) => { } } } - for ®ion_bound in bounds.region_bounds.iter() { + for ®ion_bound in &bounds.region_bounds { // account for the binder being introduced below; no need to shift `param_ty` // because, at present at least, it can only refer to early-bound regions let region_bound = ty_fold::shift_region(region_bound, 1); vec.push(ty::Binder(ty::OutlivesPredicate(param_ty, region_bound)).as_predicate()); } - for bound_trait_ref in bounds.trait_bounds.iter() { + for bound_trait_ref in &bounds.trait_bounds { vec.push(bound_trait_ref.as_predicate()); } - for projection in bounds.projection_bounds.iter() { + for projection in &bounds.projection_bounds { vec.push(projection.as_predicate()); } @@ -5931,17 +5931,17 @@ pub fn populate_implementations_for_type_if_necessary(tcx: &ctxt, // Record the trait->implementation mappings, if applicable. let associated_traits = csearch::get_impl_trait(tcx, impl_def_id); - for trait_ref in associated_traits.iter() { + if let Some(ref trait_ref) = associated_traits { record_trait_implementation(tcx, trait_ref.def_id, impl_def_id); } // For any methods that use a default implementation, add them to // the map. This is a bit unfortunate. - for impl_item_def_id in impl_items.iter() { + for impl_item_def_id in &impl_items { let method_def_id = impl_item_def_id.def_id(); match impl_or_trait_item(tcx, method_def_id) { MethodTraitItem(method) => { - for &source in method.provided_source.iter() { + if let Some(source) = method.provided_source { tcx.provided_method_sources .borrow_mut() .insert(method_def_id, source); @@ -5985,11 +5985,11 @@ pub fn populate_implementations_for_trait_if_necessary( // For any methods that use a default implementation, add them to // the map. This is a bit unfortunate. - for impl_item_def_id in impl_items.iter() { + for impl_item_def_id in &impl_items { let method_def_id = impl_item_def_id.def_id(); match impl_or_trait_item(tcx, method_def_id) { MethodTraitItem(method) => { - for &source in method.provided_source.iter() { + if let Some(source) = method.provided_source { tcx.provided_method_sources .borrow_mut() .insert(method_def_id, source); @@ -6121,7 +6121,7 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - }; let fn_sig = |&: state: &mut SipHasher, sig: &Binder>| { let sig = anonymize_late_bound_regions(tcx, sig).0; - for a in sig.inputs.iter() { helper(tcx, *a, svh, state); } + for a in &sig.inputs { helper(tcx, *a, svh, state); } if let ty::FnConverging(output) = sig.output { helper(tcx, output, svh, state); } @@ -6270,7 +6270,7 @@ pub fn construct_free_substs<'a,'tcx>( free_id: ast::NodeId, region_params: &[RegionParameterDef]) { - for r in region_params.iter() { + for r in region_params { regions.push(r.space, ty::free_region_from_def(free_id, r)); } } @@ -6278,7 +6278,7 @@ pub fn construct_free_substs<'a,'tcx>( fn push_types_from_defs<'tcx>(tcx: &ty::ctxt<'tcx>, types: &mut VecPerParamSpace>, defs: &[TypeParameterDef<'tcx>]) { - for def in defs.iter() { + for def in defs { debug!("construct_parameter_environment(): push_types_from_defs: def={:?}", def.repr(tcx)); let ty = ty::mk_param_from_def(tcx, def); @@ -6351,7 +6351,7 @@ pub fn construct_parameter_environment<'a,'tcx>( fn record_region_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, predicates: &[ty::Predicate<'tcx>]) { debug!("record_region_bounds(predicates={:?})", predicates.repr(tcx)); - for predicate in predicates.iter() { + for predicate in predicates { match *predicate { Predicate::Projection(..) | Predicate::Trait(..) | @@ -6870,7 +6870,7 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc let did = match self_type.sty { ty::ty_struct(struct_did, substs) => { let fields = ty::struct_fields(tcx, struct_did, substs); - for field in fields.iter() { + for field in &fields { if type_moves_by_default(param_env, span, field.mt.ty) { return Err(FieldDoesNotImplementCopy(field.name)) } @@ -6879,8 +6879,8 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc } ty::ty_enum(enum_did, substs) => { let enum_variants = ty::enum_variants(tcx, enum_did); - for variant in enum_variants.iter() { - for variant_arg_type in variant.args.iter() { + for variant in &*enum_variants { + for variant_arg_type in &variant.args { let substd_arg_type = variant_arg_type.subst(tcx, substs); if type_moves_by_default(param_env, span, substd_arg_type) { diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index 25cca98c5fb..425c9a4c9f7 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -78,7 +78,7 @@ fn verify(sess: &Session, items: &lang_items::LanguageItems) { let mut missing = HashSet::new(); sess.cstore.iter_crate_data(|cnum, _| { - for item in csearch::get_missing_lang_items(&sess.cstore, cnum).iter() { + for item in &csearch::get_missing_lang_items(&sess.cstore, cnum) { missing.insert(*item); } }); diff --git a/src/librustc/plugin/build.rs b/src/librustc/plugin/build.rs index a8018662d29..110e672b70f 100644 --- a/src/librustc/plugin/build.rs +++ b/src/librustc/plugin/build.rs @@ -48,7 +48,7 @@ pub fn find_plugin_registrar(diagnostic: &diagnostic::SpanHandler, }, _ => { diagnostic.handler().err("multiple plugin registration functions found"); - for &(_, span) in finder.registrars.iter() { + for &(_, span) in &finder.registrars { diagnostic.span_note(span, "one is here"); } diagnostic.handler().abort_if_errors(); diff --git a/src/librustc/plugin/load.rs b/src/librustc/plugin/load.rs index c420d1f15b4..22edd7c691a 100644 --- a/src/librustc/plugin/load.rs +++ b/src/librustc/plugin/load.rs @@ -73,7 +73,7 @@ pub fn load_plugins(sess: &Session, krate: &ast::Crate, // We need to error on `#[macro_use] extern crate` when it isn't at the // crate root, because `$crate` won't work properly. Identify these by // spans, because the crate map isn't set up yet. - for item in krate.module.items.iter() { + for item in &krate.module.items { if let ast::ItemExternCrate(_) = item.node { loader.span_whitelist.insert(item.span); } @@ -82,7 +82,7 @@ pub fn load_plugins(sess: &Session, krate: &ast::Crate, visit::walk_crate(&mut loader, krate); if let Some(plugins) = addl_plugins { - for plugin in plugins.iter() { + for plugin in &plugins { loader.load_plugin(CrateOrString::Str(plugin.as_slice()), None, None, None) } @@ -107,7 +107,7 @@ impl<'a, 'v> Visitor<'v> for PluginLoader<'a> { let mut plugin_attr = None; let mut macro_selection = Some(HashSet::new()); // None => load all let mut reexport = HashSet::new(); - for attr in item.attrs.iter() { + for attr in &item.attrs { let mut used = true; match attr.name().get() { "phase" => { @@ -127,7 +127,7 @@ impl<'a, 'v> Visitor<'v> for PluginLoader<'a> { macro_selection = None; } if let (Some(sel), Some(names)) = (macro_selection.as_mut(), names) { - for name in names.iter() { + for name in names { if let ast::MetaWord(ref name) = name.node { sel.insert(name.clone()); } else { @@ -145,7 +145,7 @@ impl<'a, 'v> Visitor<'v> for PluginLoader<'a> { } }; - for name in names.iter() { + for name in names { if let ast::MetaWord(ref name) = name.node { reexport.insert(name.clone()); } else { diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index ab182dd2256..afeb123b7a5 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -306,7 +306,7 @@ macro_rules! options { let value = iter.next(); let option_to_lookup = key.replace("-", "_"); let mut found = false; - for &(candidate, setter, opt_type_desc, _) in $stat.iter() { + for &(candidate, setter, opt_type_desc, _) in $stat { if option_to_lookup != candidate { continue } if !setter(&mut op, value) { match (value, opt_type_desc) { @@ -830,7 +830,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut lint_opts = vec!(); let mut describe_lints = false; - for &level in [lint::Allow, lint::Warn, lint::Deny, lint::Forbid].iter() { + for &level in &[lint::Allow, lint::Warn, lint::Deny, lint::Forbid] { for lint_name in matches.opt_strs(level.as_str()).into_iter() { if lint_name == "help" { describe_lints = true; @@ -853,7 +853,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { let mut output_types = Vec::new(); if !debugging_opts.parse_only && !no_trans { let unparsed_output_types = matches.opt_strs("emit"); - for unparsed_output_type in unparsed_output_types.iter() { + for unparsed_output_type in &unparsed_output_types { for part in unparsed_output_type.split(',') { let output_type = match part.as_slice() { "asm" => OutputTypeAssembly, @@ -923,7 +923,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { }; let mut search_paths = SearchPaths::new(); - for s in matches.opt_strs("L").iter() { + for s in &matches.opt_strs("L") { search_paths.add_path(&s[]); } @@ -997,7 +997,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { }; let mut externs = HashMap::new(); - for arg in matches.opt_strs("extern").iter() { + for arg in &matches.opt_strs("extern") { let mut parts = arg.splitn(1, '='); let name = match parts.next() { Some(s) => s, @@ -1049,7 +1049,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options { pub fn parse_crate_types_from_list(list_list: Vec) -> Result, String> { let mut crate_types: Vec = Vec::new(); - for unparsed_crate_type in list_list.iter() { + for unparsed_crate_type in &list_list { for part in unparsed_crate_type.split(',') { let new_part = match part { "lib" => default_lib_output(), diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index a433161d659..b77a70f1f5d 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -163,7 +163,7 @@ pub fn can_reach(edges_map: &HashMap, S>, source: T, while i < queue.len() { match edges_map.get(&queue[i]) { Some(edges) => { - for target in edges.iter() { + for target in edges { if *target == destination { return true; } diff --git a/src/librustc/util/nodemap.rs b/src/librustc/util/nodemap.rs index 7aa126371c4..8da06e63dae 100644 --- a/src/librustc/util/nodemap.rs +++ b/src/librustc/util/nodemap.rs @@ -62,7 +62,7 @@ impl Hasher for FnvHasher { impl Writer for FnvHasher { fn write(&mut self, bytes: &[u8]) { let FnvHasher(mut hash) = *self; - for byte in bytes.iter() { + for byte in bytes { hash = hash ^ (*byte as u64); hash = hash * 0x100000001b3; } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index eb73757bf6a..458701f2dd7 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -494,11 +494,11 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>, 0 }; - for t in tps[..tps.len() - num_defaults].iter() { + for t in &tps[..tps.len() - num_defaults] { strs.push(ty_to_string(cx, *t)) } - for projection in projections.iter() { + for projection in projections { strs.push(format!("{}={}", projection.projection_ty.item_name.user_string(cx), projection.ty.user_string(cx))); @@ -665,7 +665,7 @@ impl<'tcx> UserString<'tcx> for ty::TyTrait<'tcx> { components.push(tap.user_string(tcx)); // Builtin bounds. - for bound in bounds.builtin_bounds.iter() { + for bound in &bounds.builtin_bounds { components.push(bound.user_string(tcx)); } @@ -748,7 +748,7 @@ impl<'tcx> Repr<'tcx> for subst::RegionSubsts { impl<'tcx> Repr<'tcx> for ty::BuiltinBounds { fn repr(&self, _tcx: &ctxt) -> String { let mut res = Vec::new(); - for b in self.iter() { + for b in self { res.push(match b { ty::BoundSend => "Send".to_string(), ty::BoundSized => "Sized".to_string(), @@ -764,7 +764,7 @@ impl<'tcx> Repr<'tcx> for ty::ParamBounds<'tcx> { fn repr(&self, tcx: &ctxt<'tcx>) -> String { let mut res = Vec::new(); res.push(self.builtin_bounds.repr(tcx)); - for t in self.trait_bounds.iter() { + for t in &self.trait_bounds { res.push(t.repr(tcx)); } res.connect("+") @@ -1157,7 +1157,7 @@ impl<'tcx> UserString<'tcx> for ty::ParamBounds<'tcx> { if !s.is_empty() { result.push(s); } - for n in self.trait_bounds.iter() { + for n in &self.trait_bounds { result.push(n.user_string(tcx)); } result.connect(" + ") @@ -1173,11 +1173,11 @@ impl<'tcx> Repr<'tcx> for ty::ExistentialBounds<'tcx> { res.push(region_str); } - for bound in self.builtin_bounds.iter() { + for bound in &self.builtin_bounds { res.push(bound.user_string(tcx)); } - for projection_bound in self.projection_bounds.iter() { + for projection_bound in &self.projection_bounds { res.push(projection_bound.user_string(tcx)); } diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs index ee8bc71668b..eff11a80691 100644 --- a/src/librustc_back/archive.rs +++ b/src/librustc_back/archive.rs @@ -99,7 +99,7 @@ pub fn find_library(name: &str, osprefix: &str, ossuffix: &str, let oslibname = format!("{}{}{}", osprefix, name, ossuffix); let unixlibname = format!("lib{}.a", name); - for path in search_paths.iter() { + for path in search_paths { debug!("looking for {} inside {:?}", name, path.display()); let test = path.join(&oslibname[]); if test.exists() { return test } @@ -244,7 +244,7 @@ impl<'a> ArchiveBuilder<'a> { // 32,768, and we leave a bit of extra space for the program name. static ARG_LENGTH_LIMIT: uint = 32000; - for member_name in self.members.iter() { + for member_name in &self.members { let len = member_name.as_vec().len(); // `len + 1` to account for the space that's inserted before each @@ -297,7 +297,7 @@ impl<'a> ArchiveBuilder<'a> { // all SYMDEF files as these are just magical placeholders which get // re-created when we make a new archive anyway. let files = try!(fs::readdir(loc.path())); - for file in files.iter() { + for file in &files { let filename = file.filename_str().unwrap(); if skip(filename) { continue } if filename.contains(".SYMDEF") { continue } diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs index 47b909df5e8..311b07fc26f 100644 --- a/src/librustc_back/rpath.rs +++ b/src/librustc_back/rpath.rs @@ -51,7 +51,7 @@ pub fn get_rpath_flags(config: RPathConfig) -> Vec where fn rpaths_to_flags(rpaths: &[String]) -> Vec { let mut ret = Vec::new(); - for rpath in rpaths.iter() { + for rpath in rpaths { ret.push(format!("-Wl,-rpath,{}", &(*rpath)[])); } return ret; @@ -63,7 +63,7 @@ fn get_rpaths(mut config: RPathConfig, libs: &[Path]) -> Vec { debug!("output: {:?}", config.out_filename.display()); debug!("libs:"); - for libpath in libs.iter() { + for libpath in libs { debug!(" {:?}", libpath.display()); } @@ -77,7 +77,7 @@ fn get_rpaths(mut config: RPathConfig, libs: &[Path]) -> Vec fn log_rpaths(desc: &str, rpaths: &[String]) { debug!("{} rpaths:", desc); - for rpath in rpaths.iter() { + for rpath in rpaths { debug!(" {}", *rpath); } } @@ -139,7 +139,7 @@ fn get_install_prefix_rpath(config: RPathConfig) -> String where fn minimize_rpaths(rpaths: &[String]) -> Vec { let mut set = HashSet::new(); let mut minimized = Vec::new(); - for rpath in rpaths.iter() { + for rpath in rpaths { if set.insert(&rpath[]) { minimized.push(rpath.clone()); } diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs index d99ce8b64b0..c15b4114aa7 100644 --- a/src/librustc_back/sha2.rs +++ b/src/librustc_back/sha2.rs @@ -557,7 +557,7 @@ mod tests { fn test_hash(sh: &mut D, tests: &[Test]) { // Test that it works when accepting the message all at once - for t in tests.iter() { + for t in tests { sh.reset(); sh.input_str(t.input.as_slice()); let out_str = sh.result_str(); @@ -565,7 +565,7 @@ mod tests { } // Test that it works when accepting the message in pieces - for t in tests.iter() { + for t in tests { sh.reset(); let len = t.input.len(); let mut left = len; diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 3d7adc9934f..a14f4775ec1 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -79,7 +79,7 @@ impl Svh { // avoid collisions. let mut state = SipHasher::new(); - for data in metadata.iter() { + for data in metadata { data.hash(&mut state); } @@ -97,7 +97,7 @@ impl Svh { // // We hash only the MetaItems instead of the entire Attribute // to avoid hashing the AttrId - for attr in krate.attrs.iter() { + for attr in &krate.attrs { attr.node.value.hash(&mut state); } diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs index 16adccfba57..697e8a75163 100644 --- a/src/librustc_back/target/mod.rs +++ b/src/librustc_back/target/mod.rs @@ -384,7 +384,7 @@ impl Target { let paths = os::split_paths(&target_path[]); // FIXME 16351: add a sane default search path? - for dir in paths.iter() { + for dir in &paths { let p = dir.join(path.clone()); if p.is_file() { return load_file(&p); diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index b66419420e9..b8d736ab9ca 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -279,7 +279,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { let loan_path = owned_ptr_base_path(loan_path); let cont = self.each_in_scope_loan(scope, |loan| { let mut ret = true; - for restr_path in loan.restricted_paths.iter() { + for restr_path in &loan.restricted_paths { if **restr_path == *loan_path { if !op(loan) { ret = false; @@ -361,7 +361,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { debug!("new_loan_indices = {:?}", new_loan_indices); self.each_issued_loan(scope, |issued_loan| { - for &new_loan_index in new_loan_indices.iter() { + for &new_loan_index in &new_loan_indices { let new_loan = &self.all_loans[new_loan_index]; self.report_error_if_loans_conflict(issued_loan, new_loan); } @@ -370,7 +370,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { for (i, &x) in new_loan_indices.iter().enumerate() { let old_loan = &self.all_loans[x]; - for &y in new_loan_indices[(i+1) ..].iter() { + for &y in &new_loan_indices[(i+1) ..] { let new_loan = &self.all_loans[y]; self.report_error_if_loans_conflict(old_loan, new_loan); } @@ -416,7 +416,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { } let loan2_base_path = owned_ptr_base_path_rc(&loan2.loan_path); - for restr_path in loan1.restricted_paths.iter() { + for restr_path in &loan1.restricted_paths { if *restr_path != loan2_base_path { continue; } // If new_loan is something like `x.a`, and old_loan is something like `x.b`, we would diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs index 6e71da198e3..6f51ba31182 100644 --- a/src/librustc_borrowck/borrowck/fragments.rs +++ b/src/librustc_borrowck/borrowck/fragments.rs @@ -204,14 +204,14 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { debug!("fragments 1 assigned: {:?}", path_lps(&assigned[])); // Second, build parents from the moved and assigned. - for m in moved.iter() { + for m in &moved { let mut p = this.path_parent(*m); while p != InvalidMovePathIndex { parents.push(p); p = this.path_parent(p); } } - for a in assigned.iter() { + for a in &assigned { let mut p = this.path_parent(*a); while p != InvalidMovePathIndex { parents.push(p); @@ -231,15 +231,15 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) { debug!("fragments 3 assigned: {:?}", path_lps(&assigned[])); // Fourth, build the leftover from the moved, assigned, and parents. - for m in moved.iter() { + for m in &moved { let lp = this.path_loan_path(*m); add_fragment_siblings(this, tcx, &mut unmoved, lp, None); } - for a in assigned.iter() { + for a in &assigned { let lp = this.path_loan_path(*a); add_fragment_siblings(this, tcx, &mut unmoved, lp, None); } - for p in parents.iter() { + for p in &parents { let lp = this.path_loan_path(*p); add_fragment_siblings(this, tcx, &mut unmoved, lp, None); } @@ -369,7 +369,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, let fields = ty::lookup_struct_fields(tcx, def_id); match *origin_field_name { mc::NamedField(ast_name) => { - for f in fields.iter() { + for f in &fields { if f.name == ast_name { continue; } @@ -407,7 +407,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>, match *origin_field_name { mc::NamedField(ast_name) => { let variant_arg_names = variant_info.arg_names.as_ref().unwrap(); - for variant_arg_ident in variant_arg_names.iter() { + for variant_arg_ident in variant_arg_names { if variant_arg_ident.name == ast_name { continue; } diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 28d02161eeb..2cd25de431e 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -67,10 +67,10 @@ pub struct GroupedMoveErrors<'tcx> { fn report_move_errors<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, errors: &Vec>) { let grouped_errors = group_errors_with_same_origin(errors); - for error in grouped_errors.iter() { + for error in &grouped_errors { report_cannot_move_out_of(bccx, error.move_from.clone()); let mut is_first_note = true; - for move_to in error.move_to_places.iter() { + for move_to in &error.move_to_places { note_move_destination(bccx, move_to.span, &move_to.ident, is_first_note); is_first_note = false; @@ -81,7 +81,7 @@ fn report_move_errors<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, fn group_errors_with_same_origin<'tcx>(errors: &Vec>) -> Vec> { let mut grouped_errors = Vec::new(); - for error in errors.iter() { + for error in errors { append_to_grouped_errors(&mut grouped_errors, error) } return grouped_errors; diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs index ece9d61d7f2..76c431fa4c5 100644 --- a/src/librustc_borrowck/borrowck/move_data.rs +++ b/src/librustc_borrowck/borrowck/move_data.rs @@ -475,13 +475,13 @@ impl<'tcx> MoveData<'tcx> { self.kill_moves(assignment.path, assignment.id, dfcx_moves); } - for assignment in self.path_assignments.borrow().iter() { + for assignment in &*self.path_assignments.borrow() { self.kill_moves(assignment.path, assignment.id, dfcx_moves); } // Kill all moves related to a variable `x` when // it goes out of scope: - for path in self.paths.borrow().iter() { + for path in &*self.paths.borrow() { match path.loan_path.kind { LpVar(..) | LpUpvar(..) | LpDowncast(..) => { let kill_scope = path.loan_path.kill_scope(tcx); @@ -633,11 +633,11 @@ impl<'a, 'tcx> FlowedMoveData<'a, 'tcx> { //! Returns the kind of a move of `loan_path` by `id`, if one exists. let mut ret = None; - for loan_path_index in self.move_data.path_map.borrow().get(&*loan_path).iter() { + if let Some(loan_path_index) = self.move_data.path_map.borrow().get(&*loan_path) { self.dfcx_moves.each_gen_bit(id, |move_index| { let the_move = self.move_data.moves.borrow(); let the_move = (*the_move)[move_index]; - if the_move.path == **loan_path_index { + if the_move.path == *loan_path_index { ret = Some(the_move.kind); false } else { @@ -688,7 +688,7 @@ impl<'a, 'tcx> FlowedMoveData<'a, 'tcx> { ret = false; } } else { - for &loan_path_index in opt_loan_path_index.iter() { + if let Some(loan_path_index) = opt_loan_path_index { let cont = self.move_data.each_base_path(moved_path, |p| { if p == loan_path_index { // Scenario 3: some extension of `loan_path` @@ -699,7 +699,7 @@ impl<'a, 'tcx> FlowedMoveData<'a, 'tcx> { true } }); - if !cont { ret = false; break } + if !cont { ret = false; } } } ret diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs index 150e616b36c..8b1b156691a 100644 --- a/src/librustc_borrowck/graphviz.rs +++ b/src/librustc_borrowck/graphviz.rs @@ -56,7 +56,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { debug!("dataflow_for({:?}, id={}) {:?}", e, id, self.variants); let mut sets = "".to_string(); let mut seen_one = false; - for &variant in self.variants.iter() { + for &variant in &self.variants { if seen_one { sets.push_str(" "); } else { seen_one = true; } sets.push_str(variant.short_name()); sets.push_str(": "); diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 9e00844b7ee..e8ea349c3db 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -760,11 +760,11 @@ fn write_out_deps(sess: &Session, id: &str) { let mut out_filenames = Vec::new(); - for output_type in sess.opts.output_types.iter() { + for output_type in &sess.opts.output_types { let file = outputs.path(*output_type); match *output_type { config::OutputTypeExe => { - for output in sess.crate_types.borrow().iter() { + for output in &*sess.crate_types.borrow() { let p = link::filename_for_input(sess, *output, id, &file); out_filenames.push(p); @@ -800,7 +800,7 @@ fn write_out_deps(sess: &Session, .map(|fmap| escape_dep_filename(&fmap.name[])) .collect(); let mut file = try!(old_io::File::create(&deps_filename)); - for path in out_filenames.iter() { + for path in &out_filenames { try!(write!(&mut file as &mut Writer, "{}: {}\n\n", path.display(), files.connect(" "))); } diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 2eada1ff174..a8f5cfa6b3f 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -435,7 +435,7 @@ Available lint options: fn describe_debug_flags() { println!("\nAvailable debug options:\n"); - for &(name, _, opt_type_desc, desc) in config::DB_OPTIONS.iter() { + for &(name, _, opt_type_desc, desc) in config::DB_OPTIONS { let (width, extra) = match opt_type_desc { Some(..) => (21, "=val"), None => (25, "") @@ -447,7 +447,7 @@ fn describe_debug_flags() { fn describe_codegen_flags() { println!("\nAvailable codegen options:\n"); - for &(name, _, opt_type_desc, desc) in config::CG_OPTIONS.iter() { + for &(name, _, opt_type_desc, desc) in config::CG_OPTIONS { let (width, extra) = match opt_type_desc { Some(..) => (21, "=val"), None => (25, "") @@ -542,7 +542,7 @@ fn print_crate_info(sess: &Session, if sess.opts.prints.len() == 0 { return false } let attrs = input.map(|input| parse_crate_attrs(sess, input)); - for req in sess.opts.prints.iter() { + for req in &sess.opts.prints { match *req { PrintRequest::Sysroot => println!("{}", sess.sysroot().display()), PrintRequest::FileNames | @@ -566,7 +566,7 @@ fn print_crate_info(sess: &Session, let crate_types = driver::collect_crate_types(sess, attrs); let metadata = driver::collect_crate_metadata(sess, attrs); *sess.crate_metadata.borrow_mut() = metadata; - for &style in crate_types.iter() { + for &style in &crate_types { let fname = link::filename_for_input(sess, style, id.as_slice(), &t_outputs.with_extension("")); @@ -645,7 +645,7 @@ pub fn monitor(f: F) { BUG_REPORT_URL), "run with `RUST_BACKTRACE=1` for a backtrace".to_string(), ]; - for note in xs.iter() { + for note in &xs { emitter.emit(None, ¬e[], None, diagnostic::Note) } diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index 45ff1c4537c..20bf77190be 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -147,7 +147,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> { } pub fn create_region_hierarchy(&self, rh: &RH) { - for child_rh in rh.sub.iter() { + for child_rh in rh.sub { self.create_region_hierarchy(child_rh); self.infcx.tcx.region_maps.record_encl_scope( CodeExtent::from_node_id(child_rh.id), @@ -181,7 +181,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> { names: &[String]) -> Option { assert!(idx < names.len()); - for item in m.items.iter() { + for item in &m.items { if item.ident.user_string(this.infcx.tcx) == names[idx] { return search(this, &**item, idx+1, names); } diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index a24bc6eaec3..8ec1babd4da 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -261,13 +261,13 @@ impl AttrBuilder { } pub fn apply_llfn(&self, llfn: ValueRef) { - for &(idx, ref attr) in self.attrs.iter() { + for &(idx, ref attr) in &self.attrs { attr.apply_llfn(idx as c_uint, llfn); } } pub fn apply_callsite(&self, callsite: ValueRef) { - for &(idx, ref attr) in self.attrs.iter() { + for &(idx, ref attr) in &self.attrs { attr.apply_callsite(idx as c_uint, callsite); } } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 14e80c6c8ef..c398ff72f50 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -79,7 +79,7 @@ impl<'v> Visitor<'v> for ParentVisitor { // Enum variants are parented to the enum definition itself because // they inherit privacy ast::ItemEnum(ref def, _) => { - for variant in def.variants.iter() { + for variant in &def.variants { // The parent is considered the enclosing enum because the // enum will dictate the privacy visibility of this variant // instead. @@ -93,7 +93,7 @@ impl<'v> Visitor<'v> for ParentVisitor { // parent all the methods to the trait to indicate that they're // private. ast::ItemTrait(_, _, _, ref methods) if item.vis != ast::Public => { - for m in methods.iter() { + for m in methods { match *m { ast::ProvidedMethod(ref m) => { self.parents.insert(m.id, item.id); @@ -139,7 +139,7 @@ impl<'v> Visitor<'v> for ParentVisitor { // While we have the id of the struct definition, go ahead and parent // all the fields. - for field in s.fields.iter() { + for field in &s.fields { self.parents.insert(field.node.id, self.curparent); } visit::walk_struct_def(self, s) @@ -233,7 +233,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { // Enum variants inherit from their parent, so if the enum is // public all variants are public unless they're explicitly priv ast::ItemEnum(ref def, _) if public_first => { - for variant in def.variants.iter() { + for variant in &def.variants { self.exported_items.insert(variant.node.id); } } @@ -278,7 +278,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { }); if public_ty || public_trait { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { let meth_public = @@ -299,7 +299,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { // Default methods on traits are all public so long as the trait // is public ast::ItemTrait(_, _, _, ref methods) if public_first => { - for method in methods.iter() { + for method in methods { match *method { ast::ProvidedMethod(ref m) => { debug!("provided {}", m.id); @@ -359,7 +359,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> { // crate module gets processed as well. if self.prev_exported { assert!(self.export_map.contains_key(&id), "wut {}", id); - for export in self.export_map[id].iter() { + for export in &self.export_map[id] { if is_local(export.def_id) { self.reexports.insert(export.def_id.node); } @@ -837,7 +837,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { match vpath.node { ast::ViewPathSimple(..) | ast::ViewPathGlob(..) => {} ast::ViewPathList(ref prefix, ref list) => { - for pid in list.iter() { + for pid in list { match pid.node { ast::PathListIdent { id, name } => { debug!("privacy - ident item {}", id); @@ -898,7 +898,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { ast::ExprStruct(_, ref fields, _) => { match ty::expr_ty(self.tcx, expr).sty { ty::ty_struct(id, _) => { - for field in (*fields).iter() { + for field in &(*fields) { self.check_field(expr.span, id, NamedField(field.ident.node)); } @@ -906,7 +906,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { ty::ty_enum(_, _) => { match self.tcx.def_map.borrow()[expr.id].clone() { def::DefVariant(_, variant_id, _) => { - for field in fields.iter() { + for field in fields { self.check_field(expr.span, variant_id, NamedField(field.ident.node)); } @@ -971,7 +971,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { ast::PatStruct(_, ref fields, _) => { match ty::pat_ty(self.tcx, pattern).sty { ty::ty_struct(id, _) => { - for field in fields.iter() { + for field in fields { self.check_field(pattern.span, id, NamedField(field.node.ident)); } @@ -979,7 +979,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { ty::ty_enum(_, _) => { match self.tcx.def_map.borrow().get(&pattern.id) { Some(&def::DefVariant(_, variant_id, _)) => { - for field in fields.iter() { + for field in fields { self.check_field(pattern.span, variant_id, NamedField(field.node.ident)); } @@ -1091,7 +1091,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { check_inherited(item.span, item.vis, "visibility qualifiers have no effect on trait \ impls"); - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref m) => { check_inherited(m.span, m.pe_vis(), ""); @@ -1112,7 +1112,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } ast::ItemEnum(ref def, _) => { - for v in def.variants.iter() { + for v in &def.variants { match v.node.vis { ast::Public => { if item.vis == ast::Public { @@ -1126,7 +1126,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } ast::ItemTrait(_, _, _, ref methods) => { - for m in methods.iter() { + for m in methods { match *m { ast::ProvidedMethod(ref m) => { check_inherited(m.span, m.pe_vis(), @@ -1157,7 +1157,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } } let check_struct = |&: def: &ast::StructDef| { - for f in def.fields.iter() { + for f in &def.fields { match f.node.kind { ast::NamedField(_, p) => check_inherited(tcx, f.span, p), ast::UnnamedField(..) => {} @@ -1167,7 +1167,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { check_inherited(tcx, item.span, item.vis); match item.node { ast::ItemImpl(_, _, _, _, _, ref impl_items) => { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref m) => { check_inherited(tcx, m.span, m.pe_vis()); @@ -1177,12 +1177,12 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { } } ast::ItemForeignMod(ref fm) => { - for i in fm.items.iter() { + for i in &fm.items { check_inherited(tcx, i.span, i.vis); } } ast::ItemEnum(ref def, _) => { - for v in def.variants.iter() { + for v in &def.variants { check_inherited(tcx, v.span, v.node.vis); } } @@ -1190,7 +1190,7 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { ast::ItemStruct(ref def, _) => check_struct(&**def), ast::ItemTrait(_, _, _, ref methods) => { - for m in methods.iter() { + for m in methods { match *m { ast::RequiredMethod(..) => {} ast::ProvidedMethod(ref m) => check_inherited(tcx, m.span, @@ -1302,7 +1302,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { return } - for bound in bounds.iter() { + for bound in &**bounds { self.check_ty_param_bound(bound) } } @@ -1371,7 +1371,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { match *trait_ref { None => { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { visit::walk_method_helper(self, &**method) @@ -1400,7 +1400,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { // impl Public { ... }. Any public static // methods will be visible as `Public::foo`. let mut found_pub_static = false; - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { if method.pe_explicit_self().node == @@ -1439,15 +1439,15 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { } fn visit_generics(&mut self, generics: &ast::Generics) { - for ty_param in generics.ty_params.iter() { - for bound in ty_param.bounds.iter() { + for ty_param in &*generics.ty_params { + for bound in &*ty_param.bounds { self.check_ty_param_bound(bound) } } - for predicate in generics.where_clause.predicates.iter() { + for predicate in &generics.where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ref bound_pred) => { - for bound in bound_pred.bounds.iter() { + for bound in &*bound_pred.bounds { self.check_ty_param_bound(bound) } } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 65bd83d7937..a503398d484 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -223,8 +223,8 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { token::get_name(name))[]); { let r = child.span_for_namespace(ns); - for sp in r.iter() { - self.session.span_note(*sp, + if let Some(sp) = r { + self.session.span_note(sp, &format!("first definition of {} `{}` here", namespace_error_to_string(duplicate_type), token::get_name(name))[]); @@ -238,7 +238,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { fn block_needs_anonymous_module(&mut self, block: &Block) -> bool { // Check each statement. - for statement in block.stmts.iter() { + for statement in &block.stmts { match statement.node { StmtDecl(ref declaration, _) => { match declaration.node { @@ -338,7 +338,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { } } - for source_item in source_items.iter() { + for source_item in source_items { let (module_path, name) = match source_item.node { PathListIdent { name, .. } => (module_path.clone(), name.name), @@ -477,7 +477,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let module = name_bindings.get_module(); - for variant in (*enum_definition).variants.iter() { + for variant in &(*enum_definition).variants { self.build_reduced_graph_for_variant( &**variant, local_def(item.id), @@ -591,7 +591,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { }; // For each implementation item... - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { MethodImplItem(ref method) => { // Add the method to the module. @@ -675,7 +675,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let def_id = local_def(item.id); // Add the names of all the items to the trait info. - for trait_item in items.iter() { + for trait_item in items { let (name, kind) = match *trait_item { ast::RequiredMethod(_) | ast::ProvidedMethod(_) => { @@ -926,7 +926,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { let trait_item_def_ids = csearch::get_trait_item_def_ids(&self.session.cstore, def_id); - for trait_item_def_id in trait_item_def_ids.iter() { + for trait_item_def_id in &trait_item_def_ids { let (trait_item_name, trait_item_kind) = csearch::get_trait_item_name_and_kind( &self.session.cstore, @@ -1082,7 +1082,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> { // Add each static method to the module. let new_parent = type_module; - for method_info in methods.iter() { + for method_info in methods { let name = method_info.name; debug!("(building reduced graph for \ external crate) creating \ diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index 97370112ab4..a239c73c110 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -136,7 +136,7 @@ impl<'a, 'b, 'v, 'tcx> Visitor<'v> for UnusedImportCheckVisitor<'a, 'b, 'tcx> { } ViewPathList(_, ref list) => { - for i in list.iter() { + for i in list { self.finalize_import(i.node.id(), i.span); } } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index f0711903579..c10b7124218 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1031,7 +1031,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.current_module = orig_module; build_reduced_graph::populate_module_if_necessary(self, &module_); - for (_, child_node) in module_.children.borrow().iter() { + for (_, child_node) in &*module_.children.borrow() { match child_node.get_module_if_available() { None => { // Nothing to do. @@ -1042,7 +1042,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - for (_, child_module) in module_.anonymous_children.borrow().iter() { + for (_, child_module) in &*module_.anonymous_children.borrow() { self.resolve_imports_for_module_subtree(child_module.clone()); } } @@ -1087,7 +1087,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn names_to_string(&self, names: &[Name]) -> String { let mut first = true; let mut result = String::new(); - for name in names.iter() { + for name in names { if first { first = false } else { @@ -1596,7 +1596,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Add all resolved imports from the containing module. let import_resolutions = containing_module.import_resolutions.borrow(); - for (ident, target_import_resolution) in import_resolutions.iter() { + for (ident, target_import_resolution) in &*import_resolutions { debug!("(resolving glob import) writing module resolution \ {} into `{}`", token::get_name(*ident), @@ -1657,7 +1657,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Add all children from the containing module. build_reduced_graph::populate_module_if_necessary(self, &containing_module); - for (&name, name_bindings) in containing_module.children.borrow().iter() { + for (&name, name_bindings) in &*containing_module.children.borrow() { self.merge_import_resolution(module_, containing_module.clone(), import_directive, @@ -1667,7 +1667,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } // Add external module children from the containing module. - for (&name, module) in containing_module.external_module_children.borrow().iter() { + for (&name, module) in &*containing_module.external_module_children.borrow() { let name_bindings = Rc::new(Resolver::create_name_bindings_from_module(module.clone())); self.merge_import_resolution(module_, @@ -2519,7 +2519,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Descend into children and anonymous children. build_reduced_graph::populate_module_if_necessary(self, &module_); - for (_, child_node) in module_.children.borrow().iter() { + for (_, child_node) in &*module_.children.borrow() { match child_node.get_module_if_available() { None => { // Continue. @@ -2530,7 +2530,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - for (_, module_) in module_.anonymous_children.borrow().iter() { + for (_, module_) in &*module_.anonymous_children.borrow() { self.report_unresolved_imports(module_.clone()); } } @@ -2609,7 +2609,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { DlDef(d @ DefLocal(_)) => { let node_id = d.def_id().node; let mut def = d; - for rib in ribs.iter() { + for rib in ribs { match rib.kind { NormalRibKind => { // Nothing to do. Continue. @@ -2680,7 +2680,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } DlDef(def @ DefTyParam(..)) | DlDef(def @ DefSelfTy(..)) => { - for rib in ribs.iter() { + for rib in ribs { match rib.kind { NormalRibKind | ClosureRibKind(..) => { // Nothing to do. Continue. @@ -2795,8 +2795,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // enum item: resolve all the variants' discrs, // then resolve the ty params ItemEnum(ref enum_def, ref generics) => { - for variant in (*enum_def).variants.iter() { - for dis_expr in variant.node.disr_expr.iter() { + for variant in &(*enum_def).variants { + if let Some(ref dis_expr) = variant.node.disr_expr { // resolve the discriminator expr // as a constant self.with_constant_rib(|this| { @@ -2863,7 +2863,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_type_parameter_bounds(item.id, bounds, TraitDerivation); - for trait_item in (*trait_items).iter() { + for trait_item in &(*trait_items) { // Create a new rib for the trait_item-specific type // parameters. // @@ -2885,7 +2885,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_where_clause(&ty_m.generics .where_clause); - for argument in ty_m.decl.inputs.iter() { + for argument in &ty_m.decl.inputs { this.resolve_type(&*argument.ty); } @@ -2929,7 +2929,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { ItemForeignMod(ref foreign_module) => { self.with_scope(Some(name), |this| { - for foreign_item in foreign_module.items.iter() { + for foreign_item in &foreign_module.items { match foreign_item.node { ForeignItemFn(_, ref generics) => { this.with_type_parameter_rib( @@ -3075,7 +3075,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } Some(declaration) => { let mut bindings_list = HashMap::new(); - for argument in declaration.inputs.iter() { + for argument in &declaration.inputs { this.resolve_pattern(&*argument.pat, ArgumentIrrefutableMode, &mut bindings_list); @@ -3103,14 +3103,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn resolve_type_parameters(&mut self, type_parameters: &OwnedSlice) { - for type_parameter in type_parameters.iter() { + for type_parameter in &**type_parameters { self.resolve_type_parameter(type_parameter); } } fn resolve_type_parameter(&mut self, type_parameter: &TyParam) { - for bound in type_parameter.bounds.iter() { + for bound in &*type_parameter.bounds { self.resolve_type_parameter_bound(type_parameter.id, bound, TraitBoundingTypeParameter); } @@ -3124,7 +3124,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { id: NodeId, type_parameter_bounds: &OwnedSlice, reference_type: TraitReferenceType) { - for type_parameter_bound in type_parameter_bounds.iter() { + for type_parameter_bound in &**type_parameter_bounds { self.resolve_type_parameter_bound(id, type_parameter_bound, reference_type); } @@ -3193,12 +3193,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } fn resolve_where_clause(&mut self, where_clause: &ast::WhereClause) { - for predicate in where_clause.predicates.iter() { + for predicate in &where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ref bound_pred) => { self.resolve_type(&*bound_pred.bounded_ty); - for bound in bound_pred.bounds.iter() { + for bound in &*bound_pred.bounds { self.resolve_type_parameter_bound(bound_pred.bounded_ty.id, bound, TraitBoundingTypeParameter); } @@ -3236,7 +3236,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_where_clause(&generics.where_clause); // Resolve fields. - for field in fields.iter() { + for field in fields { this.resolve_type(&*field.node.ty); } }); @@ -3320,7 +3320,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { this.resolve_type(self_type); this.with_current_self_type(self_type, |this| { - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { MethodImplItem(ref method) => { // If this is a trait impl, ensure the method @@ -3375,7 +3375,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn check_trait_item(&self, name: Name, span: Span) { // If there is a TraitRef in scope for an impl, then the method must be in the trait. - for &(did, ref trait_ref) in self.current_trait_ref.iter() { + if let Some((did, ref trait_ref)) = self.current_trait_ref { if self.trait_item_map.get(&(name, did)).is_none() { let path_str = self.path_names_to_string(&trait_ref.path); self.resolve_error(span, @@ -3442,7 +3442,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { for (i, p) in arm.pats.iter().enumerate() { let map_i = self.binding_mode_map(&**p); - for (&key, &binding_0) in map_0.iter() { + for (&key, &binding_0) in &map_0 { match map_i.get(&key) { None => { self.resolve_error( @@ -3465,7 +3465,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } } - for (&key, &binding) in map_i.iter() { + for (&key, &binding) in &map_i { if !map_0.contains_key(&key) { self.resolve_error( binding.span, @@ -3482,7 +3482,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { self.value_ribs.push(Rib::new(NormalRibKind)); let mut bindings_list = HashMap::new(); - for pattern in arm.pats.iter() { + for pattern in &arm.pats { self.resolve_pattern(&**pattern, RefutableMode, &mut bindings_list); } @@ -3513,7 +3513,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { // Check for imports appearing after non-item statements. let mut found_non_item = false; - for statement in block.stmts.iter() { + for statement in &block.stmts { if let ast::StmtDecl(ref declaration, _) = statement.node { if let ast::DeclItem(ref i) = declaration.node { match i.node { @@ -4365,7 +4365,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { let mut values: Vec = Vec::new(); for rib in this.value_ribs.iter().rev() { - for (&k, _) in rib.bindings.iter() { + for (&k, _) in &rib.bindings { maybes.push(token::get_name(k)); values.push(uint::MAX); } @@ -4640,7 +4640,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { build_reduced_graph::populate_module_if_necessary(self, &search_module); { - for (_, child_names) in search_module.children.borrow().iter() { + for (_, child_names) in &*search_module.children.borrow() { let def = match child_names.def_for_namespace(TypeNS) { Some(def) => def, None => continue @@ -4656,7 +4656,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { } // Look for imports. - for (_, import) in search_module.import_resolutions.borrow().iter() { + for (_, import) in &*search_module.import_resolutions.borrow() { let target = match import.target_for_namespace(TypeNS) { None => continue, Some(target) => target, @@ -4766,13 +4766,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { debug!("Children:"); build_reduced_graph::populate_module_if_necessary(self, &module_); - for (&name, _) in module_.children.borrow().iter() { + for (&name, _) in &*module_.children.borrow() { debug!("* {}", token::get_name(name)); } debug!("Import resolutions:"); let import_resolutions = module_.import_resolutions.borrow(); - for (&name, import_resolution) in import_resolutions.iter() { + for (&name, import_resolution) in &*import_resolutions { let value_repr; match import_resolution.target_for_namespace(ValueNS) { None => { value_repr = "".to_string(); } diff --git a/src/librustc_resolve/record_exports.rs b/src/librustc_resolve/record_exports.rs index 67bcf152eb7..5d025f40d32 100644 --- a/src/librustc_resolve/record_exports.rs +++ b/src/librustc_resolve/record_exports.rs @@ -80,7 +80,7 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { self.record_exports_for_module(&*module_); build_reduced_graph::populate_module_if_necessary(self.resolver, &module_); - for (_, child_name_bindings) in module_.children.borrow().iter() { + for (_, child_name_bindings) in &*module_.children.borrow() { match child_name_bindings.get_module_if_available() { None => { // Nothing to do. @@ -91,7 +91,7 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { } } - for (_, child_module) in module_.anonymous_children.borrow().iter() { + for (_, child_module) in &*module_.anonymous_children.borrow() { self.record_exports_for_module_subtree(child_module.clone()); } } @@ -133,12 +133,12 @@ impl<'a, 'b, 'tcx> ExportRecorder<'a, 'b, 'tcx> { fn add_exports_for_module(&mut self, exports: &mut Vec, module_: &Module) { - for (name, importresolution) in module_.import_resolutions.borrow().iter() { + for (name, importresolution) in &*module_.import_resolutions.borrow() { if !importresolution.is_public { continue } let xs = [TypeNS, ValueNS]; - for &ns in xs.iter() { + for &ns in &xs { match importresolution.target_for_namespace(ns) { Some(target) => { debug!("(computing exports) maybe export '{}'", diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index c97d9090441..eeb6d9fab5e 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -194,7 +194,7 @@ fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>, symbol_hasher.input_str(&link_meta.crate_name[]); symbol_hasher.input_str("-"); symbol_hasher.input_str(link_meta.crate_hash.as_str()); - for meta in tcx.sess.crate_metadata.borrow().iter() { + for meta in &*tcx.sess.crate_metadata.borrow() { symbol_hasher.input_str(&meta[]); } symbol_hasher.input_str("-"); @@ -370,7 +370,7 @@ pub fn link_binary(sess: &Session, outputs: &OutputFilenames, crate_name: &str) -> Vec { let mut out_filenames = Vec::new(); - for &crate_type in sess.crate_types.borrow().iter() { + for &crate_type in &*sess.crate_types.borrow() { if invalid_output_for_target(sess, crate_type) { sess.bug(&format!("invalid output type `{:?}` for target os `{}`", crate_type, sess.opts.target_triple)[]); @@ -535,7 +535,7 @@ fn link_rlib<'a>(sess: &'a Session, let mut ab = ArchiveBuilder::create(config); ab.add_file(obj_filename).unwrap(); - for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() { + for &(ref l, kind) in &*sess.cstore.get_used_libraries().borrow() { match kind { cstore::NativeStatic => { ab.add_native_library(&l[]).unwrap(); @@ -721,7 +721,7 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { let crates = sess.cstore.get_used_crates(cstore::RequireStatic); let mut all_native_libs = vec![]; - for &(cnum, ref path) in crates.iter() { + for &(cnum, ref path) in &crates { let ref name = sess.cstore.get_crate_data(cnum).name; let p = match *path { Some(ref p) => p.clone(), None => { @@ -746,7 +746,7 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) { and so may need to be preserved"); } - for &(kind, ref lib) in all_native_libs.iter() { + for &(kind, ref lib) in &all_native_libs { let name = match kind { cstore::NativeStatic => "static library", cstore::NativeUnknown => "library", @@ -1133,7 +1133,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session, // crates. let deps = sess.cstore.get_used_crates(cstore::RequireDynamic); - for &(cnum, _) in deps.iter() { + for &(cnum, _) in &deps { // We may not pass all crates through to the linker. Some crates may // appear statically in an existing dylib, meaning we'll pick up all the // symbols from the dylib. @@ -1277,7 +1277,7 @@ fn add_upstream_native_libraries(cmd: &mut Command, sess: &Session) { let crates = sess.cstore.get_used_crates(cstore::RequireStatic); for (cnum, _) in crates.into_iter() { let libs = csearch::get_native_libraries(&sess.cstore, cnum); - for &(kind, ref lib) in libs.iter() { + for &(kind, ref lib) in &libs { match kind { cstore::NativeUnknown => { cmd.arg(format!("-l{}", *lib)); diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs index 5fcf0be4c67..1a5310bb0a8 100644 --- a/src/librustc_trans/back/lto.rs +++ b/src/librustc_trans/back/lto.rs @@ -34,7 +34,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef, } // Make sure we actually can run LTO - for crate_type in sess.crate_types.borrow().iter() { + for crate_type in &*sess.crate_types.borrow() { match *crate_type { config::CrateTypeExecutable | config::CrateTypeStaticlib => {} _ => { diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index 9b195486d5d..c54e3e02d3c 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -100,7 +100,7 @@ impl SharedEmitter { fn dump(&mut self, handler: &Handler) { let mut buffer = self.buffer.lock().unwrap(); - for diag in buffer.iter() { + for diag in &*buffer { match diag.code { Some(ref code) => { handler.emit_with_code(None, @@ -452,7 +452,7 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext, config.no_builtins); } - for pass in config.passes.iter() { + for pass in &config.passes { let pass = CString::from_slice(pass.as_bytes()); if !llvm::LLVMRustAddPass(mpm, pass.as_ptr()) { cgcx.handler.warn(format!("unknown pass {:?}, ignoring", @@ -597,7 +597,7 @@ pub fn run_passes(sess: &Session, modules_config.emit_bc = true; } - for output_type in output_types.iter() { + for output_type in output_types { match *output_type { config::OutputTypeBitcode => { modules_config.emit_bc = true; }, config::OutputTypeLlvmAssembly => { modules_config.emit_ir = true; }, @@ -761,7 +761,7 @@ pub fn run_passes(sess: &Session, // Otherwise, we produced it only as a temporary output, and will need // to get rid of it. let mut user_wants_bitcode = false; - for output_type in output_types.iter() { + for output_type in output_types { match *output_type { config::OutputTypeBitcode => { user_wants_bitcode = true; @@ -1015,7 +1015,7 @@ unsafe fn configure_llvm(sess: &Session) { // FIXME #21627 disable faulty FastISel on AArch64 (even for -O0) if sess.target.target.arch.as_slice() == "aarch64" { add("-fast-isel=0"); } - for arg in sess.opts.cg.llvm_args.iter() { + for arg in &sess.opts.cg.llvm_args { add(&(*arg)[]); } } diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs index fbeaae1d1df..e522b1f3671 100644 --- a/src/librustc_trans/save/mod.rs +++ b/src/librustc_trans/save/mod.rs @@ -113,7 +113,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { error!("Mis-calculated spans for path '{}'. \ Found {} spans, expected {}. Found spans:", path_to_string(path), spans.len(), path.segments.len()); - for s in spans.iter() { + for s in &spans { let loc = self.sess.codemap().lookup_char_pos(s.lo); error!(" '{}' in {}, line {}", self.span.snippet(*s), loc.file.name, loc.line); @@ -204,7 +204,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { return; } let sub_paths = &sub_paths[..len-2]; - for &(ref span, ref qualname) in sub_paths.iter() { + for &(ref span, ref qualname) in sub_paths { self.fmt.sub_mod_ref_str(path.span, *span, &qualname[], @@ -264,13 +264,13 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } fn process_formals(&mut self, formals: &Vec, qualname: &str) { - for arg in formals.iter() { + for arg in formals { assert!(self.collected_paths.len() == 0 && !self.collecting); self.collecting = true; self.visit_pat(&*arg.pat); self.collecting = false; let span_utils = self.span.clone(); - for &(id, ref p, _, _) in self.collected_paths.iter() { + for &(id, ref p, _, _) in &self.collected_paths { let typ = ppaux::ty_to_string(&self.analysis.ty_cx, (*self.analysis.ty_cx.node_types.borrow())[id]); // get the span only for the name of the variable (I hope the path is only ever a @@ -389,7 +389,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.process_formals(&method.pe_fn_decl().inputs, qualname); // walk arg and return types - for arg in method.pe_fn_decl().inputs.iter() { + for arg in &method.pe_fn_decl().inputs { self.visit_ty(&*arg.ty); } @@ -493,7 +493,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.process_formals(&decl.inputs, &qualname[]); // walk arg and return types - for arg in decl.inputs.iter() { + for arg in &decl.inputs { self.visit_ty(&*arg.ty); } @@ -580,7 +580,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &val[]); // fields - for field in def.fields.iter() { + for field in &def.fields { self.process_struct_field_def(field, &qualname[], item.id); self.visit_ty(&*field.node.ty); } @@ -605,7 +605,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &format!("Could not find subspan for enum {}", enum_name)[]), } - for variant in enum_definition.variants.iter() { + for variant in &enum_definition.variants { let name = get_ident(variant.node.name); let name = name.get(); let mut qualname = enum_name.clone(); @@ -623,7 +623,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &enum_name[], &val[], item.id); - for arg in args.iter() { + for arg in args { self.visit_ty(&*arg.ty); } } @@ -642,7 +642,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &val[], item.id); - for field in struct_def.fields.iter() { + for field in &struct_def.fields { self.process_struct_field_def(field, qualname.as_slice(), variant.node.id); self.visit_ty(&*field.node.ty); } @@ -701,7 +701,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { } self.process_generic_params(type_parameters, item.span, "", item.id); - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { visit::walk_method_helper(self, &**method) @@ -729,7 +729,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { &val[]); // super-traits - for super_bound in trait_refs.iter() { + for super_bound in &**trait_refs { let trait_ref = match *super_bound { ast::TraitTyParamBound(ref trait_ref, _) => { trait_ref @@ -759,7 +759,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { // walk generics and methods self.process_generic_params(generics, item.span, &qualname[], item.id); - for method in methods.iter() { + for method in methods { self.visit_trait_item(method) } } @@ -912,11 +912,11 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { _ => None }; - for field in fields.iter() { + for field in fields { match struct_def { Some(struct_def) => { let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, struct_def); - for f in fields.iter() { + for f in &fields { if generated_code(field.ident.span) { continue; } @@ -1010,10 +1010,10 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> { self.span.snippet(p.span))[]); } }; - for &Spanned { node: ref field, span } in fields.iter() { + for &Spanned { node: ref field, span } in fields { let sub_span = self.span.span_for_first_ident(span); let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, struct_def); - for f in fields.iter() { + for f in fields { if f.name == field.ident.name { self.fmt.ref_str(recorder::VarRef, span, @@ -1104,7 +1104,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { let glob_map = &self.analysis.glob_map; let glob_map = glob_map.as_ref().unwrap(); if glob_map.contains_key(&item.id) { - for n in glob_map[item.id].iter() { + for n in &glob_map[item.id] { if name_string.len() > 0 { name_string.push_str(", "); } @@ -1122,7 +1122,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.write_sub_paths(path, true); } ast::ViewPathList(ref path, ref list) => { - for plid in list.iter() { + for plid in list { match plid.node { ast::PathListIdent { id, .. } => { match self.lookup_type_ref(id) { @@ -1208,8 +1208,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { } fn visit_generics(&mut self, generics: &ast::Generics) { - for param in generics.ty_params.iter() { - for bound in param.bounds.iter() { + for param in &*generics.ty_params { + for bound in &*param.bounds { if let ast::TraitTyParamBound(ref trait_ref, _) = *bound { self.process_trait_ref(&trait_ref.trait_ref); } @@ -1270,7 +1270,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { scope_id); // walk arg and return types - for arg in method_type.decl.inputs.iter() { + for arg in &method_type.decl.inputs { self.visit_ty(&*arg.ty); } @@ -1349,7 +1349,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { match *ty { ty::ty_struct(def_id, _) => { let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, def_id); - for f in fields.iter() { + for f in &fields { if f.name == ident.node.name { let sub_span = self.span.span_for_last_ident(ex.span); self.fmt.ref_str(recorder::VarRef, @@ -1404,7 +1404,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { self.process_formals(&decl.inputs, &id[]); // walk arg and return types - for arg in decl.inputs.iter() { + for arg in &decl.inputs { self.visit_ty(&*arg.ty); } @@ -1435,7 +1435,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { fn visit_arm(&mut self, arm: &ast::Arm) { assert!(self.collected_paths.len() == 0 && !self.collecting); self.collecting = true; - for pattern in arm.pats.iter() { + for pattern in &arm.pats { // collect paths from the arm's patterns self.visit_pat(&**pattern); } @@ -1443,7 +1443,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { // This is to get around borrow checking, because we need mut self to call process_path. let mut paths_to_process = vec![]; // process collected paths - for &(id, ref p, ref immut, ref_kind) in self.collected_paths.iter() { + for &(id, ref p, ref immut, ref_kind) in &self.collected_paths { let def_map = self.analysis.ty_cx.def_map.borrow(); if !def_map.contains_key(&id) { self.sess.span_bug(p.span, @@ -1477,7 +1477,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { *def) } } - for &(id, ref path, ref_kind) in paths_to_process.iter() { + for &(id, ref path, ref_kind) in &paths_to_process { self.process_path(id, path.span, path, ref_kind); } self.collecting = false; @@ -1508,7 +1508,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> { let value = self.span.snippet(l.span); - for &(id, ref p, ref immut, _) in self.collected_paths.iter() { + for &(id, ref p, ref immut, _) in &self.collected_paths { let value = if *immut { value.to_string() } else { "".to_string() }; let types = self.analysis.ty_cx.node_types.borrow(); let typ = ppaux::ty_to_string(&self.analysis.ty_cx, (*types)[id]); diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index b66e2770815..52fe8797592 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -366,7 +366,7 @@ impl<'a, 'p, 'blk, 'tcx> Repr<'tcx> for Match<'a, 'p, 'blk, 'tcx> { } fn has_nested_bindings(m: &[Match], col: uint) -> bool { - for br in m.iter() { + for br in m { match br.pats[col].node { ast::PatIdent(_, _, Some(_)) => return true, _ => () @@ -561,7 +561,7 @@ fn get_branches<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let tcx = bcx.tcx(); let mut found: Vec = vec![]; - for br in m.iter() { + for br in m { let cur = br.pats[col]; let opt = match cur.node { ast::PatLit(ref l) => ConstantValue(ConstantExpr(&**l)), @@ -827,7 +827,7 @@ fn insert_lllocals<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, bindings_map: &BindingsMap<'tcx>, cs: Option) -> Block<'blk, 'tcx> { - for (&ident, &binding_info) in bindings_map.iter() { + for (&ident, &binding_info) in bindings_map { let llval = match binding_info.trmode { // By value mut binding for a copy type: load from the ptr // into the matched value and copy to our alloca @@ -883,7 +883,7 @@ fn compile_guard<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let val = unpack_datum!(bcx, expr::trans(bcx, guard_expr)); let val = val.to_llbool(bcx); - for (_, &binding_info) in data.bindings_map.iter() { + for (_, &binding_info) in &data.bindings_map { if let TrByCopy(llbinding) = binding_info.trmode { call_lifetime_end(bcx, llbinding); } @@ -891,7 +891,7 @@ fn compile_guard<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, with_cond(bcx, Not(bcx, val, guard_expr.debug_loc()), |bcx| { // Guard does not match: remove all bindings from the lllocals table - for (_, &binding_info) in data.bindings_map.iter() { + for (_, &binding_info) in &data.bindings_map { call_lifetime_end(bcx, binding_info.llmatch); bcx.fcx.lllocals.borrow_mut().remove(&binding_info.id); } @@ -949,7 +949,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } None => { let data = &m[0].data; - for &(ref ident, ref value_ptr) in m[0].bound_ptrs.iter() { + for &(ref ident, ref value_ptr) in &m[0].bound_ptrs { let llmatch = data.bindings_map[*ident].llmatch; call_lifetime_start(bcx, llmatch); Store(bcx, *value_ptr, llmatch); @@ -1055,7 +1055,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, Variant(_, ref repr, _) => { let (the_kind, val_opt) = adt::trans_switch(bcx, &**repr, val); kind = the_kind; - for &tval in val_opt.iter() { test_val = tval; } + if let Some(tval) = val_opt { test_val = tval; } } SliceLengthEqual(_) | SliceLengthGreaterOrEqual(_, _) => { let (_, len) = tvec::get_base_and_len(bcx, val, left_ty); @@ -1064,7 +1064,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, } } } - for o in opts.iter() { + for o in &opts { match *o { ConstantRange(_, _) => { kind = Compare; break }, SliceLengthGreaterOrEqual(_, _) => { kind = CompareSliceLength; break }, @@ -1410,7 +1410,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>, compile_submatch(bcx, &matches[], &[discr_datum.val], &chk, has_default); let mut arm_cxs = Vec::new(); - for arm_data in arm_datas.iter() { + for arm_data in &arm_datas { let mut bcx = arm_data.bodycx; // insert bindings into the lllocals map and add cleanups @@ -1623,7 +1623,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, }); } - for inner_pat in inner.iter() { + if let Some(ref inner_pat) = *inner { bcx = bind_irrefutable_pat(bcx, &**inner_pat, val, cleanup_scope); } } @@ -1639,7 +1639,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, &*repr, vinfo.disr_val, val); - for sub_pat in sub_pats.iter() { + if let Some(ref sub_pat) = *sub_pats { for (i, &argval) in args.vals.iter().enumerate() { bcx = bind_irrefutable_pat(bcx, &*sub_pat[i], argval, cleanup_scope); @@ -1673,7 +1673,7 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let pat_ty = node_id_type(bcx, pat.id); let pat_repr = adt::represent_type(bcx.ccx(), pat_ty); expr::with_field_tys(tcx, pat_ty, Some(pat.id), |discr, field_tys| { - for f in fields.iter() { + for f in fields { let ix = ty::field_idx_strict(tcx, f.node.ident.name, field_tys); let fldptr = adt::trans_field_ptr(bcx, &*pat_repr, val, discr, ix); diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 1deb07e1ba0..b99622ce911 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -285,7 +285,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // alignment of the type. let (_, align) = union_size_and_align(fields.as_slice()); let mut use_align = true; - for st in fields.iter() { + for st in &fields { // Get the first non-zero-sized field let field = st.fields.iter().skip(1).filter(|ty| { let t = type_of::sizing_type_of(cx, **ty); @@ -519,7 +519,7 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp cx.tcx().sess.bug("range_to_inttype: found ReprPacked on an enum"); } } - for &ity in attempts.iter() { + for &ity in attempts { if bounds_usable(cx, ity, bounds) { return ity; } @@ -563,7 +563,7 @@ fn ensure_struct_fits_in_address_space<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, packed: bool, scapegoat: Ty<'tcx>) { let mut offset = 0; - for &llty in fields.iter() { + for &llty in fields { // Invariant: offset < ccx.obj_size_bound() <= 1<<61 if !packed { let type_align = machine::llalign_of_min(ccx, llty); @@ -1097,7 +1097,7 @@ fn compute_struct_field_offsets<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, let mut offsets = vec!(); let mut offset = 0; - for &ty in st.fields.iter() { + for &ty in &st.fields { let llty = type_of::sizing_type_of(ccx, ty); if !st.packed { let type_align = type_of::align_of(ccx, ty); diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index a7afa17ab72..e4077f26ba8 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -350,7 +350,7 @@ pub fn get_extern_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: ast::DefId, // don't do this then linker errors can be generated where the linker // complains that one object files has a thread local version of the // symbol and another one doesn't. - for attr in ty::get_attrs(ccx.tcx(), did).iter() { + for attr in &*ty::get_attrs(ccx.tcx(), did) { if attr.check_name("thread_local") { llvm::set_thread_local(c, true); } @@ -442,7 +442,7 @@ pub fn set_llvm_fn_attrs(ccx: &CrateContext, attrs: &[ast::Attribute], llfn: Val InlineNone => { /* fallthrough */ } } - for attr in attrs.iter() { + for attr in attrs { let mut used = true; match attr.name().get() { "no_stack_check" => unset_split_stack(llfn), @@ -765,7 +765,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, n_variants); let next_cx = fcx.new_temp_block("enum-iter-next"); - for variant in (*variants).iter() { + for variant in &(*variants) { let variant_cx = fcx.new_temp_block( &format!("enum-iter-variant-{}", @@ -970,7 +970,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if need_invoke(bcx) { debug!("invoking {} at {:?}", bcx.val_to_string(llfn), bcx.llbb); - for &llarg in llargs.iter() { + for &llarg in llargs { debug!("arg: {}", bcx.val_to_string(llarg)); } let normal_bcx = bcx.fcx.new_temp_block("normal-return"); @@ -986,7 +986,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, return (llresult, normal_bcx); } else { debug!("calling {} at {:?}", bcx.val_to_string(llfn), bcx.llbb); - for &llarg in llargs.iter() { + for &llarg in llargs { debug!("arg: {}", bcx.val_to_string(llarg)); } @@ -1830,7 +1830,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, vec![ty::mk_tup(ccx.tcx(), monomorphized_arg_types)] } }; - for monomorphized_arg_type in monomorphized_arg_types.iter() { + for monomorphized_arg_type in &monomorphized_arg_types { debug!("trans_closure: monomorphized_arg_type: {}", ty_to_string(ccx.tcx(), *monomorphized_arg_type)); } @@ -1908,7 +1908,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>, // This somewhat improves single-stepping experience in debugger. unsafe { let llreturn = fcx.llreturn.get(); - for &llreturn in llreturn.iter() { + if let Some(llreturn) = llreturn { llvm::LLVMMoveBasicBlockAfter(llreturn, bcx.llbb); } } @@ -2109,7 +2109,7 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span, let avar = adt::represent_type(ccx, ty); match *avar { adt::General(_, ref variants, _) => { - for var in variants.iter() { + for var in variants { let mut size = 0; for field in var.fields.iter().skip(1) { // skip the discriminant @@ -2382,7 +2382,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) { // and control visibility. pub fn trans_mod(ccx: &CrateContext, m: &ast::Mod) { let _icx = push_ctxt("trans_mod"); - for item in m.items.iter() { + for item in &m.items { trans_item(ccx, &**item); } } @@ -3161,7 +3161,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) stats.fn_stats.borrow_mut().sort_by(|&(_, insns_a), &(_, insns_b)| { insns_b.cmp(&insns_a) }); - for tuple in stats.fn_stats.borrow().iter() { + for tuple in &*stats.fn_stats.borrow() { match *tuple { (ref name, insns) => { println!("{} insns, {}", insns, *name); @@ -3170,7 +3170,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>) } } if shared_ccx.sess().count_llvm_insns() { - for (k, v) in shared_ccx.stats().llvm_insns.borrow().iter() { + for (k, v) in &*shared_ccx.stats().llvm_insns.borrow() { println!("{:7} {}", *v, *k); } } diff --git a/src/librustc_trans/trans/cabi_aarch64.rs b/src/librustc_trans/trans/cabi_aarch64.rs index ce1cf54919c..5d1e6d2c9e8 100644 --- a/src/librustc_trans/trans/cabi_aarch64.rs +++ b/src/librustc_trans/trans/cabi_aarch64.rs @@ -150,7 +150,7 @@ pub fn compute_abi_info(ccx: &CrateContext, rty: Type, ret_def: bool) -> FnType { let mut arg_tys = Vec::new(); - for &aty in atys.iter() { + for &aty in atys { let ty = classify_arg_ty(ccx, aty); arg_tys.push(ty); } diff --git a/src/librustc_trans/trans/cabi_arm.rs b/src/librustc_trans/trans/cabi_arm.rs index ac32ce49511..50014230df6 100644 --- a/src/librustc_trans/trans/cabi_arm.rs +++ b/src/librustc_trans/trans/cabi_arm.rs @@ -186,7 +186,7 @@ pub fn compute_abi_info(ccx: &CrateContext, }; let mut arg_tys = Vec::new(); - for &aty in atys.iter() { + for &aty in atys { let ty = classify_arg_ty(ccx, aty, align_fn); arg_tys.push(ty); } diff --git a/src/librustc_trans/trans/cabi_mips.rs b/src/librustc_trans/trans/cabi_mips.rs index af7956b46be..fecd1a9013b 100644 --- a/src/librustc_trans/trans/cabi_mips.rs +++ b/src/librustc_trans/trans/cabi_mips.rs @@ -176,7 +176,7 @@ pub fn compute_abi_info(ccx: &CrateContext, let mut arg_tys = Vec::new(); let mut offset = if sret { 4 } else { 0 }; - for aty in atys.iter() { + for aty in atys { let ty = classify_arg_ty(ccx, *aty, &mut offset); arg_tys.push(ty); }; diff --git a/src/librustc_trans/trans/cabi_powerpc.rs b/src/librustc_trans/trans/cabi_powerpc.rs index c3b0026de98..9583158a0e2 100644 --- a/src/librustc_trans/trans/cabi_powerpc.rs +++ b/src/librustc_trans/trans/cabi_powerpc.rs @@ -171,7 +171,7 @@ pub fn compute_abi_info(ccx: &CrateContext, let mut arg_tys = Vec::new(); let mut offset = if sret { 4 } else { 0 }; - for aty in atys.iter() { + for aty in atys { let ty = classify_arg_ty(ccx, *aty, &mut offset); arg_tys.push(ty); }; diff --git a/src/librustc_trans/trans/cabi_x86.rs b/src/librustc_trans/trans/cabi_x86.rs index 32f6eb060c0..028d20f3084 100644 --- a/src/librustc_trans/trans/cabi_x86.rs +++ b/src/librustc_trans/trans/cabi_x86.rs @@ -60,7 +60,7 @@ pub fn compute_abi_info(ccx: &CrateContext, ret_ty = ArgType::direct(rty, None, None, attr); } - for &t in atys.iter() { + for &t in atys { let ty = match t.kind() { Struct => { let size = llsize_of_alloc(ccx, t); diff --git a/src/librustc_trans/trans/cabi_x86_64.rs b/src/librustc_trans/trans/cabi_x86_64.rs index c0ab0d24dab..22318fb6c14 100644 --- a/src/librustc_trans/trans/cabi_x86_64.rs +++ b/src/librustc_trans/trans/cabi_x86_64.rs @@ -195,7 +195,7 @@ fn classify_ty(ty: Type) -> Vec { off: uint, packed: bool) { let mut field_off = off; - for ty in tys.iter() { + for ty in tys { if !packed { field_off = align(field_off, *ty); } @@ -333,7 +333,7 @@ fn classify_ty(ty: Type) -> Vec { fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type { fn llvec_len(cls: &[RegClass]) -> uint { let mut len = 1; - for c in cls.iter() { + for c in cls { if *c != SSEUp { break; } @@ -413,7 +413,7 @@ pub fn compute_abi_info(ccx: &CrateContext, } let mut arg_tys = Vec::new(); - for t in atys.iter() { + for t in atys { let ty = x86_64_ty(ccx, *t, |cls| cls.is_pass_byval(), ByValAttribute); arg_tys.push(ty); } diff --git a/src/librustc_trans/trans/cabi_x86_win64.rs b/src/librustc_trans/trans/cabi_x86_win64.rs index 79e309dacaa..9b34c3bf262 100644 --- a/src/librustc_trans/trans/cabi_x86_win64.rs +++ b/src/librustc_trans/trans/cabi_x86_win64.rs @@ -38,7 +38,7 @@ pub fn compute_abi_info(ccx: &CrateContext, ret_ty = ArgType::direct(rty, None, None, attr); } - for &t in atys.iter() { + for &t in atys { let ty = match t.kind() { Struct => { match llsize_of_alloc(ccx, t) { diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs index 096ea22eaac..ac76b52598d 100644 --- a/src/librustc_trans/trans/cleanup.rs +++ b/src/librustc_trans/trans/cleanup.rs @@ -72,7 +72,7 @@ impl<'blk, 'tcx: 'blk> fmt::Debug for CleanupScopeKind<'blk, 'tcx> { AstScopeKind(nid) => write!(f, "AstScopeKind({})", nid), LoopScopeKind(nid, ref blks) => { try!(write!(f, "LoopScopeKind({}, [", nid)); - for blk in blks.iter() { + for blk in blks { try!(write!(f, "{:p}, ", blk)); } write!(f, "])") diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index 5782b3987cb..392d320f166 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -515,7 +515,7 @@ impl<'a, 'tcx> FunctionContext<'a, 'tcx> { -> Block<'a, 'tcx> { let out = self.new_id_block("join", id); let mut reachable = false; - for bcx in in_cxs.iter() { + for bcx in in_cxs { if !bcx.unreachable.get() { build::Br(*bcx, out.llbb, DebugLoc::None); reachable = true; diff --git a/src/librustc_trans/trans/controlflow.rs b/src/librustc_trans/trans/controlflow.rs index c4388603145..651058a5674 100644 --- a/src/librustc_trans/trans/controlflow.rs +++ b/src/librustc_trans/trans/controlflow.rs @@ -96,7 +96,7 @@ pub fn trans_block<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, debuginfo::get_cleanup_debug_loc_for_ast_node(bcx.ccx(), b.id, b.span, true); fcx.push_ast_cleanup_scope(cleanup_debug_loc); - for s in b.stmts.iter() { + for s in &b.stmts { bcx = trans_stmt(bcx, &**s); } diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index 258a6fb958d..9032eaeae50 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -375,7 +375,7 @@ impl<'tcx> TypeMap<'tcx> { }, ty::ty_tup(ref component_types) => { unique_type_id.push_str("tuple "); - for &component_type in component_types.iter() { + for &component_type in component_types { let component_type_id = self.get_unique_type_id_of_type(cx, component_type); let component_type_id = @@ -447,7 +447,7 @@ impl<'tcx> TypeMap<'tcx> { let sig = ty::erase_late_bound_regions(cx.tcx(), sig); - for ¶meter_type in sig.inputs.iter() { + for ¶meter_type in &sig.inputs { let parameter_type_id = self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = @@ -533,7 +533,7 @@ impl<'tcx> TypeMap<'tcx> { if tps.len() > 0 { output.push('<'); - for &type_parameter in tps.iter() { + for &type_parameter in tps { let param_type_id = type_map.get_unique_type_id_of_type(cx, type_parameter); let param_type_id = @@ -563,7 +563,7 @@ impl<'tcx> TypeMap<'tcx> { let sig = ty::erase_late_bound_regions(cx.tcx(), sig); - for ¶meter_type in sig.inputs.iter() { + for ¶meter_type in &sig.inputs { let parameter_type_id = self.get_unique_type_id_of_type(cx, parameter_type); let parameter_type_id = @@ -1440,7 +1440,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } // Arguments types - for arg in fn_decl.inputs.iter() { + for arg in &fn_decl.inputs { assert_type_for_node_id(cx, arg.pat.id, arg.pat.span); let arg_type = ty::node_id_to_type(cx.tcx(), arg.pat.id); let arg_type = monomorphize::apply_param_substs(cx.tcx(), @@ -2838,7 +2838,7 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }); // regular arguments - for &argument_type in signature.inputs.iter() { + for &argument_type in &signature.inputs { signature_metadata.push(type_metadata(cx, argument_type, span)); } @@ -3226,7 +3226,7 @@ fn create_scope_map(cx: &CrateContext, // Push argument identifiers onto the stack so arguments integrate nicely // with variable shadowing. - for arg in args.iter() { + for arg in args { pat_util::pat_bindings(def_map, &*arg.pat, |_, node_id, _, path1| { scope_stack.push(ScopeStackEntry { scope_metadata: fn_metadata, ident: Some(path1.node) }); @@ -3292,7 +3292,7 @@ fn create_scope_map(cx: &CrateContext, scope_map.insert(block.id, scope_stack.last().unwrap().scope_metadata); // The interesting things here are statements and the concluding expression. - for statement in block.stmts.iter() { + for statement in &block.stmts { scope_map.insert(ast_util::stmt_id(&**statement), scope_stack.last().unwrap().scope_metadata); @@ -3306,7 +3306,7 @@ fn create_scope_map(cx: &CrateContext, } } - for exp in block.expr.iter() { + if let Some(ref exp) = block.expr { walk_expr(cx, &**exp, scope_stack, scope_map); } } @@ -3321,7 +3321,7 @@ fn create_scope_map(cx: &CrateContext, walk_pattern(cx, &*local.pat, scope_stack, scope_map); - for exp in local.init.iter() { + if let Some(ref exp) = local.init { walk_expr(cx, &**exp, scope_stack, scope_map); } } @@ -3407,7 +3407,7 @@ fn create_scope_map(cx: &CrateContext, scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); - for sub_pat in sub_pat_opt.iter() { + if let Some(ref sub_pat) = *sub_pat_opt { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } } @@ -3419,8 +3419,8 @@ fn create_scope_map(cx: &CrateContext, ast::PatEnum(_, ref sub_pats_opt) => { scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); - for sub_pats in sub_pats_opt.iter() { - for p in sub_pats.iter() { + if let Some(ref sub_pats) = *sub_pats_opt { + for p in sub_pats { walk_pattern(cx, &**p, scope_stack, scope_map); } } @@ -3440,7 +3440,7 @@ fn create_scope_map(cx: &CrateContext, ast::PatTup(ref sub_pats) => { scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); - for sub_pat in sub_pats.iter() { + for sub_pat in sub_pats { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } } @@ -3464,15 +3464,15 @@ fn create_scope_map(cx: &CrateContext, ast::PatVec(ref front_sub_pats, ref middle_sub_pats, ref back_sub_pats) => { scope_map.insert(pat.id, scope_stack.last().unwrap().scope_metadata); - for sub_pat in front_sub_pats.iter() { + for sub_pat in front_sub_pats { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } - for sub_pat in middle_sub_pats.iter() { + if let Some(ref sub_pat) = *middle_sub_pats { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } - for sub_pat in back_sub_pats.iter() { + for sub_pat in back_sub_pats { walk_pattern(cx, &**sub_pat, scope_stack, scope_map); } } @@ -3534,7 +3534,7 @@ fn create_scope_map(cx: &CrateContext, ast::ExprVec(ref init_expressions) | ast::ExprTup(ref init_expressions) => { - for ie in init_expressions.iter() { + for ie in init_expressions { walk_expr(cx, &**ie, scope_stack, scope_map); } } @@ -3612,7 +3612,7 @@ fn create_scope_map(cx: &CrateContext, scope_stack, scope_map, |cx, scope_stack, scope_map| { - for &ast::Arg { pat: ref pattern, .. } in decl.inputs.iter() { + for &ast::Arg { pat: ref pattern, .. } in &decl.inputs { walk_pattern(cx, &**pattern, scope_stack, scope_map); } @@ -3623,13 +3623,13 @@ fn create_scope_map(cx: &CrateContext, ast::ExprCall(ref fn_exp, ref args) => { walk_expr(cx, &**fn_exp, scope_stack, scope_map); - for arg_exp in args.iter() { + for arg_exp in args { walk_expr(cx, &**arg_exp, scope_stack, scope_map); } } ast::ExprMethodCall(_, _, ref args) => { - for arg_exp in args.iter() { + for arg_exp in args { walk_expr(cx, &**arg_exp, scope_stack, scope_map); } } @@ -3642,7 +3642,7 @@ fn create_scope_map(cx: &CrateContext, // walk only one pattern per arm, as they all must contain the // same binding names. - for arm_ref in arms.iter() { + for arm_ref in arms { let arm_span = arm_ref.pats[0].span; with_new_scope(cx, @@ -3650,11 +3650,11 @@ fn create_scope_map(cx: &CrateContext, scope_stack, scope_map, |cx, scope_stack, scope_map| { - for pat in arm_ref.pats.iter() { + for pat in &arm_ref.pats { walk_pattern(cx, &**pat, scope_stack, scope_map); } - for guard_exp in arm_ref.guard.iter() { + if let Some(ref guard_exp) = arm_ref.guard { walk_expr(cx, &**guard_exp, scope_stack, scope_map) } @@ -3664,7 +3664,7 @@ fn create_scope_map(cx: &CrateContext, } ast::ExprStruct(_, ref fields, ref base_exp) => { - for &ast::Field { expr: ref exp, .. } in fields.iter() { + for &ast::Field { expr: ref exp, .. } in fields { walk_expr(cx, &**exp, scope_stack, scope_map); } @@ -3678,11 +3678,11 @@ fn create_scope_map(cx: &CrateContext, ref outputs, .. }) => { // inputs, outputs: Vec<(String, P)> - for &(_, ref exp) in inputs.iter() { + for &(_, ref exp) in inputs { walk_expr(cx, &**exp, scope_stack, scope_map); } - for &(_, ref exp, _) in outputs.iter() { + for &(_, ref exp, _) in outputs { walk_expr(cx, &**exp, scope_stack, scope_map); } } @@ -3737,7 +3737,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }, ty::ty_tup(ref component_types) => { output.push('('); - for &component_type in component_types.iter() { + for &component_type in component_types { push_debuginfo_type_name(cx, component_type, true, output); output.push_str(", "); } @@ -3802,7 +3802,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let sig = ty::erase_late_bound_regions(cx.tcx(), sig); if sig.inputs.len() > 0 { - for ¶meter_type in sig.inputs.iter() { + for ¶meter_type in &sig.inputs { push_debuginfo_type_name(cx, parameter_type, true, output); output.push_str(", "); } diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index cf85389cd5b..bed43a5c838 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -1451,7 +1451,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let custom_cleanup_scope = fcx.push_custom_cleanup_scope(); // First we trans the base, if we have one, to the dest - for base in optbase.iter() { + if let Some(base) = optbase { assert_eq!(discr, 0); match ty::expr_kind(bcx.tcx(), &*base.expr) { @@ -1461,7 +1461,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, ty::RvalueStmtExpr => bcx.tcx().sess.bug("unexpected expr kind for struct base expr"), _ => { let base_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, &*base.expr, "base")); - for &(i, t) in base.fields.iter() { + for &(i, t) in &base.fields { let datum = base_datum.get_element( bcx, t, |srcval| adt::trans_field_ptr(bcx, &*repr, srcval, discr, i)); assert!(type_is_sized(bcx.tcx(), datum.ty)); @@ -1485,7 +1485,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, // (i.e. avoid GEPi and `store`s to an alloca) . let mut vec_val = C_undef(llty); - for &(i, ref e) in fields.iter() { + for &(i, ref e) in fields { let block_datum = trans(bcx, &**e); bcx = block_datum.bcx; let position = C_uint(bcx.ccx(), i); @@ -1495,7 +1495,7 @@ pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, Store(bcx, vec_val, addr); } else { // Now, we just overwrite the fields we've explicitly specified - for &(i, ref e) in fields.iter() { + for &(i, ref e) in fields { let dest = adt::trans_field_ptr(bcx, &*repr, addr, discr, i); let e_ty = expr_ty_adjusted(bcx, &**e); bcx = trans_into(bcx, &**e, SaveIn(dest)); diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 6c017866ef0..00bb3036546 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -352,7 +352,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } arg_idx += 1; - for arg_ty in fn_type.arg_tys.iter() { + for arg_ty in &fn_type.arg_tys { if arg_ty.is_ignore() { continue; } @@ -453,7 +453,7 @@ fn gate_simd_ffi(tcx: &ty::ctxt, decl: &ast::FnDecl, ty: &ty::BareFnTy) { pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) { let _icx = push_ctxt("foreign::trans_foreign_mod"); - for foreign_item in foreign_mod.items.iter() { + for foreign_item in &foreign_mod.items { let lname = link_name(&**foreign_item); if let ast::ForeignItemFn(ref decl, _) = foreign_item.node { @@ -936,7 +936,7 @@ fn lltype_for_fn_from_foreign_types(ccx: &CrateContext, tys: &ForeignTypes) -> T } }; - for &arg_ty in tys.fn_ty.arg_tys.iter() { + for &arg_ty in &tys.fn_ty.arg_tys { if arg_ty.is_ignore() { continue; } @@ -987,7 +987,7 @@ fn add_argument_attributes(tys: &ForeignTypes, i += 1; - for &arg_ty in tys.fn_ty.arg_tys.iter() { + for &arg_ty in &tys.fn_ty.arg_tys { if arg_ty.is_ignore() { continue; } diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 497237da38c..5d26daab5cd 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -572,7 +572,7 @@ pub fn emit_tydescs(ccx: &CrateContext) { // As of this point, allow no more tydescs to be created. ccx.finished_tydescs().set(true); let glue_fn_ty = Type::generic_glue_fn(ccx).ptr_to(); - for (_, ti) in ccx.tydescs().borrow().iter() { + for (_, ti) in &*ccx.tydescs().borrow() { // Each of the glue functions needs to be cast to a generic type // before being put into the tydesc because we only have a singleton // tydesc type. Then we'll recast each function to its real type when diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs index 9bee2c5bbc6..340fcb76058 100644 --- a/src/librustc_trans/trans/intrinsic.rs +++ b/src/librustc_trans/trans/intrinsic.rs @@ -92,7 +92,7 @@ pub fn get_simple_intrinsic(ccx: &CrateContext, item: &ast::ForeignItem) -> Opti /// the only intrinsic that needs such verification is `transmute`. pub fn check_intrinsics(ccx: &CrateContext) { let mut last_failing_id = None; - for transmute_restriction in ccx.tcx().transmute_restrictions.borrow().iter() { + for transmute_restriction in &*ccx.tcx().transmute_restrictions.borrow() { // Sometimes, a single call to transmute will push multiple // type pairs to test in order to exhaustively test the // possibility around a type parameter. If one of those fails, diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index 335c639df90..f522024c2e7 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -65,7 +65,7 @@ pub fn trans_impl(ccx: &CrateContext, // items that we need to translate. if !generics.ty_params.is_empty() { let mut v = TransItemVisitor{ ccx: ccx }; - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { visit::walk_method_helper(&mut v, &**method); @@ -75,7 +75,7 @@ pub fn trans_impl(ccx: &CrateContext, } return; } - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { if method.pe_generics().ty_params.len() == 0 { diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index 844795b667b..66f603cbe07 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -263,7 +263,7 @@ pub fn write_content<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ast::ExprVec(ref elements) => { match dest { Ignore => { - for element in elements.iter() { + for element in elements { bcx = expr::trans_into(bcx, &**element, Ignore); } } diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 6b6ca600a88..2243982c20d 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -84,7 +84,7 @@ pub fn untuple_arguments_if_necessary<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, match inputs[inputs.len() - 1].sty { ty::ty_tup(ref tupled_arguments) => { debug!("untuple_arguments_if_necessary(): untupling arguments"); - for &tupled_argument in tupled_arguments.iter() { + for &tupled_argument in tupled_arguments { result.push(tupled_argument); } } diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 350227c6662..d14945d1c9f 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -373,7 +373,7 @@ fn create_substs_for_ast_path<'tcx>( } } - for param in ty_param_defs[supplied_ty_param_count..].iter() { + for param in &ty_param_defs[supplied_ty_param_count..] { match param.default { Some(default) => { // This is a default type parameter. @@ -659,7 +659,7 @@ fn ast_path_to_trait_ref<'a,'tcx>( prohibit_projections(this.tcx(), assoc_bindings.as_slice()); } Some(ref mut v) => { - for binding in assoc_bindings.iter() { + for binding in &assoc_bindings { match ast_type_binding_to_projection_predicate(this, trait_ref.clone(), self_ty, binding) { Ok(pp) => { v.push(pp); } @@ -979,7 +979,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>, token::get_name(assoc_name), token::get_name(ty_param_name)); - for suitable_bound in suitable_bounds.iter() { + for suitable_bound in &suitable_bounds { span_note!(this.tcx().sess, ast_ty.span, "associated type `{}` could derive from `{}`", token::get_name(ty_param_name), @@ -1710,7 +1710,7 @@ pub fn partition_bounds<'a>(tcx: &ty::ctxt, let mut region_bounds = Vec::new(); let mut trait_bounds = Vec::new(); let mut trait_def_ids = DefIdMap(); - for ast_bound in ast_bounds.iter() { + for ast_bound in ast_bounds { match *ast_bound { ast::TraitTyParamBound(ref b, ast::TraitBoundModifier::None) => { match ::lookup_def_tcx(tcx, b.trait_ref.path.span, b.trait_ref.ref_id) { diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index c4b7ffb8729..174a9029534 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -240,7 +240,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, // below for details. demand::eqtype(fcx, pat.span, expected, pat_ty); - for elt in before.iter() { + for elt in before { check_pat(pcx, &**elt, inner_ty); } if let Some(ref slice) = *slice { @@ -254,7 +254,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, }); check_pat(pcx, &**slice, slice_ty); } - for elt in after.iter() { + for elt in after { check_pat(pcx, &**elt, inner_ty); } } @@ -348,12 +348,12 @@ pub fn check_match<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Typecheck the patterns first, so that we get types for all the // bindings. - for arm in arms.iter() { + for arm in arms { let mut pcx = pat_ctxt { fcx: fcx, map: pat_id_map(&tcx.def_map, &*arm.pats[0]), }; - for p in arm.pats.iter() { + for p in &arm.pats { check_pat(&mut pcx, &**p, discrim_ty); } } @@ -439,7 +439,7 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat, "use of trait `{}` in a struct pattern", name); fcx.write_error(pat.id); - for field in fields.iter() { + for field in fields { check_pat(pcx, &*field.node.pat, tcx.types.err); } return; @@ -458,7 +458,7 @@ pub fn check_pat_struct<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pat: &'tcx ast::Pat, "`{}` does not name a struct or a struct variant", name); fcx.write_error(pat.id); - for field in fields.iter() { + for field in fields { check_pat(pcx, &*field.node.pat, tcx.types.err); } return; @@ -540,7 +540,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, fcx.write_error(pat.id); if let Some(subpats) = subpats { - for pat in subpats.iter() { + for pat in subpats { check_pat(pcx, &**pat, tcx.types.err); } } @@ -558,7 +558,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, "this pattern has {} field{}, but the corresponding {} has no fields", subpats.len(), if subpats.len() == 1 {""} else {"s"}, kind_name); - for pat in subpats.iter() { + for pat in subpats { check_pat(pcx, &**pat, tcx.types.err); } } else { @@ -568,7 +568,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, kind_name, arg_tys.len(), if arg_tys.len() == 1 {""} else {"s"}); - for pat in subpats.iter() { + for pat in subpats { check_pat(pcx, &**pat, tcx.types.err); } } @@ -598,7 +598,7 @@ pub fn check_struct_pat_fields<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, let mut used_fields = FnvHashMap(); // Typecheck each field. - for &Spanned { node: ref field, span } in fields.iter() { + for &Spanned { node: ref field, span } in fields { let field_type = match used_fields.entry(field.ident.name) { Occupied(occupied) => { span_err!(tcx.sess, span, E0025, diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index e9ea0921bc9..8ad67b43178 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -134,7 +134,7 @@ pub fn probe<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Create a list of simplified self types, if we can. let mut simplified_steps = Vec::new(); - for step in steps.iter() { + for step in &steps { match fast_reject::simplify_type(fcx.tcx(), step.self_ty, true) { None => { break; } Some(simplified_type) => { simplified_steps.push(simplified_type); } @@ -236,7 +236,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { fn assemble_inherent_candidates(&mut self) { let steps = self.steps.clone(); - for step in steps.iter() { + for step in &*steps { self.assemble_probe(step.self_ty); } } @@ -268,8 +268,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // metadata if necessary. ty::populate_implementations_for_type_if_necessary(self.tcx(), def_id); - for impl_infos in self.tcx().inherent_impls.borrow().get(&def_id).iter() { - for &impl_def_id in impl_infos.iter() { + if let Some(impl_infos) = self.tcx().inherent_impls.borrow().get(&def_id) { + for &impl_def_id in &***impl_infos { self.assemble_inherent_impl_probe(impl_def_id); } } @@ -449,7 +449,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { let mut duplicates = HashSet::new(); let opt_applicable_traits = self.fcx.ccx.trait_map.get(&expr_id); for applicable_traits in opt_applicable_traits.into_iter() { - for &trait_did in applicable_traits.iter() { + for &trait_did in applicable_traits { if duplicates.insert(trait_did) { try!(self.assemble_extension_candidates_for_trait(trait_did)); } @@ -530,7 +530,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { Some(impls) => impls, }; - for &impl_def_id in impl_def_ids.borrow().iter() { + for &impl_def_id in &*impl_def_ids.borrow() { debug!("assemble_extension_candidates_for_trait_impl: trait_def_id={} impl_def_id={}", trait_def_id.repr(self.tcx()), impl_def_id.repr(self.tcx())); @@ -601,7 +601,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // Check if there is an unboxed-closure self-type in the list of receivers. // If so, add "synthetic impls". let steps = self.steps.clone(); - for step in steps.iter() { + for step in &*steps { let (closure_def_id, _, _) = match step.self_ty.sty { ty::ty_closure(a, b, ref c) => (a, b, c), _ => continue, @@ -653,7 +653,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { method.repr(self.tcx()), method_index); - for step in self.steps.iter() { + for step in &*self.steps { debug!("assemble_projection_candidates: step={}", step.repr(self.tcx())); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index c193e1ef483..a704508e6fa 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -735,7 +735,7 @@ pub fn check_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { None => { } } - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref m) => { check_method_body(ccx, &impl_pty.generics, &**m); @@ -750,7 +750,7 @@ pub fn check_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { ast::ItemTrait(_, ref generics, _, ref trait_methods) => { check_trait_on_unimplemented(ccx, generics, it); let trait_def = ty::lookup_trait_def(ccx.tcx, local_def(it.id)); - for trait_method in trait_methods.iter() { + for trait_method in trait_methods { match *trait_method { RequiredMethod(..) => { // Nothing to do, since required methods don't have @@ -774,11 +774,11 @@ pub fn check_item<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, it: &'tcx ast::Item) { } ast::ItemForeignMod(ref m) => { if m.abi == abi::RustIntrinsic { - for item in m.items.iter() { + for item in &m.items { check_intrinsic_type(ccx, &**item); } } else { - for item in m.items.iter() { + for item in &m.items { let pty = ty::lookup_item_type(ccx.tcx, local_def(item.id)); if !pty.generics.types.is_empty() { span_err!(ccx.tcx.sess, item.span, E0044, @@ -879,7 +879,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, // Check existing impl methods to see if they are both present in trait // and compatible with trait signature - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref impl_method) => { let impl_method_def_id = local_def(impl_method.id); @@ -969,7 +969,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, // Check for missing items from trait let provided_methods = ty::provided_trait_methods(tcx, impl_trait_ref.def_id); let mut missing_methods = Vec::new(); - for trait_item in trait_items.iter() { + for trait_item in &*trait_items { match *trait_item { ty::MethodTraitItem(ref trait_method) => { let is_implemented = @@ -2321,7 +2321,7 @@ fn check_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // of arguments when we typecheck the functions. This isn't really the // right way to do this. let xs = [false, true]; - for check_blocks in xs.iter() { + for check_blocks in &xs { let check_blocks = *check_blocks; debug!("check_blocks={}", check_blocks); @@ -3101,7 +3101,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let mut best_dist = name.len(); let fields = ty::lookup_struct_fields(tcx, id); let mut best = None; - for elem in fields.iter() { + for elem in &fields { let n = elem.name.as_str(); // ignore already set fields if skip.iter().any(|&x| x == n) { @@ -3199,14 +3199,14 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let mut class_field_map = FnvHashMap(); let mut fields_found = 0; - for field in field_types.iter() { + for field in field_types { class_field_map.insert(field.name, (field.id, false)); } let mut error_happened = false; // Typecheck each field. - for field in ast_fields.iter() { + for field in ast_fields { let mut expected_field_type = tcx.types.err; let pair = class_field_map.get(&field.ident.node.name).map(|x| *x); @@ -3273,7 +3273,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, assert!(fields_found <= field_types.len()); if fields_found < field_types.len() { let mut missing_fields = Vec::new(); - for class_field in field_types.iter() { + for class_field in field_types { let name = class_field.name; let (_, seen) = class_field_map[name]; if !seen { @@ -3374,7 +3374,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // Make sure to still write the types // otherwise we might ICE fcx.write_error(id); - for field in fields.iter() { + for field in fields { check_expr(fcx, &*field.expr); } match *base_expr { @@ -3628,10 +3628,10 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, constrain_path_type_parameters(fcx, expr); } ast::ExprInlineAsm(ref ia) => { - for &(_, ref input) in ia.inputs.iter() { + for &(_, ref input) in &ia.inputs { check_expr(fcx, &**input); } - for &(_, ref out, _) in ia.outputs.iter() { + for &(_, ref out, _) in &ia.outputs { check_expr(fcx, &**out); } fcx.write_nil(id); @@ -3764,14 +3764,14 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let typ = match uty { Some(uty) => { - for e in args.iter() { + for e in args { check_expr_coercable_to_type(fcx, &**e, uty); } uty } None => { let t: Ty = fcx.infcx().next_ty_var(); - for e in args.iter() { + for e in args { check_expr_has_type(fcx, &**e, t); } t @@ -4270,7 +4270,7 @@ fn check_block_with_expected<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, let mut warned = false; let mut any_diverges = false; let mut any_err = false; - for s in blk.stmts.iter() { + for s in &blk.stmts { check_stmt(fcx, &**s); let s_id = ast_util::stmt_id(&**s); let s_ty = fcx.node_ty(s_id); @@ -4506,7 +4506,7 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, let mut disr_vals: Vec = Vec::new(); let mut prev_disr_val: Option = None; - for v in vs.iter() { + for v in vs { // If the discriminant value is specified explicitly in the enum check whether the // initialization expression is valid, otherwise use the last value plus one. @@ -4838,7 +4838,7 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // variables. If the user provided some types, we may still need // to add defaults. If the user provided *too many* types, that's // a problem. - for &space in ParamSpace::all().iter() { + for &space in &ParamSpace::all() { adjust_type_parameters(fcx, span, space, type_defs, &mut substs); assert_eq!(substs.types.len(space), type_defs.len(space)); @@ -4870,13 +4870,13 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, fcx: &FnCtxt, segment: &ast::PathSegment) { - for typ in segment.parameters.types().iter() { + for typ in &segment.parameters.types() { span_err!(fcx.tcx().sess, typ.span, E0085, "type parameters may not appear here"); break; } - for lifetime in segment.parameters.lifetimes().iter() { + for lifetime in &segment.parameters.lifetimes() { span_err!(fcx.tcx().sess, lifetime.span, E0086, "lifetime parameters may not appear here"); break; diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index f8c7055a003..816edd92bf9 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -148,7 +148,7 @@ pub fn regionck_ensure_component_tys_wf<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, span: Span, component_tys: &[Ty<'tcx>]) { let mut rcx = Rcx::new(fcx, Repeating(0), SubjectNode::None); - for &component_ty in component_tys.iter() { + for &component_ty in component_tys { // Check that each type outlives the empty region. Since the // empty region is a subregion of all others, this can't fail // unless the type does not meet the well-formedness @@ -298,7 +298,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { .region_obligations(node_id) .to_vec(); - for r_o in region_obligations.iter() { + for r_o in ®ion_obligations { debug!("visit_region_obligations: r_o={}", r_o.repr(self.tcx())); let sup_type = self.resolve_type(r_o.sup_type); @@ -327,7 +327,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { debug!("relate_free_regions >>"); let tcx = self.tcx(); - for &ty in fn_sig_tys.iter() { + for &ty in fn_sig_tys { let ty = self.resolve_type(ty); debug!("relate_free_regions(t={})", ty.repr(tcx)); let body_scope = CodeExtent::from_node_id(body_id); @@ -337,7 +337,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> { tcx, ty, body_scope); - for constraint in constraints.iter() { + for constraint in &constraints { debug!("constraint: {}", constraint.repr(tcx)); match *constraint { regionmanip::RegionSubRegionConstraint(_, @@ -424,7 +424,7 @@ fn visit_block(rcx: &mut Rcx, b: &ast::Block) { fn visit_arm(rcx: &mut Rcx, arm: &ast::Arm) { // see above - for p in arm.pats.iter() { + for p in &arm.pats { constrain_bindings_in_pat(&**p, rcx); } @@ -487,13 +487,13 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) { let has_method_map = rcx.fcx.inh.method_map.borrow().contains_key(&method_call); // Check any autoderefs or autorefs that appear. - for &adjustment in rcx.fcx.inh.adjustments.borrow().get(&expr.id).iter() { + if let Some(adjustment) = rcx.fcx.inh.adjustments.borrow().get(&expr.id) { debug!("adjustment={:?}", adjustment); match *adjustment { ty::AdjustDerefRef(ty::AutoDerefRef {autoderefs, autoref: ref opt_autoref}) => { let expr_ty = rcx.resolve_node_type(expr.id); constrain_autoderefs(rcx, expr, autoderefs, expr_ty); - for autoref in opt_autoref.iter() { + if let Some(ref autoref) = *opt_autoref { link_autoref(rcx, expr, autoderefs, autoref); // Require that the resulting region encompasses @@ -753,7 +753,7 @@ fn check_expr_fn_block(rcx: &mut Rcx, debug!("ensure_free_variable_types_outlive_closure_bound({}, {})", bounds.region_bound.repr(tcx), expr.repr(tcx)); - for freevar in freevars.iter() { + for freevar in freevars { let var_node_id = { let def_id = freevar.def.def_id(); assert!(def_id.krate == ast::LOCAL_CRATE); @@ -779,7 +779,7 @@ fn check_expr_fn_block(rcx: &mut Rcx, }; // Check that the type meets the criteria of the existential bounds: - for builtin_bound in bounds.builtin_bounds.iter() { + for builtin_bound in &bounds.builtin_bounds { let code = traits::ClosureCapture(var_node_id, expr.span, builtin_bound); let cause = traits::ObligationCause::new(freevar.span, rcx.fcx.body_id, code); rcx.fcx.register_builtin_bound(var_ty, builtin_bound, cause); @@ -802,7 +802,7 @@ fn check_expr_fn_block(rcx: &mut Rcx, let tcx = rcx.fcx.ccx.tcx; debug!("constrain_captured_variables({}, {})", region_bound.repr(tcx), expr.repr(tcx)); - for freevar in freevars.iter() { + for freevar in freevars { debug!("constrain_captured_variables: freevar.def={:?}", freevar.def); // Identify the variable being closed over and its node-id. @@ -897,13 +897,13 @@ fn constrain_call<'a, I: Iterator>(rcx: &mut Rcx, } // as loop above, but for receiver - for r in receiver.iter() { + if let Some(r) = receiver { debug!("receiver: {}", r.repr(tcx)); type_of_node_must_outlive( rcx, infer::CallRcvr(r.span), r.id, callee_region); if implicitly_ref_args { - link_by_ref(rcx, &**r, callee_scope); + link_by_ref(rcx, &*r, callee_scope); } } } @@ -1079,8 +1079,8 @@ fn link_match(rcx: &Rcx, discr: &ast::Expr, arms: &[ast::Arm]) { let mc = mc::MemCategorizationContext::new(rcx.fcx); let discr_cmt = ignore_err!(mc.cat_expr(discr)); debug!("discr_cmt={}", discr_cmt.repr(rcx.tcx())); - for arm in arms.iter() { - for root_pat in arm.pats.iter() { + for arm in arms { + for root_pat in &arm.pats { link_pattern(rcx, mc, discr_cmt.clone(), &**root_pat); } } @@ -1092,7 +1092,7 @@ fn link_match(rcx: &Rcx, discr: &ast::Expr, arms: &[ast::Arm]) { fn link_fn_args(rcx: &Rcx, body_scope: CodeExtent, args: &[ast::Arg]) { debug!("regionck::link_fn_args(body_scope={:?})", body_scope); let mc = mc::MemCategorizationContext::new(rcx.fcx); - for arg in args.iter() { + for arg in args { let arg_ty = rcx.fcx.node_ty(arg.id); let re_scope = ty::ReScope(body_scope); let arg_cmt = mc.cat_rvalue(arg.id, arg.ty.span, re_scope, arg_ty); @@ -1418,7 +1418,7 @@ fn type_must_outlive<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>, rcx.tcx(), ty, region); - for constraint in constraints.iter() { + for constraint in &constraints { debug!("constraint: {}", constraint.repr(rcx.tcx())); match *constraint { regionmanip::RegionSubRegionConstraint(None, r_a, r_b) => { @@ -1479,7 +1479,7 @@ fn generic_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, // The problem is that the type of `x` is `&'a A`. To be // well-formed, then, A must be lower-generic by `'a`, but we // don't know that this holds from first principles. - for &(ref r, ref p) in rcx.region_bound_pairs.iter() { + for &(ref r, ref p) in &rcx.region_bound_pairs { debug!("generic={} p={}", generic.repr(rcx.tcx()), p.repr(rcx.tcx())); diff --git a/src/librustc_typeck/check/regionmanip.rs b/src/librustc_typeck/check/regionmanip.rs index cbd51a880ce..4a0e2acc854 100644 --- a/src/librustc_typeck/check/regionmanip.rs +++ b/src/librustc_typeck/check/regionmanip.rs @@ -126,7 +126,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { } ty::ty_tup(ref tuptys) => { - for &tupty in tuptys.iter() { + for &tupty in tuptys { self.accumulate_from_ty(tupty); } } @@ -236,7 +236,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { // Variance of each type/region parameter. let variances = ty::item_variances(self.tcx, def_id); - for &space in ParamSpace::all().iter() { + for &space in &ParamSpace::all() { let region_params = substs.regions().get_slice(space); let region_variances = variances.regions.get_slice(space); let region_param_defs = generics.regions.get_slice(space); @@ -272,7 +272,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { } } - for ®ion_bound in region_param_def.bounds.iter() { + for ®ion_bound in ®ion_param_def.bounds { // The type declared a constraint like // // 'b : 'a @@ -314,7 +314,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { // Inspect bounds on this type parameter for any // region bounds. - for &r in type_param_def.bounds.region_bounds.iter() { + for &r in &type_param_def.bounds.region_bounds { self.stack.push((r, Some(ty))); self.accumulate_from_ty(type_param_ty); self.stack.pop().unwrap(); @@ -368,7 +368,7 @@ impl<'a, 'tcx> Wf<'a, 'tcx> { // And then, in turn, to be well-formed, the // `region_bound` that user specified must imply the // region bounds required from all of the trait types: - for &r_d in required_region_bounds.iter() { + for &r_d in &required_region_bounds { // Each of these is an instance of the `'c <= 'b` // constraint above self.out.push(RegionSubRegionConstraint(Some(ty), r_d, r_c)); diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index f7babadd41f..b52e01f9a7a 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -138,7 +138,7 @@ impl<'a,'tcx> SeedBorrowKind<'a,'tcx> { } ty::with_freevars(self.tcx(), expr.id, |freevars| { - for freevar in freevars.iter() { + for freevar in freevars { let var_node_id = freevar.def.local_node_id(); let upvar_id = ty::UpvarId { var_id: var_node_id, closure_expr_id: expr.id }; diff --git a/src/librustc_typeck/check/vtable.rs b/src/librustc_typeck/check/vtable.rs index 5cf71a9be6a..43910a937e8 100644 --- a/src/librustc_typeck/check/vtable.rs +++ b/src/librustc_typeck/check/vtable.rs @@ -221,7 +221,7 @@ pub fn register_object_cast_obligations<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // bounds attached to the object cast. (In other words, if the // object type is Foo+Send, this would create an obligation // for the Send check.) - for builtin_bound in object_trait.bounds.builtin_bounds.iter() { + for builtin_bound in &object_trait.bounds.builtin_bounds { fcx.register_builtin_bound( referent_ty, builtin_bound, @@ -231,7 +231,7 @@ pub fn register_object_cast_obligations<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Create obligations for the projection predicates. let projection_bounds = object_trait.projection_bounds_with_self_ty(fcx.tcx(), referent_ty); - for projection_bound in projection_bounds.iter() { + for projection_bound in &projection_bounds { let projection_obligation = Obligation::new(cause.clone(), projection_bound.as_predicate()); fcx.register_predicate(projection_obligation); @@ -263,7 +263,7 @@ fn check_object_type_binds_all_associated_types<'tcx>(tcx: &ty::ctxt<'tcx>, }) .collect(); - for projection_bound in object_trait.bounds.projection_bounds.iter() { + for projection_bound in &object_trait.bounds.projection_bounds { let pair = (projection_bound.0.projection_ty.trait_ref.def_id, projection_bound.0.projection_ty.item_name); associated_types.remove(&pair); diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs index db226295cd9..24153fd94ea 100644 --- a/src/librustc_typeck/check/wf.rs +++ b/src/librustc_typeck/check/wf.rs @@ -147,15 +147,15 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> { item.span, region::CodeExtent::from_node_id(item.id), Some(&mut this.cache)); - for variant in variants.iter() { - for field in variant.fields.iter() { + for variant in &variants { + for field in &variant.fields { // Regions are checked below. bounds_checker.check_traits_in_ty(field.ty); } // For DST, all intermediate types must be sized. if variant.fields.len() > 0 { - for field in variant.fields.init().iter() { + for field in variant.fields.init() { fcx.register_builtin_bound( field.ty, ty::BoundSized, @@ -323,7 +323,7 @@ fn reject_shadowing_type_parameters<'tcx>(tcx: &ty::ctxt<'tcx>, let impl_params = generics.types.get_slice(subst::TypeSpace).iter() .map(|tp| tp.name).collect::>(); - for method_param in generics.types.get_slice(subst::FnSpace).iter() { + for method_param in generics.types.get_slice(subst::FnSpace) { if impl_params.contains(&method_param.name) { span_err!(tcx.sess, span, E0194, "type parameter `{}` shadows another type parameter of the same name", diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 0eaecf8ac05..52b1eb490cc 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -49,7 +49,7 @@ pub fn resolve_type_vars_in_fn(fcx: &FnCtxt, assert_eq!(fcx.writeback_errors.get(), false); let mut wbcx = WritebackCx::new(fcx); wbcx.visit_block(blk); - for arg in decl.inputs.iter() { + for arg in &decl.inputs { wbcx.visit_node_id(ResolvingPattern(arg.pat.span), arg.id); wbcx.visit_pat(&*arg.pat); @@ -119,7 +119,7 @@ impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx> { match e.node { ast::ExprClosure(_, _, ref decl, _) => { - for input in decl.inputs.iter() { + for input in &decl.inputs { let _ = self.visit_node_id(ResolvingExpr(e.span), input.id); } @@ -182,7 +182,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { return; } - for (upvar_id, upvar_capture) in self.fcx.inh.upvar_capture_map.borrow().iter() { + for (upvar_id, upvar_capture) in &*self.fcx.inh.upvar_capture_map.borrow() { let new_upvar_capture = match *upvar_capture { ty::UpvarCapture::ByValue => ty::UpvarCapture::ByValue, ty::UpvarCapture::ByRef(ref upvar_borrow) => { @@ -204,12 +204,12 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { return } - for (def_id, closure_ty) in self.fcx.inh.closure_tys.borrow().iter() { + for (def_id, closure_ty) in &*self.fcx.inh.closure_tys.borrow() { let closure_ty = self.resolve(closure_ty, ResolvingClosure(*def_id)); self.fcx.tcx().closure_tys.borrow_mut().insert(*def_id, closure_ty); } - for (def_id, &closure_kind) in self.fcx.inh.closure_kinds.borrow().iter() { + for (def_id, &closure_kind) in &*self.fcx.inh.closure_kinds.borrow() { self.fcx.tcx().closure_kinds.borrow_mut().insert(*def_id, closure_kind); } } diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 9760d5f05df..ed340b0882c 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -136,7 +136,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { // the tcx. let mut tcx_inherent_impls = self.crate_context.tcx.inherent_impls.borrow_mut(); - for (k, v) in self.inherent_impls.borrow().iter() { + for (k, v) in &*self.inherent_impls.borrow() { tcx_inherent_impls.insert((*k).clone(), Rc::new((*v.borrow()).clone())); } @@ -167,7 +167,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let impl_items = self.create_impl_from_item(item); - for associated_trait in associated_traits.iter() { + for associated_trait in associated_traits { let trait_ref = ty::node_id_to_trait_ref(self.crate_context.tcx, associated_trait.ref_id); debug!("(checking implementation) adding impl for trait '{}', item '{}'", @@ -215,7 +215,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let impl_type_scheme = ty::lookup_item_type(tcx, impl_id); let prov = ty::provided_trait_methods(tcx, trait_ref.def_id); - for trait_method in prov.iter() { + for trait_method in &prov { // Synthesize an ID. let new_id = tcx.sess.next_node_id(); let new_did = local_def(new_id); @@ -303,7 +303,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { } }).collect(); - for trait_ref in trait_refs.iter() { + if let Some(ref trait_ref) = *trait_refs { let ty_trait_ref = ty::node_id_to_trait_ref( self.crate_context.tcx, trait_ref.ref_id); @@ -345,17 +345,17 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { assert!(associated_traits.is_some()); // Record all the trait items. - for trait_ref in associated_traits.iter() { + if let Some(trait_ref) = associated_traits { self.add_trait_impl(trait_ref.def_id, impl_def_id); } // For any methods that use a default implementation, add them to // the map. This is a bit unfortunate. - for item_def_id in impl_items.iter() { + for item_def_id in &impl_items { let impl_item = ty::impl_or_trait_item(tcx, item_def_id.def_id()); match impl_item { ty::MethodTraitItem(ref method) => { - for &source in method.provided_source.iter() { + if let Some(source) = method.provided_source { tcx.provided_method_sources .borrow_mut() .insert(item_def_id.def_id(), source); @@ -398,7 +398,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { Some(found_impls) => found_impls }; - for &impl_did in trait_impls.borrow().iter() { + for &impl_did in &*trait_impls.borrow() { let items = &(*impl_items)[impl_did]; if items.len() < 1 { // We'll error out later. For now, just don't ICE. @@ -465,7 +465,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { // Clone first to avoid a double borrow error. let trait_impls = trait_impls.borrow().clone(); - for &impl_did in trait_impls.iter() { + for &impl_did in &trait_impls { debug!("check_implementations_of_copy: impl_did={}", impl_did.repr(tcx)); @@ -559,7 +559,7 @@ fn subst_receiver_types_in_method_ty<'tcx>(tcx: &ty::ctxt<'tcx>, // replace the type parameters declared on the trait with those // from the impl - for &space in [subst::TypeSpace, subst::SelfSpace].iter() { + for &space in &[subst::TypeSpace, subst::SelfSpace] { method_generics.types.replace( space, impl_type_scheme.generics.types.get_slice(space).to_vec()); diff --git a/src/librustc_typeck/coherence/overlap.rs b/src/librustc_typeck/coherence/overlap.rs index a7bad3dc789..403dcf1e25a 100644 --- a/src/librustc_typeck/coherence/overlap.rs +++ b/src/librustc_typeck/coherence/overlap.rs @@ -46,7 +46,7 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { (k, v.borrow().clone()) }).collect(); - for &(trait_def_id, ref impls) in trait_def_ids.iter() { + for &(trait_def_id, ref impls) in &trait_def_ids { self.check_for_overlapping_impls_of_trait(trait_def_id, impls); } } @@ -65,7 +65,7 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> { continue; } - for &impl2_def_id in trait_impls[(i+1)..].iter() { + for &impl2_def_id in &trait_impls[(i+1)..] { self.check_if_impls_overlap(trait_def_id, impl1_def_id, impl2_def_id); diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index ed33ddd458a..6d92343d332 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -203,7 +203,7 @@ fn get_enum_variant_types<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, let tcx = ccx.tcx; // Create a set of parameter types shared among all the variants. - for variant in variants.iter() { + for variant in variants { let variant_def_id = local_def(variant.node.id); // Nullary enum constructors get turned into constants; n-ary enum @@ -249,7 +249,7 @@ fn collect_trait_methods<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, if let ast::ItemTrait(_, _, _, ref trait_items) = item.node { // For each method, construct a suitable ty::Method and // store it into the `tcx.impl_or_trait_items` table: - for trait_item in trait_items.iter() { + for trait_item in trait_items { match *trait_item { ast::RequiredMethod(_) | ast::ProvidedMethod(_) => { @@ -527,8 +527,8 @@ fn ensure_no_ty_param_bounds(ccx: &CollectCtxt, thing: &'static str) { let mut warn = false; - for ty_param in generics.ty_params.iter() { - for bound in ty_param.bounds.iter() { + for ty_param in &*generics.ty_params { + for bound in &*ty_param.bounds { match *bound { ast::TraitTyParamBound(..) => { warn = true; @@ -596,7 +596,7 @@ fn convert(ccx: &CollectCtxt, it: &ast::Item) { }; let mut methods = Vec::new(); - for impl_item in impl_items.iter() { + for impl_item in impl_items { match *impl_item { ast::MethodImplItem(ref method) => { let body_id = method.pe_body().id; @@ -644,7 +644,7 @@ fn convert(ccx: &CollectCtxt, it: &ast::Item) { &ty_generics, parent_visibility); - for trait_ref in opt_trait_ref.iter() { + if let Some(ref trait_ref) = *opt_trait_ref { astconv::instantiate_trait_ref(ccx, &ExplicitRscope, trait_ref, @@ -663,7 +663,7 @@ fn convert(ccx: &CollectCtxt, it: &ast::Item) { it.ident.repr(ccx.tcx), trait_def.repr(ccx.tcx)); - for trait_method in trait_methods.iter() { + for trait_method in trait_methods { let self_type = ty::mk_self_type(tcx); match *trait_method { ast::RequiredMethod(ref type_method) => { @@ -1168,7 +1168,7 @@ fn add_unsized_bound<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, { // Try to find an unbound in bounds. let mut unbound = None; - for ab in ast_bounds.iter() { + for ab in ast_bounds { if let &ast::TraitTyParamBound(ref ptr, ast::TraitBoundModifier::Maybe) = ab { if unbound.is_none() { assert!(ptr.bound_lifetimes.is_empty()); @@ -1249,12 +1249,12 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, create_predicates(ccx.tcx, &mut result, space); // Add the bounds not associated with a type parameter - for predicate in where_clause.predicates.iter() { + for predicate in &where_clause.predicates { match predicate { &ast::WherePredicate::BoundPredicate(ref bound_pred) => { let ty = ast_ty_to_ty(ccx, &ExplicitRscope, &*bound_pred.bounded_ty); - for bound in bound_pred.bounds.iter() { + for bound in &*bound_pred.bounds { match bound { &ast::TyParamBound::TraitTyParamBound(ref poly_trait_ref, _) => { let mut projections = Vec::new(); @@ -1269,7 +1269,7 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, result.predicates.push(space, trait_ref.as_predicate()); - for projection in projections.iter() { + for projection in &projections { result.predicates.push(space, projection.as_predicate()); } } @@ -1285,7 +1285,7 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, &ast::WherePredicate::RegionPredicate(ref region_pred) => { let r1 = ast_region_to_region(ccx.tcx, ®ion_pred.lifetime); - for bound in region_pred.bounds.iter() { + for bound in ®ion_pred.bounds { let r2 = ast_region_to_region(ccx.tcx, bound); let pred = ty::Binder(ty::OutlivesPredicate(r1, r2)); result.predicates.push(space, ty::Predicate::RegionOutlives(pred)) @@ -1308,16 +1308,16 @@ fn ty_generics<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>, result: &mut ty::Generics<'tcx>, space: subst::ParamSpace) { - for type_param_def in result.types.get_slice(space).iter() { + for type_param_def in result.types.get_slice(space) { let param_ty = ty::mk_param_from_def(tcx, type_param_def); for predicate in ty::predicates(tcx, param_ty, &type_param_def.bounds).into_iter() { result.predicates.push(space, predicate); } } - for region_param_def in result.regions.get_slice(space).iter() { + for region_param_def in result.regions.get_slice(space) { let region = region_param_def.to_early_bound_region(); - for &bound_region in region_param_def.bounds.iter() { + for &bound_region in ®ion_param_def.bounds { // account for new binder introduced in the predicate below; no need // to shift `region` because it is never a late-bound region let bound_region = ty_fold::shift_region(bound_region, 1); @@ -1480,7 +1480,7 @@ fn ty_of_foreign_fn_decl<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>, ast_generics: &ast::Generics, abi: abi::Abi) -> ty::TypeScheme<'tcx> { - for i in decl.inputs.iter() { + for i in &decl.inputs { match (*i).pat.node { ast::PatIdent(_, _, _) => (), ast::PatWild(ast::PatWildSingle) => (), diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 6c5950e4df5..40197ee2c49 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -499,12 +499,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { // `ty::VariantInfo::from_ast_variant()` ourselves // here, mainly so as to mask the differences between // struct-like enums and so forth. - for ast_variant in enum_definition.variants.iter() { + for ast_variant in &enum_definition.variants { let variant = ty::VariantInfo::from_ast_variant(tcx, &**ast_variant, /*discriminant*/ 0); - for arg_ty in variant.args.iter() { + for arg_ty in &variant.args { self.add_constraints_from_ty(generics, *arg_ty, self.covariant); } } @@ -513,7 +513,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { ast::ItemStruct(..) => { let generics = &ty::lookup_item_type(tcx, did).generics; let struct_fields = ty::lookup_struct_fields(tcx, did); - for field_info in struct_fields.iter() { + for field_info in &struct_fields { assert_eq!(field_info.id.krate, ast::LOCAL_CRATE); let field_ty = ty::node_id_to_type(tcx, field_info.id.node); self.add_constraints_from_ty(generics, field_ty, self.covariant); @@ -522,7 +522,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> { ast::ItemTrait(..) => { let trait_items = ty::trait_items(tcx, did); - for trait_item in trait_items.iter() { + for trait_item in &*trait_items { match *trait_item { ty::MethodTraitItem(ref method) => { self.add_constraints_from_sig(&method.generics, @@ -759,7 +759,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } ty::ty_tup(ref subtys) => { - for &subty in subtys.iter() { + for &subty in subtys { self.add_constraints_from_ty(generics, subty, variance); } } @@ -821,7 +821,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { let projections = data.projection_bounds_with_self_ty(self.tcx(), self.tcx().types.err); - for projection in projections.iter() { + for projection in &projections { self.add_constraints_from_ty(generics, projection.0.ty, self.invariant); } } @@ -866,7 +866,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance: VarianceTermPtr<'a>) { debug!("add_constraints_from_substs(def_id={:?})", def_id); - for p in type_param_defs.iter() { + for p in type_param_defs { let variance_decl = self.declared_variance(p.def_id, def_id, TypeParam, p.space, p.index as uint); @@ -875,7 +875,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { self.add_constraints_from_ty(generics, substs_ty, variance_i); } - for p in region_param_defs.iter() { + for p in region_param_defs { let variance_decl = self.declared_variance(p.def_id, def_id, RegionParam, p.space, p.index as uint); @@ -892,7 +892,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { sig: &ty::PolyFnSig<'tcx>, variance: VarianceTermPtr<'a>) { let contra = self.contravariant(variance); - for &input in sig.0.inputs.iter() { + for &input in &sig.0.inputs { self.add_constraints_from_ty(generics, input, contra); } if let ty::FnConverging(result_type) = sig.0.output { @@ -990,7 +990,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { while changed { changed = false; - for constraint in self.constraints.iter() { + for constraint in &self.constraints { let Constraint { inferred, variance: term } = *constraint; let InferredIndex(inferred) = inferred; let variance = self.evaluate(term); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index d5c03879438..b140e26e037 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -254,7 +254,7 @@ impl Item { /// Finds the `doc` attribute as a List and returns the list of attributes /// nested inside. pub fn doc_list<'a>(&'a self) -> Option<&'a [Attribute]> { - for attr in self.attrs.iter() { + for attr in &self.attrs { match *attr { List(ref x, ref list) if "doc" == *x => { return Some(list.as_slice()); @@ -268,7 +268,7 @@ impl Item { /// Finds the `doc` attribute as a NameValue and returns the corresponding /// value found. pub fn doc_value<'a>(&'a self) -> Option<&'a str> { - for attr in self.attrs.iter() { + for attr in &self.attrs { match *attr { NameValue(ref x, ref v) if "doc" == *x => { return Some(v.as_slice()); @@ -281,8 +281,8 @@ impl Item { pub fn is_hidden_from_doc(&self) -> bool { match self.doc_list() { - Some(ref l) => { - for innerattr in l.iter() { + Some(l) => { + for innerattr in l { match *innerattr { Word(ref s) if "hidden" == *s => { return true @@ -508,12 +508,12 @@ impl<'tcx> Clean<(Vec, Vec)> for ty::ExistentialBound fn clean(&self, cx: &DocContext) -> (Vec, Vec) { let mut tp_bounds = vec![]; self.region_bound.clean(cx).map(|b| tp_bounds.push(RegionBound(b))); - for bb in self.builtin_bounds.iter() { + for bb in &self.builtin_bounds { tp_bounds.push(bb.clean(cx)); } let mut bindings = vec![]; - for &ty::Binder(ref pb) in self.projection_bounds.iter() { + for &ty::Binder(ref pb) in &self.projection_bounds { bindings.push(TypeBinding { name: pb.projection_ty.item_name.clean(cx), ty: pb.ty.clean(cx) @@ -636,10 +636,10 @@ impl<'tcx> Clean for ty::TraitRef<'tcx> { // collect any late bound regions let mut late_bounds = vec![]; - for &ty_s in self.substs.types.get_slice(ParamSpace::TypeSpace).iter() { + for &ty_s in self.substs.types.get_slice(ParamSpace::TypeSpace) { use rustc::middle::ty::{Region, sty}; if let sty::ty_tup(ref ts) = ty_s.sty { - for &ty_s in ts.iter() { + for &ty_s in ts { if let sty::ty_rptr(ref reg, _) = ty_s.sty { if let &Region::ReLateBound(_, _) = *reg { debug!(" hit an ReLateBound {:?}", reg); @@ -662,7 +662,7 @@ impl<'tcx> Clean for ty::TraitRef<'tcx> { impl<'tcx> Clean> for ty::ParamBounds<'tcx> { fn clean(&self, cx: &DocContext) -> Vec { let mut v = Vec::new(); - for t in self.trait_bounds.iter() { + for t in &self.trait_bounds { v.push(t.clean(cx)); } for r in self.region_bounds.iter().filter_map(|r| r.clean(cx)) { @@ -872,7 +872,7 @@ impl<'a, 'tcx> Clean for (&'a ty::Generics<'tcx>, subst::ParamSpace) { Some(did) => did, None => return false }; - for bound in bounds.iter() { + for bound in bounds { if let TyParamBound::TraitBound(PolyTrait { trait_: Type::ResolvedPath { did, .. }, .. }, TBM::None) = *bound { @@ -915,7 +915,7 @@ impl<'a, 'tcx> Clean for (&'a ty::Generics<'tcx>, subst::ParamSpace) { }).collect::>(); // Finally, run through the type parameters again and insert a ?Sized unbound for // any we didn't find to be Sized. - for tp in stripped_typarams.iter() { + for tp in &stripped_typarams { if !sized_params.contains(&tp.name) { let mut sized_bound = ty::BuiltinBound::BoundSized.clean(cx); if let TyParamBound::TraitBound(_, ref mut tbm) = sized_bound { @@ -1420,12 +1420,12 @@ impl PrimitiveType { } fn find(attrs: &[Attribute]) -> Option { - for attr in attrs.iter() { + for attr in attrs { let list = match *attr { List(ref k, ref l) if *k == "doc" => l, _ => continue, }; - for sub_attr in list.iter() { + for sub_attr in list { let value = match *sub_attr { NameValue(ref k, ref v) if *k == "primitive" => v.as_slice(), @@ -2175,7 +2175,7 @@ impl Clean> for doctree::Import { let mut ret = vec![]; let remaining = if !denied { let mut remaining = vec![]; - for path in list.iter() { + for path in list { match inline::try_inline(cx, path.node.id(), None) { Some(items) => { ret.extend(items.into_iter()); diff --git a/src/librustdoc/externalfiles.rs b/src/librustdoc/externalfiles.rs index 79ca24a18d4..84e88158219 100644 --- a/src/librustdoc/externalfiles.rs +++ b/src/librustdoc/externalfiles.rs @@ -62,7 +62,7 @@ macro_rules! load_or_return { pub fn load_external_files(names: &[String]) -> Option { let mut out = String::new(); - for name in names.iter() { + for name in names { out.push_str(load_or_return!(name.as_slice(), None, None).as_slice()); out.push('\n'); } diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index eb7402b67c4..e86c0e39714 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -212,21 +212,21 @@ impl fmt::Display for clean::PathParameters { if lifetimes.len() > 0 || types.len() > 0 || bindings.len() > 0 { try!(f.write_str("<")); let mut comma = false; - for lifetime in lifetimes.iter() { + for lifetime in lifetimes { if comma { try!(f.write_str(", ")); } comma = true; try!(write!(f, "{}", *lifetime)); } - for ty in types.iter() { + for ty in types { if comma { try!(f.write_str(", ")); } comma = true; try!(write!(f, "{}", *ty)); } - for binding in bindings.iter() { + for binding in bindings { if comma { try!(f.write_str(", ")); } @@ -239,7 +239,7 @@ impl fmt::Display for clean::PathParameters { clean::PathParameters::Parenthesized { ref inputs, ref output } => { try!(f.write_str("(")); let mut comma = false; - for ty in inputs.iter() { + for ty in inputs { if comma { try!(f.write_str(", ")); } @@ -332,7 +332,7 @@ fn path(w: &mut fmt::Formatter, match rel_root { Some(root) => { let mut root = String::from_str(root.as_slice()); - for seg in path.segments[..amt].iter() { + for seg in &path.segments[..amt] { if "super" == seg.name || "self" == seg.name { try!(write!(w, "{}::", seg.name)); @@ -347,7 +347,7 @@ fn path(w: &mut fmt::Formatter, } } None => { - for seg in path.segments[..amt].iter() { + for seg in &path.segments[..amt] { try!(write!(w, "{}::", seg.name)); } } @@ -359,7 +359,7 @@ fn path(w: &mut fmt::Formatter, Some((ref fqp, shortty)) if abs_root.is_some() => { let mut url = String::from_str(abs_root.unwrap().as_slice()); let to_link = &fqp[..fqp.len() - 1]; - for component in to_link.iter() { + for component in to_link { url.push_str(component.as_slice()); url.push_str("/"); } @@ -440,7 +440,7 @@ fn tybounds(w: &mut fmt::Formatter, typarams: &Option >) -> fmt::Result { match *typarams { Some(ref params) => { - for param in params.iter() { + for param in params { try!(write!(w, " + ")); try!(write!(w, "{}", *param)); } @@ -770,7 +770,7 @@ impl fmt::Display for ModuleSummary { (100 * cnt.unmarked) as f64/tot as f64)); try!(write!(f, "")); - for submodule in m.submodules.iter() { + for submodule in &m.submodules { try!(fmt_inner(f, context, submodule)); } context.pop(); diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 8a007fb035e..20ba0bb9e90 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -283,7 +283,7 @@ pub fn run(mut krate: clean::Crate, let default: &[_] = &[]; match krate.module.as_ref().map(|m| m.doc_list().unwrap_or(default)) { Some(attrs) => { - for attr in attrs.iter() { + for attr in attrs { match *attr { clean::NameValue(ref x, ref s) if "html_favicon_url" == *x => { @@ -353,7 +353,7 @@ pub fn run(mut krate: clean::Crate, krate = cache.fold_crate(krate); // Cache where all our extern crates are located - for &(n, ref e) in krate.externs.iter() { + for &(n, ref e) in &krate.externs { cache.extern_locations.insert(n, extern_location(e, &cx.dst)); let did = ast::DefId { krate: n, node: ast::CRATE_NODE_ID }; cache.paths.insert(did, (vec![e.name.to_string()], ItemType::Module)); @@ -364,11 +364,11 @@ pub fn run(mut krate: clean::Crate, // Favor linking to as local extern as possible, so iterate all crates in // reverse topological order. for &(n, ref e) in krate.externs.iter().rev() { - for &prim in e.primitives.iter() { + for &prim in &e.primitives { cache.primitive_locations.insert(prim, n); } } - for &prim in krate.primitives.iter() { + for &prim in &krate.primitives { cache.primitive_locations.insert(prim, ast::LOCAL_CRATE); } @@ -402,7 +402,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> old_io::IoResult { @@ -420,7 +420,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> old_io::IoResult { if !nodeid_to_pathid.contains_key(&nodeid) { @@ -542,7 +542,7 @@ fn write_shared(cx: &Context, let mut w = try!(File::create(&dst)); try!(writeln!(&mut w, "var searchIndex = {{}};")); try!(writeln!(&mut w, "{}", search_index)); - for index in all_indexes.iter() { + for index in &all_indexes { try!(writeln!(&mut w, "{}", *index)); } try!(writeln!(&mut w, "initSearch(searchIndex);")); @@ -550,7 +550,7 @@ fn write_shared(cx: &Context, // Update the list of all implementors for traits let dst = cx.dst.join("implementors"); try!(mkdir(&dst)); - for (&did, imps) in cache.implementors.iter() { + for (&did, imps) in &cache.implementors { // Private modules can leak through to this phase of rustdoc, which // could contain implementations for otherwise private types. In some // rare cases we could find an implementation for an item which wasn't @@ -564,7 +564,7 @@ fn write_shared(cx: &Context, }; let mut mydst = dst.clone(); - for part in remote_path[..remote_path.len() - 1].iter() { + for part in &remote_path[..remote_path.len() - 1] { mydst.push(part.as_slice()); try!(mkdir(&mydst)); } @@ -578,12 +578,12 @@ fn write_shared(cx: &Context, let mut f = BufferedWriter::new(try!(File::create(&mydst))); try!(writeln!(&mut f, "(function() {{var implementors = {{}};")); - for implementor in all_implementors.iter() { + for implementor in &all_implementors { try!(write!(&mut f, "{}", *implementor)); } try!(write!(&mut f, r"implementors['{}'] = [", krate.name)); - for imp in imps.iter() { + for imp in imps { // If the trait and implementation are in the same crate, then // there's no need to emit information about it (there's inlining // going on). If they're in different crates then the crate defining @@ -679,10 +679,10 @@ fn extern_location(e: &clean::ExternalCrate, dst: &Path) -> ExternalLocation { // Failing that, see if there's an attribute specifying where to find this // external crate - for attr in e.attrs.iter() { + for attr in &e.attrs { match *attr { clean::List(ref x, ref list) if "doc" == *x => { - for attr in list.iter() { + for attr in list { match *attr { clean::NameValue(ref x, ref s) if "html_root_url" == *x => { @@ -1043,7 +1043,7 @@ impl DocFolder for Cache { impl<'a> Cache { fn generics(&mut self, generics: &clean::Generics) { - for typ in generics.type_params.iter() { + for typ in &generics.type_params { self.typarams.insert(typ.did, typ.name.clone()); } } @@ -1190,7 +1190,7 @@ impl Context { .collect::(); match cache().paths.get(&it.def_id) { Some(&(ref names, _)) => { - for name in (&names[..names.len() - 1]).iter() { + for name in &names[..names.len() - 1] { url.push_str(name.as_slice()); url.push_str("/"); } @@ -1252,7 +1252,7 @@ impl Context { fn build_sidebar(&self, m: &clean::Module) -> HashMap> { let mut map = HashMap::new(); - for item in m.items.iter() { + for item in &m.items { if self.ignore_private_item(item) { continue } // avoid putting foreign items to the sidebar. @@ -1536,7 +1536,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, debug!("{:?}", indices); let mut curty = None; - for &idx in indices.iter() { + for &idx in &indices { let myitem = &items[idx]; let myty = Some(shortty(myitem)); @@ -1696,7 +1696,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, try!(write!(w, "{{ }}")); } else { try!(write!(w, "{{\n")); - for t in types.iter() { + for t in &types { try!(write!(w, " ")); try!(render_method(w, t.item())); try!(write!(w, ";\n")); @@ -1704,7 +1704,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, if types.len() > 0 && required.len() > 0 { try!(w.write_str("\n")); } - for m in required.iter() { + for m in &required { try!(write!(w, " ")); try!(render_method(w, m.item())); try!(write!(w, ";\n")); @@ -1712,7 +1712,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, if required.len() > 0 && provided.len() > 0 { try!(w.write_str("\n")); } - for m in provided.iter() { + for m in &provided { try!(write!(w, " ")); try!(render_method(w, m.item())); try!(write!(w, " {{ ... }}\n")); @@ -1741,7 +1741,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,

Associated Types

")); - for t in types.iter() { + for t in &types { try!(trait_item(w, *t)); } try!(write!(w, "
")); @@ -1753,7 +1753,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,

Required Methods

")); - for m in required.iter() { + for m in &required { try!(trait_item(w, *m)); } try!(write!(w, "
")); @@ -1763,7 +1763,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,

Provided Methods

")); - for m in provided.iter() { + for m in &provided { try!(trait_item(w, *m)); } try!(write!(w, "
")); @@ -1776,7 +1776,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, ")); match cache.implementors.get(&it.def_id) { Some(implementors) => { - for i in implementors.iter() { + for i in implementors { try!(writeln!(w, "
  • {}impl{} {} for {}{}
    • ", ConciseStability(&i.stability), i.generics, i.trait_, i.for_, WhereClause(&i.generics))); @@ -1890,7 +1890,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item, try!(write!(w, " {{}}")); } else { try!(write!(w, " {{\n")); - for v in e.variants.iter() { + for v in &e.variants { try!(write!(w, " ")); let name = v.name.as_ref().unwrap().as_slice(); match v.inner { @@ -1933,7 +1933,7 @@ fn item_enum(w: &mut fmt::Formatter, it: &clean::Item, try!(document(w, it)); if e.variants.len() > 0 { try!(write!(w, "

    Variants

    \n")); - for variant in e.variants.iter() { + for variant in &e.variants { try!(write!(w, "
    {stab}{name}", stab = ConciseStability(&variant.stability), name = variant.name.as_ref().unwrap().as_slice())); @@ -1996,7 +1996,7 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item, doctree::Plain => { try!(write!(w, " {{\n{}", tab)); let mut fields_stripped = false; - for field in fields.iter() { + for field in fields { match field.inner { clean::StructFieldItem(clean::HiddenStructField) => { fields_stripped = true; @@ -2049,7 +2049,7 @@ fn render_methods(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result { .partition(|i| i.impl_.trait_.is_none()); if non_trait.len() > 0 { try!(write!(w, "

    Methods

    ")); - for i in non_trait.iter() { + for i in &non_trait { try!(render_impl(w, i)); } } @@ -2058,13 +2058,13 @@ fn render_methods(w: &mut fmt::Formatter, it: &clean::Item) -> fmt::Result { Implementations")); let (derived, manual): (Vec<_>, _) = traits.into_iter() .partition(|i| i.impl_.derived); - for i in manual.iter() { + for i in &manual { try!(render_impl(w, i)); } if derived.len() > 0 { try!(write!(w, "

    Derived Implementations \

    ")); - for i in derived.iter() { + for i in &derived { try!(render_impl(w, i)); } } @@ -2137,14 +2137,14 @@ fn render_impl(w: &mut fmt::Formatter, i: &Impl) -> fmt::Result { } try!(write!(w, "
    ")); - for trait_item in i.impl_.items.iter() { + for trait_item in &i.impl_.items { try!(doctraititem(w, trait_item, true)); } fn render_default_methods(w: &mut fmt::Formatter, t: &clean::Trait, i: &clean::Impl) -> fmt::Result { - for trait_item in t.items.iter() { + for trait_item in &t.items { let n = trait_item.item().name.clone(); match i.items.iter().find(|m| { m.name == n }) { Some(..) => continue, @@ -2209,7 +2209,7 @@ impl<'a> fmt::Display for Sidebar<'a> { None => return Ok(()) }; try!(write!(w, "

    {}

    ", short, longty)); - for &NameDoc(ref name, ref doc) in items.iter() { + for &NameDoc(ref name, ref doc) in items { let curty = shortty(cur).to_static_str(); let class = if cur.name.as_ref().unwrap() == name && short == curty { "current" } else { "" }; diff --git a/src/librustdoc/html/toc.rs b/src/librustdoc/html/toc.rs index 9143baf9ed9..7790c7d6a50 100644 --- a/src/librustdoc/html/toc.rs +++ b/src/librustdoc/html/toc.rs @@ -185,7 +185,7 @@ impl fmt::Debug for Toc { impl fmt::Display for Toc { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { try!(write!(fmt, "