Implement pretty-printing of `..` and update tests.

Update tests to change all `&expr[]` to `&expr[..]` to make sure pretty printing
passes.

diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index e6d895a49fcd77896657f8e1bedfaf6527e73f0f..ee871c9d59b43129ca40095ba53b76109172a767 100644 (file)
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1813,9 +1813,7 @@ pub fn print_expr(&mut self, expr: &ast::Expr) -> IoResult<()> {
                 if let &Some(ref e) = start {
                     try!(self.print_expr(&**e));
                 }
-                if start.is_some() || end.is_some() {
-                    try!(word(&mut self.s, ".."));
-                }
+                try!(word(&mut self.s, ".."));
                 if let &Some(ref e) = end {
                     try!(self.print_expr(&**e));
                 }

diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index 5386fc0419dc3c405b09283c2f4f70d229fa1486..65713053160d250992d853d202ba4e6bdaccfde2 100644 (file)
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -180,7 +180,7 @@ fn rng(&mut self, max: f32) -> f32 {
 
     fn nextc(&mut self) -> u8 {
         let r = self.rng(1.0);
-        for a in &self.lookup[] {
+        for a in &self.lookup[..] {
             if a.p >= r {
                 return a.c;
             }

diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs
index 6b6ab3f29701953fc326385f8be4464df2092077..82425d2c22708760bc5d67ecc4683615de8b1836 100644 (file)
--- a/src/test/compile-fail/packed-struct-generic-transmute.rs
+++ b/src/test/compile-fail/packed-struct-generic-transmute.rs
@@ -32,6 +32,6 @@ fn main() {
     let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 };
     unsafe {
         let oof: Oof<[u8; 5], i32> = mem::transmute(foo);
-        println!("{:?} {:?}", &oof.rab[], oof.zab);
+        println!("{:?} {:?}", &oof.rab[..], oof.zab);
     }
 }

diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs
index 9b030de998373be9b62b6b9542d8de7fbb5c4a11..1fcbae833dc7f00342660e55494a2c375917d521 100644 (file)
--- a/src/test/run-pass/auto-encode.rs
+++ b/src/test/run-pass/auto-encode.rs
@@ -35,7 +35,7 @@ fn test_rbml<'a, 'b, A:
     let mut rbml_w = EBwriter::Encoder::new(&mut wr);
     a1.encode(&mut rbml_w);
 
-    let d: serialize::rbml::Doc<'a> = EBDoc::new(&wr[]);
+    let d: serialize::rbml::Doc<'a> = EBDoc::new(&wr);
     let mut decoder: EBReader::Decoder<'a> = EBreader::Decoder::new(d);
     let a2: A = Decodable::decode(&mut decoder);
     assert!(*a1 == a2);

diff --git a/src/test/run-pass/coerce-overloaded-autoderef.rs b/src/test/run-pass/coerce-overloaded-autoderef.rs
index ae4db40411553d4efb4f165f9e97218c76d25b5c..ec8d58616dc0fc66c902c48226b32a1d0fdaeb59 100644 (file)
--- a/src/test/run-pass/coerce-overloaded-autoderef.rs
+++ b/src/test/run-pass/coerce-overloaded-autoderef.rs
@@ -47,11 +47,11 @@ fn use_slice(_: &[u8]) {}
 fn use_slice_mut(_: &mut [u8]) {}
 
 fn use_vec(mut v: Vec<u8>) {
-    use_slice_mut(&mut v[]); // what you have to write today
-    use_slice_mut(&mut v);   // what you'd be able to write
+    use_slice_mut(&mut v[..]); // what you have to write today
+    use_slice_mut(&mut v);     // what you'd be able to write
     use_slice_mut(&mut &mut &mut v);
 
-    use_slice(&v[]);    // what you have to write today
+    use_slice(&v[..]);  // what you have to write today
     use_slice(&v);      // what you'd be able to write
     use_slice(&&&&&&v);
     use_slice(&mut &&&&&v);
@@ -59,7 +59,7 @@ fn use_vec(mut v: Vec<u8>) {
 }
 
 fn use_vec_ref(v: &Vec<u8>) {
-    use_slice(&v[]);    // what you have to write today
+    use_slice(&v[..]);  // what you have to write today
     use_slice(v);       // what you'd be able to write
     use_slice(&&&&&&v);
     use_slice(&mut &&&&&v);

diff --git a/src/test/run-pass/deriving-encodable-decodable.rs b/src/test/run-pass/deriving-encodable-decodable.rs
index 8c93f1ec78dc1f0849834b265db35c362dd6aedc..ea43163775ce908172c827ff386abd5dc89a9847 100644 (file)
--- a/src/test/run-pass/deriving-encodable-decodable.rs
+++ b/src/test/run-pass/deriving-encodable-decodable.rs
@@ -59,7 +59,7 @@ fn roundtrip<'a, T: Rand + Eq + Encodable<Encoder<'a>> +
     let mut w = Vec::new();
     let mut e = Encoder::new(&mut w);
     obj.encode(&mut e);
-    let doc = rbml::Doc::new(&w[]);
+    let doc = rbml::Doc::new(&w);
     let mut dec = Decoder::new(doc);
     let obj2 = Decodable::decode(&mut dec);
     assert!(obj == obj2);

diff --git a/src/test/run-pass/foreach-external-iterators-break.rs b/src/test/run-pass/foreach-external-iterators-break.rs
index e9e8c3f09290d784e1999f3d802a330747248423..25d625e27f6ddd40578fad4ef9424085a830778b 100644 (file)
--- a/src/test/run-pass/foreach-external-iterators-break.rs
+++ b/src/test/run-pass/foreach-external-iterators-break.rs
@@ -11,7 +11,7 @@
 pub fn main() {
     let x = [1; 100];
     let mut y = 0;
-    for i in &x[] {
+    for i in &x[..] {
         if y > 10 {
             break;
         }

diff --git a/src/test/run-pass/foreach-external-iterators-nested.rs b/src/test/run-pass/foreach-external-iterators-nested.rs
index 6acfbc95317627bc9213fa92eb18032f6e7aed15..3817e1b0edace950ce3f320474ef3881e92cf4d5 100644 (file)
--- a/src/test/run-pass/foreach-external-iterators-nested.rs
+++ b/src/test/run-pass/foreach-external-iterators-nested.rs
@@ -13,8 +13,8 @@ pub fn main() {
     let y = [2; 100];
     let mut p = 0;
     let mut q = 0;
-    for i in &x[] {
-        for j in &y[] {
+    for i in &x[..] {
+        for j in &y[..] {
             p += *j;
         }
         q += *i + p;

diff --git a/src/test/run-pass/foreach-external-iterators.rs b/src/test/run-pass/foreach-external-iterators.rs
index 2f154be659d888538de644a2f2cc1da4405bfb55..8403a1669ffcf5fecd6e2fe8f688fab6f1ec4fe0 100644 (file)
--- a/src/test/run-pass/foreach-external-iterators.rs
+++ b/src/test/run-pass/foreach-external-iterators.rs
@@ -11,7 +11,7 @@
 pub fn main() {
     let x = [1; 100];
     let mut y = 0;
-    for i in &x[] {
+    for i in &x[..] {
         y += *i
     }
     assert!(y == 100);

diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs
index 379b8f7700e594fb66d8b043a8ab6ceda260f74b..b1c443dd0c51b5713a2721c538bf0d84b18bbc5d 100644 (file)
--- a/src/test/run-pass/issue-8898.rs
+++ b/src/test/run-pass/issue-8898.rs
@@ -18,9 +18,9 @@ pub fn main() {
     let x  = [(), ()];
     let slice = &x[..1];
 
-    assert_repr_eq(&abc[], "[1, 2, 3]".to_string());
-    assert_repr_eq(&tf[], "[true, false]".to_string());
-    assert_repr_eq(&x[], "[(), ()]".to_string());
+    assert_repr_eq(&abc[..], "[1, 2, 3]".to_string());
+    assert_repr_eq(&tf[..], "[true, false]".to_string());
+    assert_repr_eq(&x[..], "[(), ()]".to_string());
     assert_repr_eq(slice, "[()]".to_string());
-    assert_repr_eq(&x[], "[(), ()]".to_string());
+    assert_repr_eq(&x[..], "[(), ()]".to_string());
 }

diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs
index 6a1384ff9339614ed4913f0bf329449eb8f88961..6d72e9774dca839b0982cb7d751f9c4a80ba36af 100644 (file)
--- a/src/test/run-pass/repeated-vector-syntax.rs
+++ b/src/test/run-pass/repeated-vector-syntax.rs
@@ -13,9 +13,9 @@ pub fn main() {
     let y = [ 0; 1 ];
 
     print!("[");
-    for xi in &x[] {
-        print!("{:?}, ", &xi[]);
+    for xi in &x[..] {
+        print!("{:?}, ", &xi[..]);
     }
     println!("]");
-    println!("{:?}", &y[]);
+    println!("{:?}", &y[..]);
 }

diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs
index 3f6afc8d987a6b9f0970803036f77b14bb6efd4d..6e256be69dac74c1d463ebe30f493c2518e0c306 100644 (file)
--- a/src/test/run-pass/slice-2.rs
+++ b/src/test/run-pass/slice-2.rs
@@ -13,7 +13,6 @@
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     let cmp: &[int] = &[1, 2, 3, 4, 5];
-    assert!(&x[] == cmp);
     assert!(&x[..] == cmp);
     let cmp: &[int] = &[3, 4, 5];
     assert!(&x[2..] == cmp);
@@ -24,7 +23,7 @@ fn main() {
 
     let x: Vec<int> = vec![1, 2, 3, 4, 5];
     let cmp: &[int] = &[1, 2, 3, 4, 5];
-    assert!(&x[] == cmp);
+    assert!(&x[..] == cmp);
     let cmp: &[int] = &[3, 4, 5];
     assert!(&x[2..] == cmp);
     let cmp: &[int] = &[1, 2, 3];
@@ -35,7 +34,6 @@ fn main() {
     let x: &mut [int] = &mut [1, 2, 3, 4, 5];
     {
         let cmp: &mut [int] = &mut [1, 2, 3, 4, 5];
-        assert!(&mut x[] == cmp);
         assert!(&mut x[..] == cmp);
     }
     {
@@ -54,7 +52,6 @@ fn main() {
     let mut x: Vec<int> = vec![1, 2, 3, 4, 5];
     {
         let cmp: &mut [int] = &mut [1, 2, 3, 4, 5];
-        assert!(&mut x[] == cmp);
         assert!(&mut x[..] == cmp);
     }
     {

diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs
index 81db525db28a2a3d40c7053d4fe69785f0a3c31a..59fb24ffc02cd405ded5acb56abf80f63c1348ae 100644 (file)
--- a/src/test/run-pass/slice.rs
+++ b/src/test/run-pass/slice.rs
@@ -80,11 +80,11 @@ fn index_mut(&mut self, _index: &RangeFull) -> &mut Foo {
 
 fn main() {
     let mut x = Foo;
-    &x[];
+    &x[..];
     &x[Foo..];
     &x[..Foo];
     &x[Foo..Foo];
-    &mut x[];
+    &mut x[..];
     &mut x[Foo..];
     &mut x[..Foo];
     &mut x[Foo..Foo];