---

yaml
---
r: 182874
b: refs/heads/beta
c: efc97a5
h: refs/heads/master
v: v3

Author: Jorge Aparicio

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 7d661af9c86566088f7dbaeee25143ecde673b75
+refs/heads/beta: efc97a51ffc798247e36156cf8e2d175bf509018
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: eb836bf767aa1d8d4cba488a9091cde3c0ab4b2f

branches/beta/src/libcollections/binary_heap.rs

@@ -67,7 +67,7 @@
 //! // for a simpler implementation.
 //! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: uint, goal: uint) -> uint {
 //!     // dist[node] = current shortest distance from `start` to `node`
-//!     let mut dist: Vec<_> = range(0, adj_list.len()).map(|_| uint::MAX).collect();
+//!     let mut dist: Vec<_> = (0..adj_list.len()).map(|_| uint::MAX).collect();
 //!
 //!     let mut heap = BinaryHeap::new();
 //!

branches/beta/src/libcollections/btree/map.rs

@@ -1730,7 +1730,7 @@ mod test {
         let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
 
         let mut j = 0u;
-        for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(range(2u, size)) {
+        for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2u..size) {
             assert_eq!(k, i);
             assert_eq!(v, i);
             j += 1;

branches/beta/src/libcollections/dlist.rs

@@ -599,7 +599,7 @@ impl<T> DList<T> {
         }  else {
             // better off starting from the end
             let mut iter = self.iter_mut();
-            for _ in range(0, len - 1 - (at - 1)) {
+            for _ in 0..len - 1 - (at - 1) {
                 iter.next_back();
             }
             iter.tail

branches/beta/src/libcollections/ring_buf.rs

@@ -388,7 +388,7 @@ impl<T> RingBuf<T> {
     /// use std::collections::RingBuf;
     ///
     /// let mut buf = RingBuf::with_capacity(15);
-    /// buf.extend(range(0u, 4));
+    /// buf.extend(0u..4);
     /// assert_eq!(buf.capacity(), 15);
     /// buf.shrink_to_fit();
     /// assert!(buf.capacity() >= 4);
@@ -483,7 +483,7 @@ impl<T> RingBuf<T> {
     #[unstable(feature = "collections",
                reason = "matches collection reform specification; waiting on panic semantics")]
     pub fn truncate(&mut self, len: uint) {
-        for _ in range(len, self.len()) {
+        for _ in len..self.len() {
             self.pop_back();
         }
     }

branches/beta/src/libcollections/slice.rs

@@ -1254,7 +1254,7 @@ impl Iterator for ElementSwaps {
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
         // For a vector of size n, there are exactly n! permutations.
-        let n = range(2, self.sdir.len() + 1).product();
+        let n = (2..self.sdir.len() + 1).product();
         (n - self.swaps_made, Some(n - self.swaps_made))
     }
 }
@@ -1385,7 +1385,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
     // .offset-ing.
     for start in range_step(0, len, insertion) {
         // start <= i < len;
-        for i in range(start, cmp::min(start + insertion, len)) {
+        for i in start..cmp::min(start + insertion, len) {
             // j satisfies: start <= j <= i;
             let mut j = i as int;
             unsafe {

branches/beta/src/libcollections/vec.rs

@@ -1079,7 +1079,7 @@ impl<T: Clone> Vec<T> {
     pub fn push_all(&mut self, other: &[T]) {
         self.reserve(other.len());
 
-        for i in range(0, other.len()) {
+        for i in 0..other.len() {
             let len = self.len();
 
             // Unsafe code so this can be optimised to a memcpy (or something similarly
@@ -1988,12 +1988,12 @@ mod tests {
         let mut v = Vec::new();
         let mut w = Vec::new();
 
-        v.extend(range(0i, 3));
+        v.extend(0i..3);
         for i in 0i..3 { w.push(i) }
 
         assert_eq!(v, w);
 
-        v.extend(range(3i, 10));
+        v.extend(3i..10);
         for i in 3i..10 { w.push(i) }
 
         assert_eq!(v, w);
@@ -2499,7 +2499,7 @@ mod tests {
     }
 
     fn do_bench_from_slice(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
@@ -2531,7 +2531,7 @@ mod tests {
     }
 
     fn do_bench_from_iter(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
@@ -2563,8 +2563,8 @@ mod tests {
     }
 
     fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
-        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+        let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
+        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2612,8 +2612,8 @@ mod tests {
     }
 
     fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(range(0, dst_len));
-        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+        let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
+        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2661,8 +2661,8 @@ mod tests {
     }
 
     fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(range(0u, dst_len));
-        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+        let dst: Vec<uint> = FromIterator::from_iter(0u..dst_len);
+        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2710,7 +2710,7 @@ mod tests {
     }
 
     fn do_bench_clone(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(range(0, src_len));
+        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
@@ -2742,8 +2742,8 @@ mod tests {
     }
 
     fn do_bench_clone_from(b: &mut Bencher, times: uint, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(range(0, src_len));
-        let src: Vec<uint> = FromIterator::from_iter(range(dst_len, dst_len + src_len));
+        let dst: Vec<uint> = FromIterator::from_iter(0..src_len);
+        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = (times * src_len) as u64;
 

branches/beta/src/libcollections/vec_map.rs

@@ -459,7 +459,7 @@ impl<V> VecMap<V> {
     pub fn insert(&mut self, key: uint, value: V) -> Option<V> {
         let len = self.v.len();
         if len <= key {
-            self.v.extend(range(0, key - len + 1).map(|_| None));
+            self.v.extend((0..key - len + 1).map(|_| None));
         }
         replace(&mut self.v[key], Some(value))
     }

branches/beta/src/libcore/borrow.rs

@@ -125,7 +125,7 @@ impl<T> ToOwned<T> for T where T: Clone {
 /// use std::borrow::Cow;
 ///
 /// fn abs_all(input: &mut Cow<Vec<int>, [int]>) {
-///     for i in range(0, input.len()) {
+///     for i in 0..input.len() {
 ///         let v = input[i];
 ///         if v < 0 {
 ///             // clones into a vector the first time (if not already owned)

branches/beta/src/libcore/str/mod.rs

@@ -800,7 +800,7 @@ impl TwoWaySearcher {
             // See if the right part of the needle matches
             let start = if long_period { self.crit_pos }
                         else { cmp::max(self.crit_pos, self.memory) };
-            for i in range(start, needle.len()) {
+            for i in start..needle.len() {
                 if needle[i] != haystack[self.position + i] {
                     self.position += i - self.crit_pos + 1;
                     if !long_period {

branches/beta/src/libcoretest/iter.rs

@@ -305,7 +305,7 @@ fn test_cycle() {
 #[test]
 fn test_iterator_nth() {
     let v: &[_] = &[0i, 1, 2, 3, 4];
-    for i in range(0u, v.len()) {
+    for i in 0u..v.len() {
         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
     }
     assert_eq!(v.iter().nth(v.len()), None);
@@ -458,7 +458,7 @@ fn test_min_by() {
 
 #[test]
 fn test_by_ref() {
-    let mut xs = range(0i, 10);
+    let mut xs = 0i..10;
     // sum the first five values
     let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
     assert_eq!(partial_sum, 10);
@@ -730,32 +730,32 @@ fn test_random_access_cycle() {
 
 #[test]
 fn test_double_ended_range() {
-    assert!(range(11i, 14).rev().collect::<Vec<int>>() == vec![13i, 12, 11]);
+    assert!((11i..14).rev().collect::<Vec<int>>() == vec![13i, 12, 11]);
     for _ in (10i..0).rev() {
         panic!("unreachable");
     }
 
-    assert!(range(11u, 14).rev().collect::<Vec<uint>>() == vec![13u, 12, 11]);
+    assert!((11u..14).rev().collect::<Vec<uint>>() == vec![13u, 12, 11]);
     for _ in (10u..0).rev() {
         panic!("unreachable");
     }
 }
 
 #[test]
 fn test_range() {
-    assert!(range(0i, 5).collect::<Vec<int>>() == vec![0i, 1, 2, 3, 4]);
-    assert!(range(-10i, -1).collect::<Vec<int>>() ==
+    assert!((0i..5).collect::<Vec<int>>() == vec![0i, 1, 2, 3, 4]);
+    assert!((-10i..-1).collect::<Vec<int>>() ==
                vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
-    assert!(range(0i, 5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
-    assert_eq!(range(200i, -5).count(), 0);
-    assert_eq!(range(200i, -5).rev().count(), 0);
-    assert_eq!(range(200i, 200).count(), 0);
-    assert_eq!(range(200i, 200).rev().count(), 0);
+    assert!((0i..5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
+    assert_eq!((200i..-5).count(), 0);
+    assert_eq!((200i..-5).rev().count(), 0);
+    assert_eq!((200i..200).count(), 0);
+    assert_eq!((200i..200).rev().count(), 0);
 
-    assert_eq!(range(0i, 100).size_hint(), (100, Some(100)));
+    assert_eq!((0i..100).size_hint(), (100, Some(100)));
     // this test is only meaningful when sizeof uint < sizeof u64
-    assert_eq!(range(uint::MAX - 1, uint::MAX).size_hint(), (1, Some(1)));
-    assert_eq!(range(-10i, -1).size_hint(), (9, Some(9)));
+    assert_eq!((uint::MAX - 1..uint::MAX).size_hint(), (1, Some(1)));
+    assert_eq!((-10i..-1).size_hint(), (9, Some(9)));
 }
 
 #[test]
@@ -892,7 +892,7 @@ fn bench_rposition(b: &mut Bencher) {
 #[bench]
 fn bench_skip_while(b: &mut Bencher) {
     b.iter(|| {
-        let it = range(0u, 100);
+        let it = 0u..100;
         let mut sum = 0;
         it.skip_while(|&x| { sum += x; sum < 4000 }).all(|_| true);
     });

branches/beta/src/libcoretest/str.rs

@@ -17,7 +17,7 @@ fn test_bool_from_str() {
 
 fn check_contains_all_substrings(s: &str) {
     assert!(s.contains(""));
-    for i in range(0, s.len()) {
+    for i in 0..s.len() {
         for j in range(i+1, s.len() + 1) {
             assert!(s.contains(&s[i..j]));
         }

branches/beta/src/libgraphviz/lib.rs

@@ -176,7 +176,7 @@
 //! }
 //!
 //! impl<'a> dot::GraphWalk<'a, Nd, Ed<'a>> for Graph {
-//!     fn nodes(&self) -> dot::Nodes<'a,Nd> { range(0,self.nodes.len()).collect() }
+//!     fn nodes(&self) -> dot::Nodes<'a,Nd> { (0..self.nodes.len()).collect() }
 //!     fn edges(&'a self) -> dot::Edges<'a,Ed<'a>> { self.edges.iter().collect() }
 //!     fn source(&self, e: &Ed) -> Nd { let & &(s,_) = e; s }
 //!     fn target(&self, e: &Ed) -> Nd { let & &(_,t) = e; t }
@@ -715,7 +715,7 @@ mod tests {
 
     impl<'a> GraphWalk<'a, Node, &'a Edge> for LabelledGraph {
         fn nodes(&'a self) -> Nodes<'a,Node> {
-            range(0u, self.node_labels.len()).collect()
+            (0u..self.node_labels.len()).collect()
         }
         fn edges(&'a self) -> Edges<'a,&'a Edge> {
             self.edges.iter().collect()

branches/beta/src/librustc/metadata/tydecode.rs

@@ -132,7 +132,7 @@ pub fn parse_state_from_data<'a, 'tcx>(data: &'a [u8], crate_num: ast::CrateNum,
 fn data_log_string(data: &[u8], pos: uint) -> String {
     let mut buf = String::new();
     buf.push_str("<<");
-    for i in range(pos, data.len()) {
+    for i in pos..data.len() {
         let c = data[i];
         if c > 0x20 && c <= 0x7F {
             buf.push(c as char);

branches/beta/src/librustc/middle/dependency_format.rs

@@ -157,7 +157,7 @@ fn calculate_type(sess: &session::Session,
     });
 
     // Collect what we've got so far in the return vector.
-    let mut ret = range(1, sess.cstore.next_crate_num()).map(|i| {
+    let mut ret = (1..sess.cstore.next_crate_num()).map(|i| {
         match formats.get(&i).map(|v| *v) {
             v @ Some(cstore::RequireDynamic) => v,
             _ => None,

branches/beta/src/librustc/middle/infer/error_reporting.rs

@@ -1229,8 +1229,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                             let mut insert = Vec::new();
                             if lifetimes.len() == 0 {
                                 let anon = self.cur_anon.get();
-                                for (i, a) in range(anon,
-                                                    anon+expected).enumerate() {
+                                for (i, a) in (anon..anon+expected).enumerate() {
                                     if anon_nums.contains(&a) {
                                         insert.push(i as u32);
                                     }

branches/beta/src/librustc/middle/infer/region_inference/mod.rs

@@ -983,7 +983,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
     }
 
     fn construct_var_data(&self) -> Vec<VarData> {
-        range(0, self.num_vars() as uint).map(|_| {
+        (0..self.num_vars() as uint).map(|_| {
             VarData {
                 // All nodes are initially classified as contracting; during
                 // the expansion phase, we will shift the classification for
@@ -1259,7 +1259,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
 
         let mut opt_graph = None;
 
-        for idx in range(0u, self.num_vars() as uint) {
+        for idx in 0u..self.num_vars() as uint {
             match var_data[idx].value {
                 Value(_) => {
                     /* Inference successful */
@@ -1316,7 +1316,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
             }
         }
 
-        range(0, self.num_vars() as uint).map(|idx| var_data[idx].value).collect()
+        (0..self.num_vars() as uint).map(|idx| var_data[idx].value).collect()
     }
 
     fn construct_graph(&self) -> RegionGraph {

branches/beta/src/librustc/middle/resolve_lifetime.rs

@@ -404,7 +404,7 @@ impl<'a> LifetimeContext<'a> {
     }
 
     fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &Vec<ast::LifetimeDef>) {
-        for i in range(0, lifetimes.len()) {
+        for i in 0..lifetimes.len() {
             let lifetime_i = &lifetimes[i];
 
             let special_idents = [special_idents::static_lifetime];
@@ -417,7 +417,7 @@ impl<'a> LifetimeContext<'a> {
             }
 
             // It is a hard error to shadow a lifetime within the same scope.
-            for j in range(i + 1, lifetimes.len()) {
+            for j in i + 1..lifetimes.len() {
                 let lifetime_j = &lifetimes[j];
 
                 if lifetime_i.lifetime.name == lifetime_j.lifetime.name {

branches/beta/src/librustc/middle/traits/select.rs

@@ -595,7 +595,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             let mut i = 0;
             while i < candidates.len() {
                 let is_dup =
-                    range(0, candidates.len())
+                    (0..candidates.len())
                     .filter(|&j| i != j)
                     .any(|j| self.candidate_should_be_dropped_in_favor_of(stack,
                                                                           &candidates[i],

branches/beta/src/librustc/util/lev_distance.rs

@@ -14,7 +14,7 @@ pub fn lev_distance(me: &str, t: &str) -> uint {
     if me.is_empty() { return t.chars().count(); }
     if t.is_empty() { return me.chars().count(); }
 
-    let mut dcol: Vec<_> = range(0, t.len() + 1).collect();
+    let mut dcol: Vec<_> = (0..t.len() + 1).collect();
     let mut t_last = 0;
 
     for (i, sc) in me.chars().enumerate() {