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.

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),
             }
         }

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 */ }
             };

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();

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!(self.word_space(";"));
-                try!(word(&mut self.s, ".."));
                 try!(self.print_expr(&**count));
                 try!(word(&mut self.s, "]"));
                 try!(self.end());

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'];
     }
 }
 

src/test/bench/noise.rs

@@ -37,20 +37,20 @@ fn gradient(orig: Vec2, grad: Vec2, p: Vec2) -> f32 {
 }
 
 struct Noise2DContext {
-    rgradients: [Vec2, ..256],
+    rgradients: [Vec2; 256],
-    permutations: [i32, ..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) {

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],
+    cnt: [i32; 16],
-    fact: [u32, .. 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;

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] {
+fn make_lookup(a: &[AminoAcid]) -> [AminoAcid;LOOKUP_SIZE] {
-    let mut lookup = [ NULL_AMINO_ACID, ..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) {

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) {

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",

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;

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],
+    table8: [u8;1 << 8],
-    table16: [u16, ..1 << 16]
+    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;

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],

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`
 }

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() {

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]`
 }

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() {

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 };

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.

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.

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;
+    let f2: &Fat<[int; 3]> = f1;
-    //~^ ERROR mismatched types: expected `&Fat<[int, ..3]>`, found `&Fat<[int]>`
+    //~^ ERROR mismatched types: expected `&Fat<[int; 3]>`, found `&Fat<[int]>`
 }

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

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];
 }

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];
+    let x: [u8; 1518599999] = [0; 1518599999];
-    generic::<[u8, ..1518599999]>(x);
+    generic::<[u8; 1518599999]>(x);
 }

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;
 }

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() {}
 

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)
     };

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)
   };

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]`
 }

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
     };
 }

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
 }

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];

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
 }

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
 }

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`
 }

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)
 }

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()),

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,
+pub fn test_move_array_then_overwrite_elem2(mut a: [D; 3], i: uint, j: uint,
-                                            recv: &mut [D, ..3], d1: D, d2: D) {
+                                            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).*`

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`
 }
 

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
 }

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
     }
 }

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
     }
 }

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 {

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);
     }
 }

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 `*`

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`
 }

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`

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`
 }

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 a = [0; n]; //~ ERROR expected constant integer for repeat count, found variable
-    let b = [0, ..()];
+    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
 }

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() {}

src/test/compile-fail/trailing-comma-array-repeat.rs

@@ -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: `]`
-}

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
 }
 

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 t1: *const [u8; 2] = &x1.y as *const _;
-    let h1: *const [u8, ..2] = &x1.y as *const [u8, ..2];
+    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 t1: *mut [u8; 2] = &mut x1.y as *mut _;
-    let h1: *mut [u8, ..2] = &mut x1.y as *mut [u8, ..2];
+    let h1: *mut [u8; 2] = &mut x1.y as *mut [u8; 2];
 }
 

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],
+    x: [u32; 3],
-    y: [[u32, ..2], ..2]
+    y: [[u32; 2]; 2]
 }
 
 struct StructInternalPadding {
-    x: [i16, ..2],
+    x: [i16; 2],
-    y: [i64, ..2]
+    y: [i64; 2]
 }
 
 struct SingleVec {
-    x: [i16, ..5]
+    x: [i16; 5]
 }
 
 struct StructPaddedAtEnd {
-    x: [i64, ..2],
+    x: [i64; 2],
-    y: [i16, ..2]
+    y: [i16; 2]
 }
 
 fn main() {

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();

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,

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]

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];

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;

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
+        (((&((([(1i as int), (2 as int), (3 as int)] as [int; 3])) as
-                [int, ..3]) as &[int, ..3]) as *const _ as *const [int, ..3])
+                [int; 3]) as &[int; 3]) as *const _ as *const [int; 3]) as
-            as *const [int, ..(3u as uint)] as *const [int, ..3]);
+            *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
+                 (&([("test" as &'static str)] as [&'static str; 1]) as
-                     &'static [&'static str, ..1]);
+                     &'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 struct TupleBar([int; (4u as uint)]);
-pub enum Baz { BazVariant([int, ..(5u 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
+        ((id::<[int; (3u as uint)]> as
-             fn([int, ..3]) -> [int, ..3])(([(1 as int), (2 as int),
+             fn([int; 3]) -> [int; 3])(([(1 as int), (2 as int), (3 as int)]
-                                             (3 as int)] as [int, ..3])) as
+                                           as [int; 3])) as [int; 3]);
-            [int, ..3]);
 }
 fn main() { }

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());
 }

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());
 }

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() {

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 _a: [bool; 1 as uint];
-    let _b: [int, ..SIZE as uint] = [1, ..SIZE as uint];
+    let _b: [int; SIZE as uint] = [1; SIZE as uint];
-    let _c: [bool, ..'\n' as uint] = [true, ..'\n' as uint];
+    let _c: [bool; '\n' as uint] = [true; '\n' as uint];
-    let _d: [bool, ..true as uint] = [true, ..true as uint];
+    let _d: [bool; true as uint] = [true; true as uint];
 }

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 aa: [int; 3] = [1, 2, 3];
-const ab: &'static [int, ..3] = &aa;
+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];

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() {

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];
 

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] {

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];
 
 }

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];
 
 }

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];

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};

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 A: [u8; 2] = ['h' as u8, 'i' as u8];
-const B: &'static [u8, ..2] = &A;
+const B: &'static [u8; 2] = &A;
 const C: *const u8 = B as *const u8;
 
 pub fn main() {

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() {

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);

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;  Flopsy::Bunny as uint];
-    let _v = [0i, .. BAR];
+    let _v = [0i;  BAR];
-    let _v = [0i, .. BAR2];
+    let _v = [0i;  BAR2];
     const BAR3:uint = BAR2;
-    let _v = [0i, .. BAR3];
+    let _v = [0i;  BAR3];
 }

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 x : [int; 5] = [1,2,3,4,5];
-    let _y : [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 a : [int; 5] = [1,1,1,1,1];
-    let b : [int, ..5] = [2,2,2,2,2];
+    let b : [int; 5] = [2,2,2,2,2];
-    let c : [int, ..5] = [2,2,2,2,3];
+    let c : [int; 5] = [2,2,2,2,3];
 
     log(debug, a);
 

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);
 }

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
     };

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)

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] };
 }

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() {}

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();

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());
 }

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 }

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

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];
 }

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 a = [0i; STRUCT.field];
-    let b = [0i, ..TUP.0];
+    let b = [0i; TUP.0];
 
     assert!(a.len() == 42);
     assert!(b.len() == 43);

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() {

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,

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];
 }

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.
 */
 

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]
 }
 

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]; ()
 }

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!()];
 }

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!(),
         _ => ()

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();

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();
 }

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); }
 }

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]);