Auto merge of #21677 - japaric:no-range, r=alexcrichton

Note: Do not merge until we get a newer snapshot that includes #21374

There was some type inference fallout (see 4th commit) because type inference with `a..b` is not as good as with `range(a, b)` (see #21672).

r? @alexcrichton 

5 files changed, 28 insertions, 28 deletions

diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs
index e6a7170acea..7c71c733662 100644
--- a/src/libcoretest/any.rs
+++ b/src/libcoretest/any.rs
@@ -11,7 +11,7 @@ use core::any::*;
 use test::Bencher;
 use test;
 
-#[derive(PartialEq, Show)]
+#[derive(PartialEq, Debug)]
 struct Test;
 
 static TEST: &'static str = "Test";
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index 9481245f120..8bcd4982fba 100644
--- a/src/libcoretest/iter.rs
+++ b/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]);
-    for _ in range(10i, 0).rev() {
+    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]);
-    for _ in range(10u, 0).rev() {
+    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]
@@ -883,7 +883,7 @@ fn test_fuse() {
 
 #[bench]
 fn bench_rposition(b: &mut Bencher) {
-    let it: Vec<uint> = range(0u, 300).collect();
+    let it: Vec<uint> = (0u..300).collect();
     b.iter(|| {
         it.iter().rposition(|&x| x <= 150);
     });
@@ -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);
     });
@@ -900,10 +900,10 @@ fn bench_skip_while(b: &mut Bencher) {
 
 #[bench]
 fn bench_multiple_take(b: &mut Bencher) {
-    let mut it = range(0u, 42).cycle();
+    let mut it = (0u..42).cycle();
     b.iter(|| {
         let n = it.next().unwrap();
-        for _ in range(0u, n) {
+        for _ in 0u..n {
             it.take(it.next().unwrap()).all(|_| true);
         }
     });
diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs
index 1169f910238..bb9d1524786 100644
--- a/src/libcoretest/option.rs
+++ b/src/libcoretest/option.rs
@@ -223,13 +223,13 @@ fn test_ord() {
 /* FIXME(#20575)
 #[test]
 fn test_collect() {
-    let v: Option<Vec<int>> = range(0i, 0).map(|_| Some(0i)).collect();
+    let v: Option<Vec<int>> = (0i..0).map(|_| Some(0i)).collect();
     assert!(v == Some(vec![]));
 
-    let v: Option<Vec<int>> = range(0i, 3).map(|x| Some(x)).collect();
+    let v: Option<Vec<int>> = (0i..3).map(|x| Some(x)).collect();
     assert!(v == Some(vec![0, 1, 2]));
 
-    let v: Option<Vec<int>> = range(0i, 3).map(|x| {
+    let v: Option<Vec<int>> = (0i..3).map(|x| {
         if x > 1 { None } else { Some(x) }
     }).collect();
     assert!(v == None);
diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs
index daccb709890..d36228fa3d7 100644
--- a/src/libcoretest/result.rs
+++ b/src/libcoretest/result.rs
@@ -68,13 +68,13 @@ pub fn test_impl_map_err() {
 /* FIXME(#20575)
 #[test]
 fn test_collect() {
-    let v: Result<Vec<int>, ()> = range(0i, 0).map(|_| Ok::<int, ()>(0)).collect();
+    let v: Result<Vec<int>, ()> = (0i..0).map(|_| Ok::<int, ()>(0)).collect();
     assert!(v == Ok(vec![]));
 
-    let v: Result<Vec<int>, ()> = range(0i, 3).map(|x| Ok::<int, ()>(x)).collect();
+    let v: Result<Vec<int>, ()> = (0i..3).map(|x| Ok::<int, ()>(x)).collect();
     assert!(v == Ok(vec![0, 1, 2]));
 
-    let v: Result<Vec<int>, int> = range(0i, 3).map(|x| {
+    let v: Result<Vec<int>, int> = (0i..3).map(|x| {
         if x > 1 { Err(x) } else { Ok(x) }
     }).collect();
     assert!(v == Err(2));
diff --git a/src/libcoretest/str.rs b/src/libcoretest/str.rs
index 3d89b26be04..938755113b5 100644
--- a/src/libcoretest/str.rs
+++ b/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]));
         }