Allow use of `[_ ; n]` syntax for fixed length and repeating arrays.

This does NOT break any existing programs because the `[_, ..n]` syntax is also supported.

122 files changed, 260 insertions, 266 deletions

diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index b0124977c9f..b65473bb767 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -452,7 +452,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
         ty_vec(t, sz) => {
             let inner_str = ty_to_string(cx, t);
             match sz {
-                Some(n) => format!("[{}, ..{}]", inner_str, n),
+                Some(n) => format!("[{}; {}]", inner_str, n),
                 None => format!("[{}]", inner_str),
             }
         }
diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs
index 9a5e6830da1..cdb36602f15 100644
--- a/src/librustc_trans/trans/debuginfo.rs
+++ b/src/librustc_trans/trans/debuginfo.rs
@@ -334,7 +334,7 @@ impl<'tcx> TypeMap<'tcx> {
         // mut ptr (*mut)       -> {*mut :pointee-uid:}
         // unique ptr (~)       -> {~ :pointee-uid:}
         // @-ptr (@)            -> {@ :pointee-uid:}
-        // sized vec ([T, ..x]) -> {[:size:] :element-uid:}
+        // sized vec ([T; x])   -> {[:size:] :element-uid:}
         // unsized vec ([T])    -> {[] :element-uid:}
         // trait (T)            -> {trait_:svh: / :node-id:_<(:param-uid:),*> }
         // closure              -> {<unsafe_> <once_> :store-sigil: |(:param-uid:),* <,_...>| -> \
@@ -3752,7 +3752,7 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
             match optional_length {
                 Some(len) => {
-                    output.push_str(format!(", ..{}", len).as_slice());
+                    output.push_str(format!("; {}", len).as_slice());
                 }
                 None => { /* nothing to do */ }
             };
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 3ad224b93ce..620dfd643d2 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1548,7 +1548,7 @@ impl<'a> Parser<'a> {
             self.expect(&token::OpenDelim(token::Bracket));
             let t = self.parse_ty_sum();
 
-            // Parse the `, ..e` in `[ int, ..e ]`
+            // Parse the `; e` in `[ int; e ]`
             // where `e` is a const expression
             let t = match self.maybe_parse_fixed_vstore() {
                 None => TyVec(t),
@@ -1716,6 +1716,9 @@ impl<'a> Parser<'a> {
             self.bump();
             self.bump();
             Some(self.parse_expr())
+        } else if self.check(&token::Semi) {
+            self.bump();
+            Some(self.parse_expr())
         } else {
             None
         }
@@ -2262,6 +2265,12 @@ impl<'a> Parser<'a> {
                         let count = self.parse_expr();
                         self.expect(&token::CloseDelim(token::Bracket));
                         ex = ExprRepeat(first_expr, count);
+                    } else if self.check(&token::Semi) {
+                        // Repeating vector syntax: [ 0; 512 ]
+                        self.bump();
+                        let count = self.parse_expr();
+                        self.expect(&token::CloseDelim(token::Bracket));
+                        ex = ExprRepeat(first_expr, count);
                     } else if self.check(&token::Comma) {
                         // Vector with two or more elements.
                         self.bump();
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index d2cc0cba317..993fbed10a8 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -755,7 +755,7 @@ impl<'a> State<'a> {
             ast::TyFixedLengthVec(ref ty, ref v) => {
                 try!(word(&mut self.s, "["));
                 try!(self.print_type(&**ty));
-                try!(word(&mut self.s, ", .."));
+                try!(word(&mut self.s, "; "));
                 try!(self.print_expr(&**v));
                 try!(word(&mut self.s, "]"));
             }
@@ -1531,8 +1531,7 @@ impl<'a> State<'a> {
                 try!(self.ibox(indent_unit));
                 try!(word(&mut self.s, "["));
                 try!(self.print_expr(&**element));
-                try!(word(&mut self.s, ","));
-                try!(word(&mut self.s, ".."));
+                try!(self.word_space(";"));
                 try!(self.print_expr(&**count));
                 try!(word(&mut self.s, "]"));
                 try!(self.end());
diff --git a/src/test/auxiliary/nested_item.rs b/src/test/auxiliary/nested_item.rs
index 96bae656390..d97a2e3cda1 100644
--- a/src/test/auxiliary/nested_item.rs
+++ b/src/test/auxiliary/nested_item.rs
@@ -28,7 +28,7 @@ impl<T> Foo {
 pub struct Parser<T>;
 impl<T: std::iter::Iterator<char>> Parser<T> {
     fn in_doctype(&mut self) {
-        static DOCTYPEPattern: [char, ..6] = ['O', 'C', 'T', 'Y', 'P', 'E'];
+        static DOCTYPEPattern: [char; 6] = ['O', 'C', 'T', 'Y', 'P', 'E'];
     }
 }
 
diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs
index 025f8467d20..75cf864ce49 100644
--- a/src/test/bench/noise.rs
+++ b/src/test/bench/noise.rs
@@ -37,20 +37,20 @@ fn gradient(orig: Vec2, grad: Vec2, p: Vec2) -> f32 {
 }
 
 struct Noise2DContext {
-    rgradients: [Vec2, ..256],
-    permutations: [i32, ..256],
+    rgradients: [Vec2; 256],
+    permutations: [i32; 256],
 }
 
 impl Noise2DContext {
     fn new() -> Noise2DContext {
         let mut rng = StdRng::new().unwrap();
 
-        let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }, ..256];
+        let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }; 256];
         for x in rgradients.iter_mut() {
             *x = random_gradient(&mut rng);
         }
 
-        let mut permutations = [0i32, ..256];
+        let mut permutations = [0i32; 256];
         for (i, x) in permutations.iter_mut().enumerate() {
             *x = i as i32;
         }
@@ -65,7 +65,7 @@ impl Noise2DContext {
         self.rgradients[(idx & 255) as uint]
     }
 
-    fn get_gradients(&self, x: f32, y: f32) -> ([Vec2, ..4], [Vec2, ..4]) {
+    fn get_gradients(&self, x: f32, y: f32) -> ([Vec2; 4], [Vec2; 4]) {
         let x0f = x.floor();
         let y0f = y.floor();
         let x1f = x0f + 1.0;
@@ -102,7 +102,7 @@ impl Noise2DContext {
 
 fn main() {
     let symbols = [' ', '░', '▒', '▓', '█', '█'];
-    let mut pixels = [0f32, ..256*256];
+    let mut pixels = [0f32; 256*256];
     let n2d = Noise2DContext::new();
 
     for _ in range(0u, 100) {
diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs
index 4849421a3f0..723b2b722d7 100644
--- a/src/test/bench/shootout-fannkuch-redux.rs
+++ b/src/test/bench/shootout-fannkuch-redux.rs
@@ -64,14 +64,14 @@ fn next_permutation(perm: &mut [i32], count: &mut [i32]) {
 }
 
 struct P {
-    p: [i32, .. 16],
+    p: [i32; 16],
 }
 
 impl Copy for P {}
 
 struct Perm {
-    cnt: [i32, .. 16],
-    fact: [u32, .. 16],
+    cnt: [i32; 16],
+    fact: [u32; 16],
     n: u32,
     permcount: u32,
     perm: P,
@@ -81,21 +81,21 @@ impl Copy for Perm {}
 
 impl Perm {
     fn new(n: u32) -> Perm {
-        let mut fact = [1, .. 16];
+        let mut fact = [1; 16];
         for i in range(1, n as uint + 1) {
             fact[i] = fact[i - 1] * i as u32;
         }
         Perm {
-            cnt: [0, .. 16],
+            cnt: [0; 16],
             fact: fact,
             n: n,
             permcount: 0,
-            perm: P { p: [0, .. 16 ] }
+            perm: P { p: [0; 16 ] }
         }
     }
 
     fn get(&mut self, mut idx: i32) -> P {
-        let mut pp = [0u8, .. 16];
+        let mut pp = [0u8; 16];
         self.permcount = idx as u32;
         for (i, place) in self.perm.p.iter_mut().enumerate() {
             *place = i as i32 + 1;
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index afffbe5bed4..eb18cfdaed3 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -64,7 +64,7 @@ const ALU: &'static str = "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTG\
 
 const NULL_AMINO_ACID: AminoAcid = AminoAcid { c: ' ' as u8, p: 0.0 };
 
-static IUB: [AminoAcid, ..15] = [
+static IUB: [AminoAcid;15] = [
     AminoAcid { c: 'a' as u8, p: 0.27 },
     AminoAcid { c: 'c' as u8, p: 0.12 },
     AminoAcid { c: 'g' as u8, p: 0.12 },
@@ -82,7 +82,7 @@ static IUB: [AminoAcid, ..15] = [
     AminoAcid { c: 'Y' as u8, p: 0.02 },
 ];
 
-static HOMO_SAPIENS: [AminoAcid, ..4] = [
+static HOMO_SAPIENS: [AminoAcid;4] = [
     AminoAcid { c: 'a' as u8, p: 0.3029549426680 },
     AminoAcid { c: 'c' as u8, p: 0.1979883004921 },
     AminoAcid { c: 'g' as u8, p: 0.1975473066391 },
@@ -148,8 +148,8 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
     }
 }
 
-fn make_lookup(a: &[AminoAcid]) -> [AminoAcid, ..LOOKUP_SIZE] {
-    let mut lookup = [ NULL_AMINO_ACID, ..LOOKUP_SIZE ];
+fn make_lookup(a: &[AminoAcid]) -> [AminoAcid;LOOKUP_SIZE] {
+    let mut lookup = [ NULL_AMINO_ACID;LOOKUP_SIZE ];
     let mut j = 0;
     for (i, slot) in lookup.iter_mut().enumerate() {
         while a[j].p < (i as f32) {
@@ -162,7 +162,7 @@ fn make_lookup(a: &[AminoAcid]) -> [AminoAcid, ..LOOKUP_SIZE] {
 
 struct RandomFasta<'a, W:'a> {
     seed: u32,
-    lookup: [AminoAcid, ..LOOKUP_SIZE],
+    lookup: [AminoAcid;LOOKUP_SIZE],
     out: &'a mut W,
 }
 
@@ -193,7 +193,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> {
     fn make(&mut self, n: uint) -> IoResult<()> {
         let lines = n / LINE_LEN;
         let chars_left = n % LINE_LEN;
-        let mut buf = [0, ..LINE_LEN + 1];
+        let mut buf = [0;LINE_LEN + 1];
 
         for _ in range(0, lines) {
             for i in range(0u, LINE_LEN) {
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 1f0bed05521..2de61cf3572 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -89,7 +89,7 @@ fn make_fasta<W: Writer, I: Iterator<u8>>(
     -> std::io::IoResult<()>
 {
     try!(wr.write(header.as_bytes()));
-    let mut line = [0u8, .. LINE_LENGTH + 1];
+    let mut line = [0u8; LINE_LENGTH + 1];
     while n > 0 {
         let nb = min(LINE_LENGTH, n);
         for i in range(0, nb) {
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index d112fe60674..8521e2216e9 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -46,10 +46,10 @@ use std::string::String;
 use std::slice;
 use std::sync::{Arc, Future};
 
-static TABLE: [u8, ..4] = [ 'A' as u8, 'C' as u8, 'G' as u8, 'T' as u8 ];
+static TABLE: [u8;4] = [ 'A' as u8, 'C' as u8, 'G' as u8, 'T' as u8 ];
 static TABLE_SIZE: uint = 2 << 16;
 
-static OCCURRENCES: [&'static str, ..5] = [
+static OCCURRENCES: [&'static str;5] = [
     "GGT",
     "GGTA",
     "GGTATT",
diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index 3f36c16aff6..dab67331120 100644
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -45,7 +45,7 @@ const SOLAR_MASS: f64 = 4.0 * PI * PI;
 const YEAR: f64 = 365.24;
 const N_BODIES: uint = 5;
 
-static BODIES: [Planet, ..N_BODIES] = [
+static BODIES: [Planet;N_BODIES] = [
     // Sun
     Planet {
         x: 0.0, y: 0.0, z: 0.0,
@@ -102,7 +102,7 @@ struct Planet {
 
 impl Copy for Planet {}
 
-fn advance(bodies: &mut [Planet, ..N_BODIES], dt: f64, steps: int) {
+fn advance(bodies: &mut [Planet;N_BODIES], dt: f64, steps: int) {
     for _ in range(0, steps) {
         let mut b_slice = bodies.as_mut_slice();
         loop {
@@ -135,7 +135,7 @@ fn advance(bodies: &mut [Planet, ..N_BODIES], dt: f64, steps: int) {
     }
 }
 
-fn energy(bodies: &[Planet, ..N_BODIES]) -> f64 {
+fn energy(bodies: &[Planet;N_BODIES]) -> f64 {
     let mut e = 0.0;
     let mut bodies = bodies.iter();
     loop {
@@ -155,7 +155,7 @@ fn energy(bodies: &[Planet, ..N_BODIES]) -> f64 {
     e
 }
 
-fn offset_momentum(bodies: &mut [Planet, ..N_BODIES]) {
+fn offset_momentum(bodies: &mut [Planet;N_BODIES]) {
     let mut px = 0.0;
     let mut py = 0.0;
     let mut pz = 0.0;
diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs
index 312ee2dd27e..d746ec1dbab 100644
--- a/src/test/bench/shootout-reverse-complement.rs
+++ b/src/test/bench/shootout-reverse-complement.rs
@@ -50,17 +50,17 @@ use std::ptr::{copy_memory};
 use std::io::{IoResult, EndOfFile};
 
 struct Tables {
-    table8: [u8, ..1 << 8],
-    table16: [u16, ..1 << 16]
+    table8: [u8;1 << 8],
+    table16: [u16;1 << 16]
 }
 
 impl Tables {
     fn new() -> Tables {
-        let mut table8 = [0, ..1 << 8];
+        let mut table8 = [0;1 << 8];
         for (i, v) in table8.iter_mut().enumerate() {
             *v = Tables::computed_cpl8(i as u8);
         }
-        let mut table16 = [0, ..1 << 16];
+        let mut table16 = [0;1 << 16];
         for (i, v) in table16.iter_mut().enumerate() {
             *v = table8[i & 255] as u16 << 8 |
                  table8[i >> 8]  as u16;
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index c55f85f40e8..5fb7e2c3a84 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -46,7 +46,7 @@ impl Sudoku {
         return Sudoku { grid: g }
     }
 
-    pub fn from_vec(vec: &[[u8, ..9], ..9]) -> Sudoku {
+    pub fn from_vec(vec: &[[u8;9];9]) -> Sudoku {
         let g = Vec::from_fn(9u, |i| {
             Vec::from_fn(9u, |j| { vec[i][j] })
         });
@@ -198,7 +198,7 @@ impl Colors {
     }
 }
 
-static DEFAULT_SUDOKU: [[u8, ..9], ..9] = [
+static DEFAULT_SUDOKU: [[u8;9];9] = [
          /* 0    1    2    3    4    5    6    7    8    */
   /* 0 */  [0u8, 4u8, 0u8, 6u8, 0u8, 0u8, 0u8, 3u8, 2u8],
   /* 1 */  [0u8, 0u8, 8u8, 0u8, 2u8, 0u8, 0u8, 0u8, 0u8],
@@ -212,7 +212,7 @@ static DEFAULT_SUDOKU: [[u8, ..9], ..9] = [
 ];
 
 #[cfg(test)]
-static DEFAULT_SOLUTION: [[u8, ..9], ..9] = [
+static DEFAULT_SOLUTION: [[u8;9];9] = [
          /* 0    1    2    3    4    5    6    7    8    */
   /* 0 */  [1u8, 4u8, 9u8, 6u8, 7u8, 5u8, 8u8, 3u8, 2u8],
   /* 1 */  [5u8, 3u8, 8u8, 1u8, 2u8, 9u8, 7u8, 4u8, 6u8],
diff --git a/src/test/compile-fail/better-expected.rs b/src/test/compile-fail/better-expected.rs
index 489f892726a..2e0f2a174c6 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: [int ..3]; //~ ERROR expected one of `(`, `+`, `,`, `::`, or `]`, found `..`
+    let x: [int 3]; //~ ERROR expected one of `(`, `+`, `,`, `::`, `;`, or `]`, found `3`
 }
diff --git a/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs b/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
index 93a4383b4f5..f0d42bb9ac1 100644
--- a/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
+++ b/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
@@ -11,7 +11,7 @@
 // Issue #16205.
 
 struct Foo {
-    a: [Box<int>, ..3],
+    a: [Box<int>; 3],
 }
 
 fn main() {
diff --git a/src/test/compile-fail/coercion-slice.rs b/src/test/compile-fail/coercion-slice.rs
index bb020688f58..b6b46fadb13 100644
--- a/src/test/compile-fail/coercion-slice.rs
+++ b/src/test/compile-fail/coercion-slice.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Tests that we forbid coercion from `[T, ..n]` to `&[T]`
+// Tests that we forbid coercion from `[T; n]` to `&[T]`
 
 fn main() {
-    let _: &[int] = [0i]; //~ERROR: mismatched types: expected `&[int]`, found `[int, ..1]`
+    let _: &[int] = [0i]; //~ERROR: mismatched types: expected `&[int]`, found `[int; 1]`
 }
diff --git a/src/test/compile-fail/const-cast-wrong-type.rs b/src/test/compile-fail/const-cast-wrong-type.rs
index 223426dc7c6..b3597441834 100644
--- a/src/test/compile-fail/const-cast-wrong-type.rs
+++ b/src/test/compile-fail/const-cast-wrong-type.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static a: [u8, ..3] = ['h' as u8, 'i' as u8, 0 as u8];
+static a: [u8; 3] = ['h' as u8, 'i' as u8, 0 as u8];
 static b: *const i8 = &a as *const i8; //~ ERROR mismatched types
 
 fn main() {
diff --git a/src/test/compile-fail/dst-bad-coerce1.rs b/src/test/compile-fail/dst-bad-coerce1.rs
index 59499ac070d..c77ae25e0cf 100644
--- a/src/test/compile-fail/dst-bad-coerce1.rs
+++ b/src/test/compile-fail/dst-bad-coerce1.rs
@@ -20,9 +20,9 @@ trait Bar {}
 pub fn main() {
     // With a vec of ints.
     let f1 = Fat { ptr: [1, 2, 3] };
-    let f2: &Fat<[int, ..3]> = &f1;
+    let f2: &Fat<[int; 3]> = &f1;
     let f3: &Fat<[uint]> = f2;
-    //~^ ERROR mismatched types: expected `&Fat<[uint]>`, found `&Fat<[int, ..3]>`
+    //~^ ERROR mismatched types: expected `&Fat<[uint]>`, found `&Fat<[int; 3]>`
 
     // With a trait.
     let f1 = Fat { ptr: Foo };
diff --git a/src/test/compile-fail/dst-bad-coerce2.rs b/src/test/compile-fail/dst-bad-coerce2.rs
index e1a754b6332..6eb650e9781 100644
--- a/src/test/compile-fail/dst-bad-coerce2.rs
+++ b/src/test/compile-fail/dst-bad-coerce2.rs
@@ -21,7 +21,7 @@ impl Bar for Foo {}
 pub fn main() {
     // With a vec of ints.
     let f1 = Fat { ptr: [1, 2, 3] };
-    let f2: &Fat<[int, ..3]> = &f1;
+    let f2: &Fat<[int; 3]> = &f1;
     let f3: &mut Fat<[int]> = f2; //~ ERROR mismatched types
 
     // With a trait.
diff --git a/src/test/compile-fail/dst-bad-coerce3.rs b/src/test/compile-fail/dst-bad-coerce3.rs
index 7cf647a26d7..b0bd5176374 100644
--- a/src/test/compile-fail/dst-bad-coerce3.rs
+++ b/src/test/compile-fail/dst-bad-coerce3.rs
@@ -21,7 +21,7 @@ impl Bar for Foo {}
 fn baz<'a>() {
     // With a vec of ints.
     let f1 = Fat { ptr: [1, 2, 3] };
-    let f2: &Fat<[int, ..3]> = &f1; //~ ERROR `f1` does not live long enough
+    let f2: &Fat<[int; 3]> = &f1; //~ ERROR `f1` does not live long enough
     let f3: &'a Fat<[int]> = f2;
 
     // With a trait.
diff --git a/src/test/compile-fail/dst-bad-coerce4.rs b/src/test/compile-fail/dst-bad-coerce4.rs
index 9010185f76b..783a32d6302 100644
--- a/src/test/compile-fail/dst-bad-coerce4.rs
+++ b/src/test/compile-fail/dst-bad-coerce4.rs
@@ -17,6 +17,6 @@ struct Fat<Sized? T> {
 pub fn main() {
     // With a vec of ints.
     let f1: &Fat<[int]> = &Fat { ptr: [1, 2, 3] };
-    let f2: &Fat<[int, ..3]> = f1;
-    //~^ ERROR mismatched types: expected `&Fat<[int, ..3]>`, found `&Fat<[int]>`
+    let f2: &Fat<[int; 3]> = f1;
+    //~^ ERROR mismatched types: expected `&Fat<[int; 3]>`, found `&Fat<[int]>`
 }
diff --git a/src/test/compile-fail/dst-bad-deep.rs b/src/test/compile-fail/dst-bad-deep.rs
index 506322d41f5..0833a74f1da 100644
--- a/src/test/compile-fail/dst-bad-deep.rs
+++ b/src/test/compile-fail/dst-bad-deep.rs
@@ -18,7 +18,7 @@ struct Fat<Sized? T> {
 }
 
 pub fn main() {
-    let f: Fat<[int, ..3]> = Fat { ptr: [5i, 6, 7] };
+    let f: Fat<[int; 3]> = Fat { ptr: [5i, 6, 7] };
     let g: &Fat<[int]> = &f;
     let h: &Fat<Fat<[int]>> = &Fat { ptr: *g };
     //~^ ERROR the trait `core::kinds::Sized` is not implemented
diff --git a/src/test/compile-fail/huge-array-simple.rs b/src/test/compile-fail/huge-array-simple.rs
index 17f85c7bd2b..a9dda771b7f 100644
--- a/src/test/compile-fail/huge-array-simple.rs
+++ b/src/test/compile-fail/huge-array-simple.rs
@@ -11,5 +11,5 @@
 // error-pattern: too big for the current
 
 fn main() {
-   let fat : [u8, ..(1<<61)+(1<<31)] = [0, ..(1u64<<61) as uint +(1u64<<31) as uint];
+   let fat : [u8; (1<<61)+(1<<31)] = [0; (1u64<<61) as uint +(1u64<<31) as uint];
 }
diff --git a/src/test/compile-fail/huge-array.rs b/src/test/compile-fail/huge-array.rs
index 4b91564154b..029e9651cb3 100644
--- a/src/test/compile-fail/huge-array.rs
+++ b/src/test/compile-fail/huge-array.rs
@@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern: ..1518599999
+// error-pattern:; 1518599999
 
 fn generic<T: Copy>(t: T) {
-    let s: [T, ..1518600000] = [t, ..1518600000];
+    let s: [T; 1518600000] = [t; 1518600000];
 }
 
 fn main() {
-    let x: [u8, ..1518599999] = [0, ..1518599999];
-    generic::<[u8, ..1518599999]>(x);
+    let x: [u8; 1518599999] = [0; 1518599999];
+    generic::<[u8; 1518599999]>(x);
 }
diff --git a/src/test/compile-fail/huge-enum.rs b/src/test/compile-fail/huge-enum.rs
index 4a85cb5753b..7c7a75abf3f 100644
--- a/src/test/compile-fail/huge-enum.rs
+++ b/src/test/compile-fail/huge-enum.rs
@@ -14,10 +14,10 @@
 
 #[cfg(target_word_size = "32")]
 fn main() {
-    let big: Option<[u32, ..(1<<29)-1]> = None;
+    let big: Option<[u32; (1<<29)-1]> = None;
 }
 
 #[cfg(target_word_size = "64")]
 fn main() {
-    let big: Option<[u32, ..(1<<45)-1]> = None;
+    let big: Option<[u32; (1<<45)-1]> = None;
 }
diff --git a/src/test/compile-fail/issue-13446.rs b/src/test/compile-fail/issue-13446.rs
index 162324b7c59..a0a7660428d 100644
--- a/src/test/compile-fail/issue-13446.rs
+++ b/src/test/compile-fail/issue-13446.rs
@@ -13,7 +13,7 @@
 
 // error-pattern: mismatched types
 
-static VEC: [u32, ..256] = vec!();
+static VEC: [u32; 256] = vec!();
 
 fn main() {}
 
diff --git a/src/test/compile-fail/issue-13482-2.rs b/src/test/compile-fail/issue-13482-2.rs
index 4ec8c2b1b7e..ef7d3d4d158 100644
--- a/src/test/compile-fail/issue-13482-2.rs
+++ b/src/test/compile-fail/issue-13482-2.rs
@@ -14,7 +14,7 @@ fn main() {
     let x = [1,2];
     let y = match x {
         [] => None,
-        //~^ ERROR types: expected `[_#0i, ..2]`, found `[_#7t, ..0]`
+        //~^ ERROR types: expected `[_#0i; 2]`, found `[_#7t; 0]`
         //         (expected array of 2 elements, found array of 0 elements)
         [a,_] => Some(a)
     };
diff --git a/src/test/compile-fail/issue-13482.rs b/src/test/compile-fail/issue-13482.rs
index 18070ed53b0..157280b1719 100644
--- a/src/test/compile-fail/issue-13482.rs
+++ b/src/test/compile-fail/issue-13482.rs
@@ -12,7 +12,7 @@ fn main() {
   let x = [1,2];
   let y = match x {
     [] => None,
-//~^ ERROR types: expected `[_, ..2]`, found `[_, ..0]`
+//~^ ERROR types: expected `[_; 2]`, found `[_; 0]`
 //         (expected array of 2 elements, found array of 0 elements)
     [a,_] => Some(a)
   };
diff --git a/src/test/compile-fail/issue-14845.rs b/src/test/compile-fail/issue-14845.rs
index bc606d8139f..5166d84a025 100644
--- a/src/test/compile-fail/issue-14845.rs
+++ b/src/test/compile-fail/issue-14845.rs
@@ -10,15 +10,15 @@
 
 
 struct X {
-    a: [u8, ..1]
+    a: [u8; 1]
 }
 
 fn main() {
     let x = X { a: [0] };
     let _f = &x.a as *mut u8;
-    //~^ ERROR mismatched types: expected `*mut u8`, found `&[u8, ..1]`
+    //~^ ERROR mismatched types: expected `*mut u8`, found `&[u8; 1]`
 
     let local = [0u8];
     let _v = &local as *mut u8;
-    //~^ ERROR mismatched types: expected `*mut u8`, found `&[u8, ..1]`
+    //~^ ERROR mismatched types: expected `*mut u8`, found `&[u8; 1]`
 }
diff --git a/src/test/compile-fail/issue-17252.rs b/src/test/compile-fail/issue-17252.rs
index 4a6b80d765b..4adb3f041a3 100644
--- a/src/test/compile-fail/issue-17252.rs
+++ b/src/test/compile-fail/issue-17252.rs
@@ -11,10 +11,10 @@
 static FOO: uint = FOO; //~ ERROR recursive constant
 
 fn main() {
-    let _x: [u8, ..FOO]; // caused stack overflow prior to fix
+    let _x: [u8; FOO]; // caused stack overflow prior to fix
     let _y: uint = 1 + {
         static BAR: uint = BAR; //~ ERROR recursive constant
-        let _z: [u8, ..BAR]; // caused stack overflow prior to fix
+        let _z: [u8; BAR]; // caused stack overflow prior to fix
         1
     };
 }
diff --git a/src/test/compile-fail/issue-17441.rs b/src/test/compile-fail/issue-17441.rs
index 11c815da1c7..e5da5c5504e 100644
--- a/src/test/compile-fail/issue-17441.rs
+++ b/src/test/compile-fail/issue-17441.rs
@@ -10,7 +10,7 @@
 
 fn main() {
     let _foo = &[1u, 2] as [uint];
-    //~^ ERROR cast to unsized type: `&[uint, ..2]` as `[uint]`
+    //~^ ERROR cast to unsized type: `&[uint; 2]` as `[uint]`
     //~^^ HELP consider using an implicit coercion to `&[uint]` instead
     let _bar = box 1u as std::fmt::Show;
     //~^ ERROR cast to unsized type: `Box<uint>` as `core::fmt::Show`
@@ -19,6 +19,6 @@ fn main() {
     //~^ ERROR cast to unsized type: `uint` as `core::fmt::Show`
     //~^^ HELP consider using a box or reference as appropriate
     let _quux = [1u, 2] as [uint];
-    //~^ ERROR cast to unsized type: `[uint, ..2]` as `[uint]`
+    //~^ ERROR cast to unsized type: `[uint; 2]` as `[uint]`
     //~^^ HELP consider using a box or reference as appropriate
 }
diff --git a/src/test/compile-fail/issue-17718-borrow-interior.rs b/src/test/compile-fail/issue-17718-borrow-interior.rs
index 1f763dbdc9f..8aa5fdf1c4d 100644
--- a/src/test/compile-fail/issue-17718-borrow-interior.rs
+++ b/src/test/compile-fail/issue-17718-borrow-interior.rs
@@ -15,7 +15,7 @@ static B: &'static uint = &A.a;
 static C: &'static uint = &(A.a);
 //~^ ERROR: cannot refer to the interior of another static
 
-static D: [uint, ..1] = [1];
+static D: [uint; 1] = [1];
 static E: uint = D[0];
 //~^ ERROR: cannot refer to other statics by value
 static F: &'static uint = &D[0];
diff --git a/src/test/compile-fail/issue-19244-1.rs b/src/test/compile-fail/issue-19244-1.rs
index 7ca83f21305..fafe6377397 100644
--- a/src/test/compile-fail/issue-19244-1.rs
+++ b/src/test/compile-fail/issue-19244-1.rs
@@ -11,6 +11,6 @@
 const TUP: (uint,) = (42,);
 
 fn main() {
-    let a: [int, ..TUP.1];
+    let a: [int; TUP.1];
     //~^ ERROR expected constant expr for array length: tuple index out of bounds
 }
diff --git a/src/test/compile-fail/issue-19244-2.rs b/src/test/compile-fail/issue-19244-2.rs
index d9aeecc0222..95965ca35f9 100644
--- a/src/test/compile-fail/issue-19244-2.rs
+++ b/src/test/compile-fail/issue-19244-2.rs
@@ -12,6 +12,6 @@ struct MyStruct { field: uint }
 const STRUCT: MyStruct = MyStruct { field: 42 };
 
 fn main() {
-    let a: [int, ..STRUCT.nonexistent_field];
+    let a: [int; STRUCT.nonexistent_field];
     //~^ ERROR expected constant expr for array length: nonexistent struct field
 }
diff --git a/src/test/compile-fail/issue-2149.rs b/src/test/compile-fail/issue-2149.rs
index 1150f40db76..3343e92252f 100644
--- a/src/test/compile-fail/issue-2149.rs
+++ b/src/test/compile-fail/issue-2149.rs
@@ -22,5 +22,5 @@ impl<A> vec_monad<A> for Vec<A> {
 }
 fn main() {
     ["hi"].bind(|x| [x] );
-    //~^ ERROR type `[&str, ..1]` does not implement any method in scope named `bind`
+    //~^ ERROR type `[&str; 1]` does not implement any method in scope named `bind`
 }
diff --git a/src/test/compile-fail/issue-4517.rs b/src/test/compile-fail/issue-4517.rs
index f61ed35fca3..1c5fd9be1bd 100644
--- a/src/test/compile-fail/issue-4517.rs
+++ b/src/test/compile-fail/issue-4517.rs
@@ -11,8 +11,8 @@
 fn bar(int_param: int) {}
 
 fn main() {
-    let foo: [u8, ..4] = [1u8, ..4u];
+    let foo: [u8; 4] = [1u8; 4u];
     bar(foo);
-    //~^ ERROR mismatched types: expected `int`, found `[u8, ..4]`
+    //~^ ERROR mismatched types: expected `int`, found `[u8; 4]`
     //         (expected int, found vector)
 }
diff --git a/src/test/compile-fail/lint-uppercase-variables.rs b/src/test/compile-fail/lint-uppercase-variables.rs
index eb5c475e7ef..19373c806f1 100644
--- a/src/test/compile-fail/lint-uppercase-variables.rs
+++ b/src/test/compile-fail/lint-uppercase-variables.rs
@@ -29,7 +29,7 @@ fn main() {
     println!("{}", Test);
 
     let mut f = File::open(&Path::new("something.txt"));
-    let mut buff = [0u8, ..16];
+    let mut buff = [0u8; 16];
     match f.read(&mut buff) {
         Ok(cnt) => println!("read this many bytes: {}", cnt),
         Err(IoError{ kind: EndOfFile, .. }) => println!("Got end of file: {}", EndOfFile.to_string()),
diff --git a/src/test/compile-fail/move-fragments-9.rs b/src/test/compile-fail/move-fragments-9.rs
index ce05087f659..0b095ff6f82 100644
--- a/src/test/compile-fail/move-fragments-9.rs
+++ b/src/test/compile-fail/move-fragments-9.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test moving array structures, e.g. `[T, ..3]` as well as moving
+// Test moving array structures, e.g. `[T; 3]` as well as moving
 // elements in and out of such arrays.
 //
 // Note also that the `test_move_array_then_overwrite` tests represent
@@ -18,14 +18,14 @@ pub struct D { d: int }
 impl Drop for D { fn drop(&mut self) { } }
 
 #[rustc_move_fragments]
-pub fn test_move_array_via_return(a: [D, ..3]) -> [D, ..3] {
+pub fn test_move_array_via_return(a: [D; 3]) -> [D; 3] {
     //~^ ERROR                  assigned_leaf_path: `$(local a)`
     //~| ERROR                     moved_leaf_path: `$(local a)`
     return a;
 }
 
 #[rustc_move_fragments]
-pub fn test_move_array_into_recv(a: [D, ..3], recv: &mut [D, ..3]) {
+pub fn test_move_array_into_recv(a: [D; 3], recv: &mut [D; 3]) {
     //~^ ERROR                 parent_of_fragments: `$(local recv)`
     //~| ERROR                  assigned_leaf_path: `$(local a)`
     //~| ERROR                     moved_leaf_path: `$(local a)`
@@ -34,7 +34,7 @@ pub fn test_move_array_into_recv(a: [D, ..3], recv: &mut [D, ..3]) {
 }
 
 #[rustc_move_fragments]
-pub fn test_extract_array_elem(a: [D, ..3], i: uint) -> D {
+pub fn test_extract_array_elem(a: [D; 3], i: uint) -> D {
     //~^ ERROR                 parent_of_fragments: `$(local a)`
     //~| ERROR                  assigned_leaf_path: `$(local i)`
     //~| ERROR                     moved_leaf_path: `$(local a).[]`
@@ -43,7 +43,7 @@ pub fn test_extract_array_elem(a: [D, ..3], i: uint) -> D {
 }
 
 #[rustc_move_fragments]
-pub fn test_overwrite_array_elem(mut a: [D, ..3], i: uint, d: D) {
+pub fn test_overwrite_array_elem(mut a: [D; 3], i: uint, d: D) {
     //~^ ERROR                 parent_of_fragments: `$(local mut a)`
     //~| ERROR                  assigned_leaf_path: `$(local i)`
     //~| ERROR                  assigned_leaf_path: `$(local d)`
@@ -59,7 +59,7 @@ pub fn test_overwrite_array_elem(mut a: [D, ..3], i: uint, d: D) {
 // See RFC PR 320 for more discussion.
 
 #[rustc_move_fragments]
-pub fn test_move_array_then_overwrite_elem1(mut a: [D, ..3], i: uint, recv: &mut [D, ..3], d: D) {
+pub fn test_move_array_then_overwrite_elem1(mut a: [D; 3], i: uint, recv: &mut [D; 3], d: D) {
     //~^ ERROR                 parent_of_fragments: `$(local mut a)`
     //~| ERROR                 parent_of_fragments: `$(local recv)`
     //~| ERROR                  assigned_leaf_path: `$(local recv).*`
@@ -76,8 +76,8 @@ pub fn test_move_array_then_overwrite_elem1(mut a: [D, ..3], i: uint, recv: &mut
 }
 
 #[rustc_move_fragments]
-pub fn test_move_array_then_overwrite_elem2(mut a: [D, ..3], i: uint, j: uint,
-                                            recv: &mut [D, ..3], d1: D, d2: D) {
+pub fn test_move_array_then_overwrite_elem2(mut a: [D; 3], i: uint, j: uint,
+                                            recv: &mut [D; 3], d1: D, d2: D) {
     //~^^ ERROR                parent_of_fragments: `$(local mut a)`
     //~| ERROR                 parent_of_fragments: `$(local recv)`
     //~| ERROR                  assigned_leaf_path: `$(local recv).*`
diff --git a/src/test/compile-fail/moves-based-on-type-exprs.rs b/src/test/compile-fail/moves-based-on-type-exprs.rs
index 678808f166c..d8d84e558a9 100644
--- a/src/test/compile-fail/moves-based-on-type-exprs.rs
+++ b/src/test/compile-fail/moves-based-on-type-exprs.rs
@@ -89,7 +89,7 @@ fn f100() {
 
 fn f110() {
     let x = vec!("hi".to_string());
-    let _y = [x.into_iter().next().unwrap(), ..1];
+    let _y = [x.into_iter().next().unwrap(); 1];
     touch(&x); //~ ERROR use of moved value: `x`
 }
 
diff --git a/src/test/compile-fail/non-constant-enum-for-vec-repeat.rs b/src/test/compile-fail/non-constant-enum-for-vec-repeat.rs
index 3ccce591ee7..a1dc2ab2041 100644
--- a/src/test/compile-fail/non-constant-enum-for-vec-repeat.rs
+++ b/src/test/compile-fail/non-constant-enum-for-vec-repeat.rs
@@ -11,6 +11,6 @@
 enum State { ST_NULL, ST_WHITESPACE }
 
 fn main() {
-    [State::ST_NULL, ..(State::ST_WHITESPACE as uint)];
+    [State::ST_NULL; (State::ST_WHITESPACE as uint)];
     //~^ ERROR expected constant integer for repeat count, found non-constant expression
 }
diff --git a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
index 91551941c06..85d734ddaf2 100644
--- a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
+++ b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
@@ -12,7 +12,7 @@
 
 fn main() {
     fn bar(n: int) {
-        let _x: [int, ..n];
+        let _x: [int; n];
         //~^ ERROR expected constant expr for array length: non-constant path in constant expr
     }
 }
diff --git a/src/test/compile-fail/non-constant-expr-for-vec-repeat.rs b/src/test/compile-fail/non-constant-expr-for-vec-repeat.rs
index 299e9d3dced..2e063e5237c 100644
--- a/src/test/compile-fail/non-constant-expr-for-vec-repeat.rs
+++ b/src/test/compile-fail/non-constant-expr-for-vec-repeat.rs
@@ -12,6 +12,6 @@
 
 fn main() {
     fn bar(n: uint) {
-        let _x = [0, ..n]; //~ ERROR expected constant integer for repeat count, found variable
+        let _x = [0; n]; //~ ERROR expected constant integer for repeat count, found variable
     }
 }
diff --git a/src/test/compile-fail/non-exhaustive-pattern-witness.rs b/src/test/compile-fail/non-exhaustive-pattern-witness.rs
index 6e1c3db1014..d35e3ad3c55 100644
--- a/src/test/compile-fail/non-exhaustive-pattern-witness.rs
+++ b/src/test/compile-fail/non-exhaustive-pattern-witness.rs
@@ -12,7 +12,7 @@
 
 struct Foo {
     first: bool,
-    second: Option<[uint, ..4]>
+    second: Option<[uint; 4]>
 }
 
 enum Color {
diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs
index d699f69864e..5c0aba42b96 100644
--- a/src/test/compile-fail/packed-struct-generic-transmute.rs
+++ b/src/test/compile-fail/packed-struct-generic-transmute.rs
@@ -33,7 +33,7 @@ struct Oof<T, S> {
 fn main() {
     let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 };
     unsafe {
-        let oof: Oof<[u8, .. 5], i32> = mem::transmute(foo);
+        let oof: Oof<[u8; 5], i32> = mem::transmute(foo);
         println!("{} {}", oof.rab[], oof.zab);
     }
 }
diff --git a/src/test/compile-fail/removed-syntax-fixed-vec.rs b/src/test/compile-fail/removed-syntax-fixed-vec.rs
index fe49d1f4a8d..0a8420c19c3 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 = [int * 3]; //~ ERROR expected one of `(`, `+`, `,`, `::`, or `]`, found `*`
+type v = [int * 3]; //~ ERROR expected one of `(`, `+`, `,`, `::`, `;`, or `]`, found `*`
diff --git a/src/test/compile-fail/removed-syntax-mut-vec-expr.rs b/src/test/compile-fail/removed-syntax-mut-vec-expr.rs
index 437f871f8ea..30302bbd16e 100644
--- a/src/test/compile-fail/removed-syntax-mut-vec-expr.rs
+++ b/src/test/compile-fail/removed-syntax-mut-vec-expr.rs
@@ -11,5 +11,5 @@
 fn f() {
     let v = [mut 1, 2, 3, 4];
     //~^  ERROR expected identifier, found keyword `mut`
-    //~^^ ERROR expected one of `!`, `,`, `.`, `::`, `]`, `{`, or an operator, found `1`
+    //~^^ ERROR expected one of `!`, `,`, `.`, `::`, `;`, `]`, `{`, or an operator, found `1`
 }
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 af469fadf98..9c6056bd72a 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 int];
     //~^  ERROR expected identifier, found keyword `mut`
-    //~^^ ERROR expected one of `(`, `+`, `,`, `::`, or `]`, found `int`
+    //~^^ ERROR expected one of `(`, `+`, `,`, `::`, `;`, or `]`, found `int`
diff --git a/src/test/compile-fail/repeat-to-run-dtor-twice.rs b/src/test/compile-fail/repeat-to-run-dtor-twice.rs
index 8fdf586b3d1..d3126cf44d1 100644
--- a/src/test/compile-fail/repeat-to-run-dtor-twice.rs
+++ b/src/test/compile-fail/repeat-to-run-dtor-twice.rs
@@ -24,6 +24,6 @@ impl Drop for Foo {
 
 fn main() {
     let a = Foo { x: 3 };
-    let _ = [ a, ..5 ];
+    let _ = [ a; 5 ];
     //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `Foo`
 }
diff --git a/src/test/compile-fail/repeat_count.rs b/src/test/compile-fail/repeat_count.rs
index 38fbb426fb1..3b0ef0c293a 100644
--- a/src/test/compile-fail/repeat_count.rs
+++ b/src/test/compile-fail/repeat_count.rs
@@ -12,18 +12,18 @@
 
 fn main() {
     let n = 1;
-    let a = [0, ..n]; //~ ERROR expected constant integer for repeat count, found variable
-    let b = [0, ..()];
+    let a = [0; n]; //~ ERROR expected constant integer for repeat count, found variable
+    let b = [0; ()];
 //~^ ERROR expected constant integer for repeat count, found non-constant expression
 //~^^ ERROR: expected `uint`, found `()`
-    let c = [0, ..true]; //~ ERROR expected positive integer for repeat count, found boolean
+    let c = [0; true]; //~ ERROR expected positive integer for repeat count, found boolean
     //~^ ERROR: expected `uint`, found `bool`
-    let d = [0, ..0.5]; //~ ERROR expected positive integer for repeat count, found float
+    let d = [0; 0.5]; //~ ERROR expected positive integer for repeat count, found float
     //~^ ERROR: expected `uint`, found `_`
-    let e = [0, .."foo"]; //~ ERROR expected positive integer for repeat count, found string
+    let e = [0; "foo"]; //~ ERROR expected positive integer for repeat count, found string
     //~^ ERROR: expected `uint`, found `&'static str`
-    let f = [0, ..-4];
+    let f = [0; -4];
     //~^ ERROR expected positive integer for repeat count, found negative integer
-    let f = [0u, ..-1];
+    let f = [0u; -1];
     //~^ ERROR expected positive integer for repeat count, found negative integer
 }
diff --git a/src/test/compile-fail/static-vec-repeat-not-constant.rs b/src/test/compile-fail/static-vec-repeat-not-constant.rs
index 03be2cc8f0f..ff84ed5bf0c 100644
--- a/src/test/compile-fail/static-vec-repeat-not-constant.rs
+++ b/src/test/compile-fail/static-vec-repeat-not-constant.rs
@@ -10,7 +10,7 @@
 
 fn foo() -> int { 23 }
 
-static a: [int, ..2] = [foo(), ..2];
+static a: [int; 2] = [foo(); 2];
 //~^ ERROR: function calls in constants are limited to struct and enum constructors
 
 fn main() {}
diff --git a/src/test/compile-fail/trailing-comma-array-repeat.rs b/src/test/compile-fail/trailing-comma-array-repeat.rs
deleted file mode 100644
index dadd6571583..00000000000
--- a/src/test/compile-fail/trailing-comma-array-repeat.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
-    let [_, ..,] = [(), ()]; //~ ERROR unexpected token: `]`
-}
diff --git a/src/test/compile-fail/transmute-type-parameters.rs b/src/test/compile-fail/transmute-type-parameters.rs
index 53391a0e894..2286c0e75bd 100644
--- a/src/test/compile-fail/transmute-type-parameters.rs
+++ b/src/test/compile-fail/transmute-type-parameters.rs
@@ -20,7 +20,7 @@ unsafe fn g<T>(x: (T, int)) {
     let _: int = transmute(x);  //~ ERROR cannot transmute
 }
 
-unsafe fn h<T>(x: [T, ..10]) {
+unsafe fn h<T>(x: [T; 10]) {
     let _: int = transmute(x);  //~ ERROR cannot transmute
 }
 
diff --git a/src/test/compile-fail/vector-cast-weirdness.rs b/src/test/compile-fail/vector-cast-weirdness.rs
index e096e5eb436..c5109ce473e 100644
--- a/src/test/compile-fail/vector-cast-weirdness.rs
+++ b/src/test/compile-fail/vector-cast-weirdness.rs
@@ -12,20 +12,20 @@
 // presence of the `_` type shorthand notation.
 
 struct X {
-    y: [u8, ..2],
+    y: [u8; 2],
 }
 
 fn main() {
     let x1 = X { y: [0, 0] };
 
     let p1: *const u8 = &x1.y as *const _;  //~ ERROR mismatched types
-    let t1: *const [u8, ..2] = &x1.y as *const _;
-    let h1: *const [u8, ..2] = &x1.y as *const [u8, ..2];
+    let t1: *const [u8; 2] = &x1.y as *const _;
+    let h1: *const [u8; 2] = &x1.y as *const [u8; 2];
 
     let mut x1 = X { y: [0, 0] };
 
     let p1: *mut u8 = &mut x1.y as *mut _;  //~ ERROR mismatched types
-    let t1: *mut [u8, ..2] = &mut x1.y as *mut _;
-    let h1: *mut [u8, ..2] = &mut x1.y as *mut [u8, ..2];
+    let t1: *mut [u8; 2] = &mut x1.y as *mut _;
+    let h1: *mut [u8; 2] = &mut x1.y as *mut [u8; 2];
 }
 
diff --git a/src/test/debuginfo/evec-in-struct.rs b/src/test/debuginfo/evec-in-struct.rs
index aab9c446a9e..786868f6b89 100644
--- a/src/test/debuginfo/evec-in-struct.rs
+++ b/src/test/debuginfo/evec-in-struct.rs
@@ -53,28 +53,28 @@
 #![allow(unused_variables)]
 
 struct NoPadding1 {
-    x: [u32, ..3],
+    x: [u32; 3],
     y: i32,
-    z: [f32, ..2]
+    z: [f32; 2]
 }
 
 struct NoPadding2 {
-    x: [u32, ..3],
-    y: [[u32, ..2], ..2]
+    x: [u32; 3],
+    y: [[u32; 2]; 2]
 }
 
 struct StructInternalPadding {
-    x: [i16, ..2],
-    y: [i64, ..2]
+    x: [i16; 2],
+    y: [i64; 2]
 }
 
 struct SingleVec {
-    x: [i16, ..5]
+    x: [i16; 5]
 }
 
 struct StructPaddedAtEnd {
-    x: [i64, ..2],
-    y: [i16, ..2]
+    x: [i64; 2],
+    y: [i16; 2]
 }
 
 fn main() {
diff --git a/src/test/debuginfo/lexical-scopes-in-block-expression.rs b/src/test/debuginfo/lexical-scopes-in-block-expression.rs
index a1f34aea0f2..41dee642fea 100644
--- a/src/test/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/src/test/debuginfo/lexical-scopes-in-block-expression.rs
@@ -450,7 +450,7 @@ fn main() {
         sentinel();
 
         val
-    }, ..10];
+    }; 10];
 
     zzz(); // #break
     sentinel();
@@ -491,7 +491,7 @@ fn main() {
     sentinel();
 
     // index expression
-    let a_vector = [10i, ..20];
+    let a_vector = [10i; 20];
     let _ = a_vector[{
         zzz(); // #break
         sentinel();
diff --git a/src/test/debuginfo/recursive-struct.rs b/src/test/debuginfo/recursive-struct.rs
index 032b8b1fa26..8cc0fdabfc2 100644
--- a/src/test/debuginfo/recursive-struct.rs
+++ b/src/test/debuginfo/recursive-struct.rs
@@ -143,7 +143,7 @@ fn main() {
         value: 2,
     };
 
-    let vec_unique: [UniqueNode<f32>, ..1] = [UniqueNode {
+    let vec_unique: [UniqueNode<f32>; 1] = [UniqueNode {
         next: Val {
             val: box UniqueNode {
                 next: Empty,
diff --git a/src/test/debuginfo/type-names.rs b/src/test/debuginfo/type-names.rs
index d72b080409e..286c44667c5 100644
--- a/src/test/debuginfo/type-names.rs
+++ b/src/test/debuginfo/type-names.rs
@@ -99,10 +99,10 @@
 
 // VECTORS
 // gdb-command:whatis fixed_size_vec1
-// gdb-check:type = struct ([type-names::Struct1, ..3], i16)
+// gdb-check:type = struct ([type-names::Struct1; 3], i16)
 
 // gdb-command:whatis fixed_size_vec2
-// gdb-check:type = struct ([uint, ..3], i16)
+// gdb-check:type = struct ([uint; 3], i16)
 
 // gdb-command:whatis slice1
 // gdb-check:type = struct &[uint]
diff --git a/src/test/debuginfo/vec.rs b/src/test/debuginfo/vec.rs
index fd422a90e63..00c93653cf4 100644
--- a/src/test/debuginfo/vec.rs
+++ b/src/test/debuginfo/vec.rs
@@ -30,7 +30,7 @@
 
 #![allow(unused_variables)]
 
-static mut VECT: [i32, ..3] = [1, 2, 3];
+static mut VECT: [i32; 3] = [1, 2, 3];
 
 fn main() {
     let a = [1i, 2, 3];
diff --git a/src/test/pretty/blank-lines.rs b/src/test/pretty/blank-lines.rs
index 24eb5337d25..1774edd3f76 100644
--- a/src/test/pretty/blank-lines.rs
+++ b/src/test/pretty/blank-lines.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // pp-exact
-fn f() -> [int, ..3] {
+fn f() -> [int; 3] {
     let picard = 0;
 
     let data = 1;
diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index b5ea9bd4b89..974af1e6f3e 100644
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -21,26 +21,26 @@ use std::prelude::*;
 
 // #4264 fixed-length vector types
 
-pub fn foo(_: [int, ..(3 as uint)]) { }
+pub fn foo(_: [int; (3 as uint)]) { }
 
 pub fn bar() {
     const FOO: uint = ((5u as uint) - (4u as uint) as uint);
-    let _: [(), ..(FOO as uint)] = ([(() as ())] as [(), ..1]);
+    let _: [(); (FOO as uint)] = ([(() as ())] as [(); 1]);
 
-    let _: [(), ..(1u as uint)] = ([(() as ())] as [(), ..1]);
+    let _: [(); (1u as uint)] = ([(() as ())] as [(); 1]);
 
     let _ =
-        (((&((([(1i as int), (2 as int), (3 as int)] as [int, ..3])) as
-                [int, ..3]) as &[int, ..3]) as *const _ as *const [int, ..3])
-            as *const [int, ..(3u as uint)] as *const [int, ..3]);
+        (((&((([(1i as int), (2 as int), (3 as int)] as [int; 3])) as
+                [int; 3]) as &[int; 3]) as *const _ as *const [int; 3]) as
+            *const [int; (3u as uint)] as *const [int; 3]);
 
     (match (() as ()) {
          () => {
              #[inline]
              #[allow(dead_code)]
              static __STATIC_FMTSTR: &'static [&'static str] =
-                 (&([("test" as &'static str)] as [&'static str, ..1]) as
-                     &'static [&'static str, ..1]);
+                 (&([("test" as &'static str)] as [&'static str; 1]) as
+                     &'static [&'static str; 1]);
 
 
 
@@ -57,9 +57,9 @@ pub fn bar() {
                                                                                                                                                                 &'static [&'static str]),
                                                                                                                                                             (&([]
                                                                                                                                                                   as
-                                                                                                                                                                  [core::fmt::Argument<'_>, ..0])
+                                                                                                                                                                  [core::fmt::Argument<'_>; 0])
                                                                                                                                                                 as
-                                                                                                                                                                &[core::fmt::Argument<'_>, ..0]))
+                                                                                                                                                                &[core::fmt::Argument<'_>; 0]))
                                                                                       as
                                                                                       core::fmt::Arguments<'_>)
                                                                                     as
@@ -68,18 +68,17 @@ pub fn bar() {
          }
      } as collections::string::String);
 }
-pub type Foo = [int, ..(3u as uint)];
+pub type Foo = [int; (3u as uint)];
 pub struct Bar {
-    pub x: [int, ..(3u as uint)],
+    pub x: [int; (3u as uint)],
 }
-pub struct TupleBar([int, ..(4u as uint)]);
-pub enum Baz { BazVariant([int, ..(5u as uint)]), }
+pub struct TupleBar([int; (4u as uint)]);
+pub enum Baz { BazVariant([int; (5u as uint)]), }
 pub fn id<T>(x: T) -> T { (x as T) }
 pub fn use_id() {
     let _ =
-        ((id::<[int, ..(3u as uint)]> as
-             fn([int, ..3]) -> [int, ..3])(([(1 as int), (2 as int),
-                                             (3 as int)] as [int, ..3])) as
-            [int, ..3]);
+        ((id::<[int; (3u as uint)]> as
+             fn([int; 3]) -> [int; 3])(([(1 as int), (2 as int), (3 as int)]
+                                           as [int; 3])) as [int; 3]);
 }
 fn main() { }
diff --git a/src/test/run-make/no-stack-check/attr.rs b/src/test/run-make/no-stack-check/attr.rs
index ef2db932b41..7d0fc2d7fe5 100644
--- a/src/test/run-make/no-stack-check/attr.rs
+++ b/src/test/run-make/no-stack-check/attr.rs
@@ -20,6 +20,6 @@ extern {
 #[no_stack_check]
 pub unsafe fn foo() {
     // Make sure we use the stack
-    let x: [u8, ..50] = [0, ..50];
+    let x: [u8; 50] = [0; 50];
     black_box(x.as_ptr());
 }
diff --git a/src/test/run-make/no-stack-check/flag.rs b/src/test/run-make/no-stack-check/flag.rs
index ee0364001e1..2b6e7240d6f 100644
--- a/src/test/run-make/no-stack-check/flag.rs
+++ b/src/test/run-make/no-stack-check/flag.rs
@@ -19,6 +19,6 @@ extern {
 
 pub unsafe fn foo() {
     // Make sure we use the stack
-    let x: [u8, ..50] = [0, ..50];
+    let x: [u8; 50] = [0; 50];
     black_box(x.as_ptr());
 }
diff --git a/src/test/run-make/target-specs/foo.rs b/src/test/run-make/target-specs/foo.rs
index cab98204b17..fd112034f40 100644
--- a/src/test/run-make/target-specs/foo.rs
+++ b/src/test/run-make/target-specs/foo.rs
@@ -21,7 +21,7 @@ trait Sized { }
 fn start(_main: *const u8, _argc: int, _argv: *const *const u8) -> int { 0 }
 
 extern {
-    fn _foo() -> [u8, ..16];
+    fn _foo() -> [u8; 16];
 }
 
 fn _main() {
diff --git a/src/test/run-pass/cast-in-array-size.rs b/src/test/run-pass/cast-in-array-size.rs
index aaffb013ad8..717ca3ff9fe 100644
--- a/src/test/run-pass/cast-in-array-size.rs
+++ b/src/test/run-pass/cast-in-array-size.rs
@@ -13,8 +13,8 @@
 const SIZE: int = 25;
 
 fn main() {
-    let _a: [bool, ..1 as uint];
-    let _b: [int, ..SIZE as uint] = [1, ..SIZE as uint];
-    let _c: [bool, ..'\n' as uint] = [true, ..'\n' as uint];
-    let _d: [bool, ..true as uint] = [true, ..true as uint];
+    let _a: [bool; 1 as uint];
+    let _b: [int; SIZE as uint] = [1; SIZE as uint];
+    let _c: [bool; '\n' as uint] = [true; '\n' as uint];
+    let _d: [bool; true as uint] = [true; true as uint];
 }
diff --git a/src/test/run-pass/check-static-slice.rs b/src/test/run-pass/check-static-slice.rs
index 60daedec4c7..6e2cfedf9ec 100644
--- a/src/test/run-pass/check-static-slice.rs
+++ b/src/test/run-pass/check-static-slice.rs
@@ -11,11 +11,11 @@
 // Check that the various ways of getting to a reference to a vec (both sized
 // and unsized) work properly.
 
-const aa: [int, ..3] = [1, 2, 3];
-const ab: &'static [int, ..3] = &aa;
+const aa: [int; 3] = [1, 2, 3];
+const ab: &'static [int; 3] = &aa;
 const ac: &'static [int] = ab;
 const ad: &'static [int] = &aa;
-const ae: &'static [int, ..3] = &[1, 2, 3];
+const ae: &'static [int; 3] = &[1, 2, 3];
 const af: &'static [int] = &[1, 2, 3];
 
 static ca: int = aa[0];
diff --git a/src/test/run-pass/const-autoderef.rs b/src/test/run-pass/const-autoderef.rs
index e80ed7c984b..71312fb3878 100644
--- a/src/test/run-pass/const-autoderef.rs
+++ b/src/test/run-pass/const-autoderef.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static A: [u8, ..1] = ['h' as u8];
+static A: [u8; 1] = ['h' as u8];
 static B: u8 = (&A)[0];
-static C: &'static &'static &'static &'static [u8, ..1] = & & & &A;
+static C: &'static &'static &'static &'static [u8; 1] = & & & &A;
 static D: u8 = (&C)[0];
 
 pub fn main() {
diff --git a/src/test/run-pass/const-enum-vec-index.rs b/src/test/run-pass/const-enum-vec-index.rs
index fef6c8624cf..4c8124d28a2 100644
--- a/src/test/run-pass/const-enum-vec-index.rs
+++ b/src/test/run-pass/const-enum-vec-index.rs
@@ -12,7 +12,7 @@ enum E { V1(int), V0 }
 const C: &'static [E] = &[E::V0, E::V1(0xDEADBEE)];
 static C0: E = C[0];
 static C1: E = C[1];
-const D: &'static [E, ..2] = &[E::V0, E::V1(0xDEADBEE)];
+const D: &'static [E; 2] = &[E::V0, E::V1(0xDEADBEE)];
 static D0: E = C[0];
 static D1: E = C[1];
 
diff --git a/src/test/run-pass/const-enum-vector.rs b/src/test/run-pass/const-enum-vector.rs
index 83687f8775b..6eb5c2dab38 100644
--- a/src/test/run-pass/const-enum-vector.rs
+++ b/src/test/run-pass/const-enum-vector.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 enum E { V1(int), V0 }
-static C: [E, ..3] = [E::V0, E::V1(0xDEADBEE), E::V0];
+static C: [E; 3] = [E::V0, E::V1(0xDEADBEE), E::V0];
 
 pub fn main() {
     match C[1] {
diff --git a/src/test/run-pass/const-expr-in-fixed-length-vec.rs b/src/test/run-pass/const-expr-in-fixed-length-vec.rs
index 317a54e927f..6317c2eec18 100644
--- a/src/test/run-pass/const-expr-in-fixed-length-vec.rs
+++ b/src/test/run-pass/const-expr-in-fixed-length-vec.rs
@@ -14,6 +14,6 @@
 pub fn main() {
 
     const FOO: uint = 2;
-    let _v: [int, ..FOO*3];
+    let _v: [int; FOO*3];
 
 }
diff --git a/src/test/run-pass/const-expr-in-vec-repeat.rs b/src/test/run-pass/const-expr-in-vec-repeat.rs
index 54386b33dd9..d692f3a87e4 100644
--- a/src/test/run-pass/const-expr-in-vec-repeat.rs
+++ b/src/test/run-pass/const-expr-in-vec-repeat.rs
@@ -13,6 +13,6 @@
 pub fn main() {
 
     const FOO: uint = 2;
-    let _v = [0i, ..FOO*3*2/2];
+    let _v = [0i; FOO*3*2/2];
 
 }
diff --git a/src/test/run-pass/const-fields-and-indexing.rs b/src/test/run-pass/const-fields-and-indexing.rs
index 49b244a162b..0819e0becbf 100644
--- a/src/test/run-pass/const-fields-and-indexing.rs
+++ b/src/test/run-pass/const-fields-and-indexing.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-const x : [int, ..4] = [1,2,3,4];
+const x : [int; 4] = [1,2,3,4];
 static p : int = x[2];
 const y : &'static [int] = &[1,2,3,4];
 static q : int = y[2];
diff --git a/src/test/run-pass/const-region-ptrs-noncopy.rs b/src/test/run-pass/const-region-ptrs-noncopy.rs
index 5e417efb4b5..e8081005d4a 100644
--- a/src/test/run-pass/const-region-ptrs-noncopy.rs
+++ b/src/test/run-pass/const-region-ptrs-noncopy.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type Big = [u64, ..8];
+type Big = [u64; 8];
 struct Pair<'a> { a: int, b: &'a Big }
 const x: &'static Big = &([13, 14, 10, 13, 11, 14, 14, 15]);
 const y: &'static Pair<'static> = &Pair {a: 15, b: x};
diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs
index 47d59eca263..d6f0296619a 100644
--- a/src/test/run-pass/const-str-ptr.rs
+++ b/src/test/run-pass/const-str-ptr.rs
@@ -10,8 +10,8 @@
 
 use std::{str, string};
 
-const A: [u8, ..2] = ['h' as u8, 'i' as u8];
-const B: &'static [u8, ..2] = &A;
+const A: [u8; 2] = ['h' as u8, 'i' as u8];
+const B: &'static [u8; 2] = &A;
 const C: *const u8 = B as *const u8;
 
 pub fn main() {
diff --git a/src/test/run-pass/const-vecs-and-slices.rs b/src/test/run-pass/const-vecs-and-slices.rs
index 1a2a3e36e87..26874b9f9d5 100644
--- a/src/test/run-pass/const-vecs-and-slices.rs
+++ b/src/test/run-pass/const-vecs-and-slices.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static x : [int, ..4] = [1,2,3,4];
+static x : [int; 4] = [1,2,3,4];
 static y : &'static [int] = &[1,2,3,4];
-static z : &'static [int, ..4] = &[1,2,3,4];
+static z : &'static [int; 4] = &[1,2,3,4];
 static zz : &'static [int] = &[1,2,3,4];
 
 pub fn main() {
diff --git a/src/test/run-pass/dst-struct.rs b/src/test/run-pass/dst-struct.rs
index bf5b300f7cf..3644ca81d56 100644
--- a/src/test/run-pass/dst-struct.rs
+++ b/src/test/run-pass/dst-struct.rs
@@ -120,7 +120,7 @@ pub fn main() {
     assert!((*f2)[1] == 2);
 
     // Nested Box.
-    let f1 : Box<Fat<[int, ..3]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+    let f1 : Box<Fat<[int; 3]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
     foo(&*f1);
     let f2 : Box<Fat<[int]>> = f1;
     foo(&*f2);
diff --git a/src/test/run-pass/enum-vec-initializer.rs b/src/test/run-pass/enum-vec-initializer.rs
index 0256420ac4c..d436916c279 100644
--- a/src/test/run-pass/enum-vec-initializer.rs
+++ b/src/test/run-pass/enum-vec-initializer.rs
@@ -16,9 +16,9 @@ const BAR:uint = Flopsy::Bunny as uint;
 const BAR2:uint = BAR;
 
 pub fn main() {
-    let _v = [0i, .. Flopsy::Bunny as uint];
-    let _v = [0i, .. BAR];
-    let _v = [0i, .. BAR2];
+    let _v = [0i;  Flopsy::Bunny as uint];
+    let _v = [0i;  BAR];
+    let _v = [0i;  BAR2];
     const BAR3:uint = BAR2;
-    let _v = [0i, .. BAR3];
+    let _v = [0i;  BAR3];
 }
diff --git a/src/test/run-pass/evec-internal.rs b/src/test/run-pass/evec-internal.rs
index 36b5f86aeda..28b5f781b5c 100644
--- a/src/test/run-pass/evec-internal.rs
+++ b/src/test/run-pass/evec-internal.rs
@@ -13,16 +13,16 @@
 // Doesn't work; needs a design decision.
 
 pub fn main() {
-    let x : [int, ..5] = [1,2,3,4,5];
-    let _y : [int, ..5] = [1,2,3,4,5];
+    let x : [int; 5] = [1,2,3,4,5];
+    let _y : [int; 5] = [1,2,3,4,5];
     let mut z = [1,2,3,4,5];
     z = x;
     assert_eq!(z[0], 1);
     assert_eq!(z[4], 5);
 
-    let a : [int, ..5] = [1,1,1,1,1];
-    let b : [int, ..5] = [2,2,2,2,2];
-    let c : [int, ..5] = [2,2,2,2,3];
+    let a : [int; 5] = [1,1,1,1,1];
+    let b : [int; 5] = [2,2,2,2,2];
+    let c : [int; 5] = [2,2,2,2,3];
 
     log(debug, a);
 
diff --git a/src/test/run-pass/huge-largest-array.rs b/src/test/run-pass/huge-largest-array.rs
index d494e0bf40d..e24731546ed 100644
--- a/src/test/run-pass/huge-largest-array.rs
+++ b/src/test/run-pass/huge-largest-array.rs
@@ -12,10 +12,10 @@ use std::mem::size_of;
 
 #[cfg(target_word_size = "32")]
 pub fn main() {
-    assert_eq!(size_of::<[u8, ..(1 << 31) - 1]>(), (1 << 31) - 1);
+    assert_eq!(size_of::<[u8; (1 << 31) - 1]>(), (1 << 31) - 1);
 }
 
 #[cfg(target_word_size = "64")]
 pub fn main() {
-    assert_eq!(size_of::<[u8, ..(1 << 47) - 1]>(), (1 << 47) - 1);
+    assert_eq!(size_of::<[u8; (1 << 47) - 1]>(), (1 << 47) - 1);
 }
diff --git a/src/test/run-pass/issue-11205.rs b/src/test/run-pass/issue-11205.rs
index ea138311f19..549a70f19e3 100644
--- a/src/test/run-pass/issue-11205.rs
+++ b/src/test/run-pass/issue-11205.rs
@@ -12,22 +12,22 @@
 
 trait Foo {}
 impl Foo for int {}
-fn foo(_: [&Foo, ..2]) {}
+fn foo(_: [&Foo; 2]) {}
 fn foos(_: &[&Foo]) {}
 fn foog<T>(_: &[T], _: &[T]) {}
 
-fn bar(_: [Box<Foo>, ..2]) {}
+fn bar(_: [Box<Foo>; 2]) {}
 fn bars(_: &[Box<Foo>]) {}
 
 fn main() {
-    let x: [&Foo, ..2] = [&1i, &2i];
+    let x: [&Foo; 2] = [&1i, &2i];
     foo(x);
     foo([&1i, &2i]);
 
     let r = &1i;
-    let x: [&Foo, ..2] = [r, ..2];
+    let x: [&Foo; 2] = [r; 2];
     foo(x);
-    foo([&1i, ..2]);
+    foo([&1i; 2]);
 
     let x: &[&Foo] = &[&1i, &2i];
     foos(x);
@@ -37,7 +37,7 @@ fn main() {
     let r = &1i;
     foog(x, &[r]);
 
-    let x: [Box<Foo>, ..2] = [box 1i, box 2i];
+    let x: [Box<Foo>; 2] = [box 1i, box 2i];
     bar(x);
     bar([box 1i, box 2i]);
 
@@ -49,16 +49,16 @@ fn main() {
     foog(x, &[box 1i]);
 
     struct T<'a> {
-        t: [&'a (Foo+'a), ..2]
+        t: [&'a (Foo+'a); 2]
     }
     let _n = T {
         t: [&1i, &2i]
     };
     let r = &1i;
     let _n = T {
-        t: [r, ..2]
+        t: [r; 2]
     };
-    let x: [&Foo, ..2] = [&1i, &2i];
+    let x: [&Foo; 2] = [&1i, &2i];
     let _n = T {
         t: x
     };
@@ -70,11 +70,11 @@ fn main() {
         t: &[&1i, &2i]
     };
     let r = &1i;
-    let r: [&Foo, ..2] = [r, ..2];
+    let r: [&Foo; 2] = [r; 2];
     let _n = F {
         t: &r
     };
-    let x: [&Foo, ..2] = [&1i, &2i];
+    let x: [&Foo; 2] = [&1i, &2i];
     let _n = F {
         t: &x
     };
@@ -85,7 +85,7 @@ fn main() {
     let _n = M {
         t: &[box 1i, box 2i]
     };
-    let x: [Box<Foo>, ..2] = [box 1i, box 2i];
+    let x: [Box<Foo>; 2] = [box 1i, box 2i];
     let _n = M {
         t: &x
     };
diff --git a/src/test/run-pass/issue-13259-windows-tcb-trash.rs b/src/test/run-pass/issue-13259-windows-tcb-trash.rs
index 0e42bdbd6ad..329ab7c921d 100644
--- a/src/test/run-pass/issue-13259-windows-tcb-trash.rs
+++ b/src/test/run-pass/issue-13259-windows-tcb-trash.rs
@@ -27,7 +27,7 @@ mod imp {
     }
 
     pub fn test() {
-        let mut buf: [u16, ..50] = [0, ..50];
+        let mut buf: [u16; 50] = [0; 50];
         let ret = unsafe {
             FormatMessageW(0x1000, 0 as *mut c_void, 1, 0x400,
                            buf.as_mut_ptr(), buf.len() as u32, 0 as *const c_void)
diff --git a/src/test/run-pass/issue-13763.rs b/src/test/run-pass/issue-13763.rs
index 8b2b732415e..81b6892b0f9 100644
--- a/src/test/run-pass/issue-13763.rs
+++ b/src/test/run-pass/issue-13763.rs
@@ -12,9 +12,9 @@ use std::u8;
 
 const NUM: uint = u8::BITS as uint;
 
-struct MyStruct { nums: [uint, ..8] }
+struct MyStruct { nums: [uint; 8] }
 
 
 fn main() {
-    let _s = MyStruct { nums: [0, ..NUM] };
+    let _s = MyStruct { nums: [0; NUM] };
 }
diff --git a/src/test/run-pass/issue-13837.rs b/src/test/run-pass/issue-13837.rs
index 221115a0869..f62a45277b2 100644
--- a/src/test/run-pass/issue-13837.rs
+++ b/src/test/run-pass/issue-13837.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static TEST_VALUE : *const [int, ..2] = 0x1234 as *const [int, ..2];
+static TEST_VALUE : *const [int; 2] = 0x1234 as *const [int; 2];
 
 fn main() {}
diff --git a/src/test/run-pass/issue-14940.rs b/src/test/run-pass/issue-14940.rs
index cef09af1fcf..d815620c969 100644
--- a/src/test/run-pass/issue-14940.rs
+++ b/src/test/run-pass/issue-14940.rs
@@ -15,7 +15,7 @@ fn main() {
     let args = os::args();
     if args.len() > 1 {
         let mut out = stdio::stdout();
-        out.write(&['a' as u8, ..128 * 1024]).unwrap();
+        out.write(&['a' as u8; 128 * 1024]).unwrap();
     } else {
         let out = Command::new(args[0].as_slice()).arg("child").output();
         let out = out.unwrap();
diff --git a/src/test/run-pass/issue-15673.rs b/src/test/run-pass/issue-15673.rs
index 051d98aa1d8..e66788a2c00 100644
--- a/src/test/run-pass/issue-15673.rs
+++ b/src/test/run-pass/issue-15673.rs
@@ -10,6 +10,6 @@
 
 use std::iter::AdditiveIterator;
 fn main() {
-    let x: [u64, ..3] = [1, 2, 3];
+    let x: [u64; 3] = [1, 2, 3];
     assert_eq!(6, range(0, 3).map(|i| x[i]).sum());
 }
diff --git a/src/test/run-pass/issue-17302.rs b/src/test/run-pass/issue-17302.rs
index 50583c7d127..b2abf2d2b1a 100644
--- a/src/test/run-pass/issue-17302.rs
+++ b/src/test/run-pass/issue-17302.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static mut DROPPED: [bool, ..2] = [false, false];
+static mut DROPPED: [bool; 2] = [false, false];
 
 struct A(uint);
 struct Foo { _a: A, _b: int }
diff --git a/src/test/run-pass/issue-17877.rs b/src/test/run-pass/issue-17877.rs
index 51db2f05959..827e6a10abd 100644
--- a/src/test/run-pass/issue-17877.rs
+++ b/src/test/run-pass/issue-17877.rs
@@ -9,11 +9,11 @@
 // except according to those terms.
 
 fn main() {
-    assert_eq!(match [0u8, ..1024] {
+    assert_eq!(match [0u8; 1024] {
         _ => 42u,
     }, 42u);
 
-    assert_eq!(match [0u8, ..1024] {
+    assert_eq!(match [0u8; 1024] {
         [1, _..] => 0u,
         [0, _..] => 1u,
         _ => 2u
diff --git a/src/test/run-pass/issue-18425.rs b/src/test/run-pass/issue-18425.rs
index 6bb244bf88f..f61530c7418 100644
--- a/src/test/run-pass/issue-18425.rs
+++ b/src/test/run-pass/issue-18425.rs
@@ -12,5 +12,5 @@
 // expression with a count of 1 and a non-Copy element type.
 
 fn main() {
-    let _ = [box 1u, ..1];
+    let _ = [box 1u; 1];
 }
diff --git a/src/test/run-pass/issue-19244.rs b/src/test/run-pass/issue-19244.rs
index d42bda6cd5d..3ee5ce9bff9 100644
--- a/src/test/run-pass/issue-19244.rs
+++ b/src/test/run-pass/issue-19244.rs
@@ -13,8 +13,8 @@ const STRUCT: MyStruct = MyStruct { field: 42 };
 const TUP: (uint,) = (43,);
 
 fn main() {
-    let a = [0i, ..STRUCT.field];
-    let b = [0i, ..TUP.0];
+    let a = [0i; STRUCT.field];
+    let b = [0i; TUP.0];
 
     assert!(a.len() == 42);
     assert!(b.len() == 43);
diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs
index 1dc1587ff2f..f87eb46d553 100644
--- a/src/test/run-pass/issue-2904.rs
+++ b/src/test/run-pass/issue-2904.rs
@@ -63,7 +63,7 @@ fn read_board_grid<rdr:'static + io::Reader>(mut input: rdr)
                    -> Vec<Vec<square>> {
     let mut input: &mut io::Reader = &mut input;
     let mut grid = Vec::new();
-    let mut line = [0, ..10];
+    let mut line = [0; 10];
     input.read(&mut line);
     let mut row = Vec::new();
     for c in line.iter() {
diff --git a/src/test/run-pass/issue-3656.rs b/src/test/run-pass/issue-3656.rs
index 53157ce7546..8a39676ca17 100644
--- a/src/test/run-pass/issue-3656.rs
+++ b/src/test/run-pass/issue-3656.rs
@@ -16,7 +16,7 @@ extern crate libc;
 use libc::{c_uint, uint32_t, c_void};
 
 pub struct KEYGEN {
-    hash_algorithm: [c_uint, ..2],
+    hash_algorithm: [c_uint; 2],
     count: uint32_t,
     salt: *const c_void,
     salt_size: uint32_t,
diff --git a/src/test/run-pass/issue-4387.rs b/src/test/run-pass/issue-4387.rs
index 447bf3b4b26..43948ef4a45 100644
--- a/src/test/run-pass/issue-4387.rs
+++ b/src/test/run-pass/issue-4387.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    let _foo = [0i, ..2*4];
+    let _foo = [0i; 2*4];
 }
diff --git a/src/test/run-pass/issue-5688.rs b/src/test/run-pass/issue-5688.rs
index 0a13e001fab..7c8940aafbf 100644
--- a/src/test/run-pass/issue-5688.rs
+++ b/src/test/run-pass/issue-5688.rs
@@ -13,7 +13,7 @@
 
 ...should print &[1, 2, 3] but instead prints something like
 &[4492532864, 24]. It is pretty evident that the compiler messed up
-with the representation of [int, ..n] and [int] somehow, or at least
+with the representation of [int; n] and [int] somehow, or at least
 failed to typecheck correctly.
 */
 
diff --git a/src/test/run-pass/issue-7784.rs b/src/test/run-pass/issue-7784.rs
index 666847517ef..b936eb322fc 100644
--- a/src/test/run-pass/issue-7784.rs
+++ b/src/test/run-pass/issue-7784.rs
@@ -10,10 +10,10 @@
 
 #![feature(advanced_slice_patterns)]
 
-fn foo<T: Add<T, T> + Clone>([x, y, z]: [T, ..3]) -> (T, T, T) {
+fn foo<T: Add<T, T> + Clone>([x, y, z]: [T; 3]) -> (T, T, T) {
     (x.clone(), x.clone() + y.clone(), x + y + z)
 }
-fn bar(a: &'static str, b: &'static str) -> [&'static str, ..4] {
+fn bar(a: &'static str, b: &'static str) -> [&'static str; 4] {
     [a, b, b, a]
 }
 
diff --git a/src/test/run-pass/issue-9942.rs b/src/test/run-pass/issue-9942.rs
index b9410ffdb43..321e22cd19c 100644
--- a/src/test/run-pass/issue-9942.rs
+++ b/src/test/run-pass/issue-9942.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    const S: uint = 23 as uint; [0i, ..S]; ()
+    const S: uint = 23 as uint; [0i; S]; ()
 }
diff --git a/src/test/run-pass/macro-invocation-in-count-expr-fixed-array-type.rs b/src/test/run-pass/macro-invocation-in-count-expr-fixed-array-type.rs
index 4c124d85eee..ecd7c0458f7 100644
--- a/src/test/run-pass/macro-invocation-in-count-expr-fixed-array-type.rs
+++ b/src/test/run-pass/macro-invocation-in-count-expr-fixed-array-type.rs
@@ -15,5 +15,5 @@ macro_rules! four (
 );
 
 fn main() {
-    let _x: [u16, ..four!()];
+    let _x: [u16; four!()];
 }
diff --git a/src/test/run-pass/match-arm-statics.rs b/src/test/run-pass/match-arm-statics.rs
index 400aab64b4c..db512adc011 100644
--- a/src/test/run-pass/match-arm-statics.rs
+++ b/src/test/run-pass/match-arm-statics.rs
@@ -64,7 +64,7 @@ fn issue_6533() {
 }
 
 fn issue_13626() {
-    const VAL: [u8, ..1] = [0];
+    const VAL: [u8; 1] = [0];
     match [1] {
         VAL => unreachable!(),
         _ => ()
diff --git a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
index 00319d57f8d..9ae7f49c75a 100644
--- a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
+++ b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs
@@ -38,7 +38,7 @@ impl<'a> MyWriter for &'a mut [u8] {
 }
 
 fn main() {
-    let mut buf = [0_u8, .. 6];
+    let mut buf = [0_u8; 6];
 
     {
         let mut writer = buf.as_mut_slice();
diff --git a/src/test/run-pass/method-two-traits-distinguished-via-where-clause.rs b/src/test/run-pass/method-two-traits-distinguished-via-where-clause.rs
index 986236fb6f9..fbecb6851b6 100644
--- a/src/test/run-pass/method-two-traits-distinguished-via-where-clause.rs
+++ b/src/test/run-pass/method-two-traits-distinguished-via-where-clause.rs
@@ -28,7 +28,7 @@ impl<T> B for *const [T] {
 }
 
 fn main() {
-    let x: [int, ..4] = [1,2,3,4];
+    let x: [int; 4] = [1,2,3,4];
     let xptr = x.as_slice() as *const _;
     xptr.foo();
 }
diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
index ef0bc75c326..bf926a6c48a 100644
--- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
+++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
@@ -9,13 +9,13 @@
 // except according to those terms.
 
 fn test1() {
-    let mut ints = [0i, ..32];
+    let mut ints = [0i; 32];
     ints[0] += 1;
     assert_eq!(ints[0], 1);
 }
 
 fn test2() {
-    let mut ints = [0i, ..32];
+    let mut ints = [0i; 32];
     for i in ints.iter_mut() { *i += 22; }
     for i in ints.iter() { assert!(*i == 22); }
 }
diff --git a/src/test/run-pass/new-style-fixed-length-vec.rs b/src/test/run-pass/new-style-fixed-length-vec.rs
index a689fb0cf7c..e06461daed0 100644
--- a/src/test/run-pass/new-style-fixed-length-vec.rs
+++ b/src/test/run-pass/new-style-fixed-length-vec.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static FOO: [int, ..3] = [1, 2, 3];
+static FOO: [int; 3] = [1, 2, 3];
 
 pub fn main() {
     println!("{} {} {}", FOO[0], FOO[1], FOO[2]);
diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index da1ad094df6..2660de619e9 100644
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -20,7 +20,7 @@ use std::{option, mem};
 // trying to get assert failure messages that at least identify which case
 // failed.
 
-enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8, ..0]) }
+enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8; 0]) }
 impl<T> E<T> {
     fn is_none(&self) -> bool {
         match *self {
@@ -54,7 +54,7 @@ macro_rules! check_fancy {
         check_fancy!($e: $T, |ptr| assert!(*ptr == $e));
     }};
     ($e:expr: $T:ty, |$v:ident| $chk:expr) => {{
-        assert!(E::Nothing::<$T>((), ((), ()), [23i8, ..0]).is_none());
+        assert!(E::Nothing::<$T>((), ((), ()), [23i8; 0]).is_none());
         let e = $e;
         let t_ = E::Thing::<$T>(23, e);
         match t_.get_ref() {
diff --git a/src/test/run-pass/nullable-pointer-size.rs b/src/test/run-pass/nullable-pointer-size.rs
index 5708310abad..afc22be38b8 100644
--- a/src/test/run-pass/nullable-pointer-size.rs
+++ b/src/test/run-pass/nullable-pointer-size.rs
@@ -12,7 +12,7 @@
 
 use std::mem;
 
-enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8, ..0]) }
+enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8; 0]) }
 struct S<T>(int, T);
 
 // These are macros so we get useful assert messages.
diff --git a/src/test/run-pass/order-drop-with-match.rs b/src/test/run-pass/order-drop-with-match.rs
index 9a76beac9e5..a866be43a05 100644
--- a/src/test/run-pass/order-drop-with-match.rs
+++ b/src/test/run-pass/order-drop-with-match.rs
@@ -14,7 +14,7 @@
 // in ORDER matching up to when it ran.
 // Correct order is: matched, inner, outer
 
-static mut ORDER: [uint, ..3] = [0, 0, 0];
+static mut ORDER: [uint; 3] = [0, 0, 0];
 static mut INDEX: uint = 0;
 
 struct A;
diff --git a/src/test/run-pass/out-of-stack-new-thread-no-split.rs b/src/test/run-pass/out-of-stack-new-thread-no-split.rs
index 419d9b5d824..674d0dc86da 100644
--- a/src/test/run-pass/out-of-stack-new-thread-no-split.rs
+++ b/src/test/run-pass/out-of-stack-new-thread-no-split.rs
@@ -27,7 +27,7 @@ pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } }
 
 #[no_stack_check]
 fn recurse() {
-    let buf = [0i, ..10];
+    let buf = [0i; 10];
     black_box(buf);
     recurse();
 }
diff --git a/src/test/run-pass/out-of-stack-no-split.rs b/src/test/run-pass/out-of-stack-no-split.rs
index ecb93cc6f8c..79926776abf 100644
--- a/src/test/run-pass/out-of-stack-no-split.rs
+++ b/src/test/run-pass/out-of-stack-no-split.rs
@@ -28,7 +28,7 @@ pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } }
 
 #[no_stack_check]
 fn recurse() {
-    let buf = [0i, ..10];
+    let buf = [0i; 10];
     black_box(buf);
     recurse();
 }
diff --git a/src/test/run-pass/out-of-stack.rs b/src/test/run-pass/out-of-stack.rs
index 81e75ba2cd5..1594cca89e5 100644
--- a/src/test/run-pass/out-of-stack.rs
+++ b/src/test/run-pass/out-of-stack.rs
@@ -22,7 +22,7 @@ use std::os;
 pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } }
 
 fn silent_recurse() {
-    let buf = [0i, ..1000];
+    let buf = [0i; 1000];
     black_box(buf);
     silent_recurse();
 }
diff --git a/src/test/run-pass/packed-struct-generic-layout.rs b/src/test/run-pass/packed-struct-generic-layout.rs
index 999e4aeeb59..004a3022018 100644
--- a/src/test/run-pass/packed-struct-generic-layout.rs
+++ b/src/test/run-pass/packed-struct-generic-layout.rs
@@ -20,7 +20,7 @@ struct S<T, S> {
 pub fn main() {
     unsafe {
         let s = S { a: 0xff_ff_ff_ffu32, b: 1, c: 0xaa_aa_aa_aa as i32 };
-        let transd : [u8, .. 9] = mem::transmute(s);
+        let transd : [u8; 9] = mem::transmute(s);
         // Don't worry about endianness, the numbers are palindromic.
         assert!(transd ==
                    [0xff, 0xff, 0xff, 0xff,
@@ -29,7 +29,7 @@ pub fn main() {
 
 
         let s = S { a: 1u8, b: 2u8, c: 0b10000001_10000001 as i16};
-        let transd : [u8, .. 4] = mem::transmute(s);
+        let transd : [u8; 4] = mem::transmute(s);
         // Again, no endianness problems.
         assert!(transd ==
                    [1, 2, 0b10000001, 0b10000001]);
diff --git a/src/test/run-pass/packed-struct-layout.rs b/src/test/run-pass/packed-struct-layout.rs
index b4fbf0820cd..9e94502a92a 100644
--- a/src/test/run-pass/packed-struct-layout.rs
+++ b/src/test/run-pass/packed-struct-layout.rs
@@ -13,7 +13,7 @@ use std::mem;
 #[repr(packed)]
 struct S4 {
     a: u8,
-    b: [u8, .. 3],
+    b: [u8; 3],
 }
 
 #[repr(packed)]
@@ -25,11 +25,11 @@ struct S5 {
 pub fn main() {
     unsafe {
         let s4 = S4 { a: 1, b: [2,3,4] };
-        let transd : [u8, .. 4] = mem::transmute(s4);
+        let transd : [u8; 4] = mem::transmute(s4);
         assert!(transd == [1, 2, 3, 4]);
 
         let s5 = S5 { a: 1, b: 0xff_00_00_ff };
-        let transd : [u8, .. 5] = mem::transmute(s5);
+        let transd : [u8; 5] = mem::transmute(s5);
         // Don't worry about endianness, the u32 is palindromic.
         assert!(transd == [1, 0xff, 0, 0, 0xff]);
     }
diff --git a/src/test/run-pass/packed-struct-size.rs b/src/test/run-pass/packed-struct-size.rs
index 9472fd4ce38..846d51e2e7e 100644
--- a/src/test/run-pass/packed-struct-size.rs
+++ b/src/test/run-pass/packed-struct-size.rs
@@ -14,7 +14,7 @@ use std::mem;
 #[repr(packed)]
 struct S4 {
     a: u8,
-    b: [u8, .. 3],
+    b: [u8;  3],
 }
 
 #[repr(packed)]
diff --git a/src/test/run-pass/packed-struct-vec.rs b/src/test/run-pass/packed-struct-vec.rs
index 59bb5678b69..d2121aa7752 100644
--- a/src/test/run-pass/packed-struct-vec.rs
+++ b/src/test/run-pass/packed-struct-vec.rs
@@ -22,9 +22,9 @@ struct Foo {
 impl Copy for Foo {}
 
 pub fn main() {
-    let foos = [Foo { bar: 1, baz: 2 }, .. 10];
+    let foos = [Foo { bar: 1, baz: 2 }; 10];
 
-    assert_eq!(mem::size_of::<[Foo, .. 10]>(), 90);
+    assert_eq!(mem::size_of::<[Foo; 10]>(), 90);
 
     for i in range(0u, 10) {
         assert_eq!(foos[i], Foo { bar: 1, baz: 2});
diff --git a/src/test/run-pass/packed-tuple-struct-layout.rs b/src/test/run-pass/packed-tuple-struct-layout.rs
index 5fb43503ccb..c41d678b0f5 100644
--- a/src/test/run-pass/packed-tuple-struct-layout.rs
+++ b/src/test/run-pass/packed-tuple-struct-layout.rs
@@ -11,7 +11,7 @@
 use std::mem;
 
 #[repr(packed)]
-struct S4(u8,[u8, .. 3]);
+struct S4(u8,[u8; 3]);
 
 #[repr(packed)]
 struct S5(u8,u32);
@@ -19,11 +19,11 @@ struct S5(u8,u32);
 pub fn main() {
     unsafe {
         let s4 = S4(1, [2,3,4]);
-        let transd : [u8, .. 4] = mem::transmute(s4);
+        let transd : [u8; 4] = mem::transmute(s4);
         assert!(transd == [1, 2, 3, 4]);
 
         let s5 = S5(1, 0xff_00_00_ff);
-        let transd : [u8, .. 5] = mem::transmute(s5);
+        let transd : [u8; 5] = mem::transmute(s5);
         // Don't worry about endianness, the u32 is palindromic.
         assert!(transd == [1, 0xff, 0, 0, 0xff]);
     }
diff --git a/src/test/run-pass/packed-tuple-struct-size.rs b/src/test/run-pass/packed-tuple-struct-size.rs
index 8967b07ca88..a0b88ea53c5 100644
--- a/src/test/run-pass/packed-tuple-struct-size.rs
+++ b/src/test/run-pass/packed-tuple-struct-size.rs
@@ -12,7 +12,7 @@
 use std::mem;
 
 #[repr(packed)]
-struct S4(u8,[u8, .. 3]);
+struct S4(u8,[u8;  3]);
 
 #[repr(packed)]
 struct S5(u8, u32);
diff --git a/src/test/run-pass/regions-dependent-addr-of.rs b/src/test/run-pass/regions-dependent-addr-of.rs
index 79f8ca48882..41396ef01be 100644
--- a/src/test/run-pass/regions-dependent-addr-of.rs
+++ b/src/test/run-pass/regions-dependent-addr-of.rs
@@ -18,7 +18,7 @@ struct A {
 
 struct B {
     v1: int,
-    v2: [int, ..3],
+    v2: [int; 3],
     v3: Vec<int> ,
     v4: C,
     v5: Box<C>,
diff --git a/src/test/run-pass/repeat-expr-in-static.rs b/src/test/run-pass/repeat-expr-in-static.rs
index 9955673bb0b..a53f1da4ce6 100644
--- a/src/test/run-pass/repeat-expr-in-static.rs
+++ b/src/test/run-pass/repeat-expr-in-static.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static FOO: [int, ..4] = [32, ..4];
-static BAR: [int, ..4] = [32, 32, 32, 32];
+static FOO: [int; 4] = [32; 4];
+static BAR: [int; 4] = [32, 32, 32, 32];
 
 pub fn main() {
     assert!(FOO == BAR);
diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs
index 9c369c0d770..0781822cb74 100644
--- a/src/test/run-pass/repeated-vector-syntax.rs
+++ b/src/test/run-pass/repeated-vector-syntax.rs
@@ -11,8 +11,8 @@
 #![feature(slicing_syntax)]
 
 pub fn main() {
-    let x = [ [true], ..512 ];
-    let y = [ 0i, ..1 ];
+    let x = [ [true]; 512 ];
+    let y = [ 0i; 1 ];
 
     print!("[");
     for xi in x.iter() {
diff --git a/src/test/run-pass/uninit-empty-types.rs b/src/test/run-pass/uninit-empty-types.rs
index 005205353fc..c2bd738b8a4 100644
--- a/src/test/run-pass/uninit-empty-types.rs
+++ b/src/test/run-pass/uninit-empty-types.rs
@@ -18,6 +18,6 @@ struct Foo;
 pub fn main() {
     unsafe {
         let _x: Foo = mem::uninitialized();
-        let _x: [Foo, ..2] = mem::uninitialized();
+        let _x: [Foo; 2] = mem::uninitialized();
     }
 }
diff --git a/src/test/run-pass/unsized3.rs b/src/test/run-pass/unsized3.rs
index e5e6ce6e76b..271f5817c9e 100644
--- a/src/test/run-pass/unsized3.rs
+++ b/src/test/run-pass/unsized3.rs
@@ -60,7 +60,7 @@ pub fn main() {
 
     unsafe {
         struct Foo_<T> {
-            f: [T, ..3]
+            f: [T; 3]
         }
 
         let data = box Foo_{f: [1i32, 2, 3] };
@@ -72,7 +72,7 @@ pub fn main() {
 
         struct Baz_ {
             f1: uint,
-            f2: [u8, ..5],
+            f2: [u8; 5],
         }
 
         let data = box Baz_{ f1: 42, f2: ['a' as u8, 'b' as u8, 'c' as u8, 'd' as u8, 'e' as u8] };
diff --git a/src/test/run-pass/variadic-ffi.rs b/src/test/run-pass/variadic-ffi.rs
index aa71de2123c..f8eef988561 100644
--- a/src/test/run-pass/variadic-ffi.rs
+++ b/src/test/run-pass/variadic-ffi.rs
@@ -19,7 +19,7 @@ extern {
 }
 
 unsafe fn check<T>(expected: &str, f: |*mut c_char| -> T) {
-    let mut x = [0 as c_char, ..50];
+    let mut x = [0 as c_char; 50];
     f(&mut x[0] as *mut c_char);
     let res = CString::new(&x[0], false);
     assert_eq!(expected, res.as_str().unwrap());
diff --git a/src/test/run-pass/vec-dst.rs b/src/test/run-pass/vec-dst.rs
index d8bf0a5c627..4a36231e72b 100644
--- a/src/test/run-pass/vec-dst.rs
+++ b/src/test/run-pass/vec-dst.rs
@@ -9,9 +9,9 @@
 // except according to those terms.
 
 pub fn main() {
-    // Tests for indexing into box/& [T, ..n]
-    let x: [int, ..3] = [1, 2, 3];
-    let mut x: Box<[int, ..3]> = box x;
+    // Tests for indexing into box/& [T; n]
+    let x: [int; 3] = [1, 2, 3];
+    let mut x: Box<[int; 3]> = box x;
     assert!(x[0] == 1);
     assert!(x[1] == 2);
     assert!(x[2] == 3);
@@ -20,8 +20,8 @@ pub fn main() {
     assert!(x[1] == 45);
     assert!(x[2] == 3);
 
-    let mut x: [int, ..3] = [1, 2, 3];
-    let x: &mut [int, ..3] = &mut x;
+    let mut x: [int; 3] = [1, 2, 3];
+    let x: &mut [int; 3] = &mut x;
     assert!(x[0] == 1);
     assert!(x[1] == 2);
     assert!(x[2] == 3);
diff --git a/src/test/run-pass/vec-fixed-length.rs b/src/test/run-pass/vec-fixed-length.rs
index 05a7388b5e2..20e1becd008 100644
--- a/src/test/run-pass/vec-fixed-length.rs
+++ b/src/test/run-pass/vec-fixed-length.rs
@@ -11,17 +11,17 @@
 use std::mem::size_of;
 
 pub fn main() {
-    let x: [int, ..4] = [1, 2, 3, 4];
+    let x: [int; 4] = [1, 2, 3, 4];
     assert_eq!(x[0], 1);
     assert_eq!(x[1], 2);
     assert_eq!(x[2], 3);
     assert_eq!(x[3], 4);
 
-    assert_eq!(size_of::<[u8, ..4]>(), 4u);
+    assert_eq!(size_of::<[u8; 4]>(), 4u);
 
     // FIXME #10183
     // FIXME #18069
     //if cfg!(target_word_size = "64") {
-    //    assert_eq!(size_of::<[u8, ..(1 << 32)]>(), (1u << 32));
+    //    assert_eq!(size_of::<[u8; (1 << 32)]>(), (1u << 32));
     //}
 }
diff --git a/src/test/run-pass/vec-repeat-with-cast.rs b/src/test/run-pass/vec-repeat-with-cast.rs
index 18ccd8c96ab..97a443cb3b8 100644
--- a/src/test/run-pass/vec-repeat-with-cast.rs
+++ b/src/test/run-pass/vec-repeat-with-cast.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub fn main() { let _a = [0i, ..1 as uint]; }
+pub fn main() { let _a = [0i; 1 as uint]; }
diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs
index c969e66957c..fe89c7532ee 100644
--- a/src/test/run-pass/vector-sort-panic-safe.rs
+++ b/src/test/run-pass/vector-sort-panic-safe.rs
@@ -14,7 +14,7 @@ use std::rand::{task_rng, Rng, Rand};
 
 const REPEATS: uint = 5;
 const MAX_LEN: uint = 32;
-static drop_counts: [AtomicUint, .. MAX_LEN] =
+static drop_counts: [AtomicUint;  MAX_LEN] =
     // FIXME #5244: AtomicUint is not Copy.
     [
         INIT_ATOMIC_UINT, INIT_ATOMIC_UINT, INIT_ATOMIC_UINT, INIT_ATOMIC_UINT,