---

yaml
---
r: 4644
b: refs/heads/master
c: ee7d03f
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 594c7fb0c6eb997afa7da32a2a6b4f0f78522c3f
+refs/heads/master: ee7d03f7d7691e7ada44c29e09edebb2cf3791c5

trunk/src/test/bench/shootout-nbody.rs

@@ -12,9 +12,9 @@ fn main() {
     // during 'make check' under valgrind
     // 5000000
     // 50000000
-    let inputs: vec[int] = [50000, 500000];
+    let inputs: [int] = ~[50000, 500000];
 
-    let bodies: vec[Body::props] = NBodySystem::MakeNBodySystem();
+    let bodies: [Body::props] = NBodySystem::MakeNBodySystem();
 
 
     for n: int  in inputs {
@@ -31,10 +31,10 @@ fn main() {
 
 mod NBodySystem {
 
-    fn MakeNBodySystem() -> vec[Body::props] {
+    fn MakeNBodySystem() -> [Body::props] {
         // these each return a Body::props
-        let bodies: vec[Body::props] =
-            [Body::sun(), Body::jupiter(), Body::saturn(), Body::uranus(),
+        let bodies: [Body::props] =
+            ~[Body::sun(), Body::jupiter(), Body::saturn(), Body::uranus(),
              Body::neptune()];
 
         let px: float = 0.0;
@@ -56,7 +56,7 @@ mod NBodySystem {
         ret bodies;
     }
 
-    fn advance(bodies: vec[Body::props], dt: float) {
+    fn advance(bodies: &[Body::props], dt: float) {
 
         let i: int = 0;
         while i < 5 {
@@ -95,7 +95,7 @@ mod NBodySystem {
         b.z += dt * b.vz;
     }
 
-    fn energy(bodies: vec[Body::props]) -> float {
+    fn energy(bodies: &[Body::props]) -> float {
         let dx: float;
         let dy: float;
         let dz: float;

trunk/src/test/bench/shootout-pfib.rs

@@ -69,9 +69,9 @@ fn stress_task(id: int) {
 }
 
 fn stress(num_tasks: int) {
-    let tasks = [];
+    let tasks = ~[];
     for each i: int  in range(0, num_tasks) {
-        tasks += [spawn stress_task(i)];
+        tasks += ~[spawn stress_task(i)];
     }
     for each i: int  in range(0, num_tasks) { task::join(tasks.(i)); }
 }

trunk/src/test/compile-fail/fail-type-err.rs

@@ -1,2 +1,2 @@
-// error-pattern:expected str but found vec
-fn main() { fail []; }
+// error-pattern:expected str but found [int]
+fn main() { fail ~[0]; }

trunk/src/test/compile-fail/infinite-vec-type-recursion.rs

@@ -1,6 +1,6 @@
 // -*- rust -*-
 // error-pattern: illegal recursive type
 
-type x = vec[x];
+type x = [x];
 
-fn main() { let b: x = []; }
+fn main() { let b: x = ~[]; }

trunk/src/test/compile-fail/nested-ty-params.rs

@@ -1,5 +1,5 @@
 // error-pattern:Attempt to use a type argument out of scope
-fn hd[U](v: &vec[U]) -> U {
-    fn hd1(w: &vec[U]) -> U { ret w.(0); }
+fn hd[U](v: &[U]) -> U {
+    fn hd1(w: &[U]) -> U { ret w.(0); }
     ret hd1(v);
 }

trunk/src/test/compile-fail/pattern-tyvar-2.rs

@@ -6,7 +6,7 @@ import std::option::some;
 
 // error-pattern: mismatched types
 
-tag bar { t1((), option::t[vec[int]]); t2; }
+tag bar { t1((), option::t[[int]]); t2; }
 
 fn foo(t: bar) -> int { alt t { t1(_, some(x)) { ret x * 3; } _ { fail; } } }
 

trunk/src/test/compile-fail/pattern-tyvar.rs

@@ -5,7 +5,7 @@ import std::option::some;
 
 // error-pattern: mismatched types
 
-tag bar { t1((), option::t[vec[int]]); t2; }
+tag bar { t1((), option::t[[int]]); t2; }
 
 fn foo(t: bar) { alt t { t1(_, some[int](x)) { log x; } _ { fail; } } }
 

trunk/src/test/compile-fail/shadow.rs

@@ -1,15 +1,15 @@
 // -*- rust -*-
 // error-pattern:src/test/compile-fail/shadow.rs
-fn foo(c: vec[int]) {
+fn foo(c: [int]) {
     let a: int = 5;
-    let b: vec[int] = [];
+    let b: [int] = ~[];
 
 
     alt none[int] {
-      some[int](_) { for i: int  in c { log a; let a = 17; b += [a]; } }
+      some[int](_) { for i: int  in c { log a; let a = 17; b += ~[a]; } }
     }
 }
 
 tag t[T] { none; some(T); }
 
-fn main() { foo([]); }
+fn main() { foo(~[]); }

trunk/src/test/compile-fail/unsafe-for.rs

@@ -1,6 +1,6 @@
 // error-pattern:invalidate alias x
 
 fn main() {
-    let v: vec[mutable int] = [mutable 1, 2, 3];
+    let v: [mutable int] = ~[mutable 1, 2, 3];
     for x: int  in v { v.(0) = 10; log x; }
 }

trunk/src/test/compile-fail/vec-field.rs

@@ -1,8 +1,8 @@
-// error-pattern:attempted field access on type vec[int]
+// error-pattern:attempted field access on type [int]
 // issue #367
 
 fn f() {
-    let v = [1];
+    let v = ~[1];
     log v.some_field_name; //type error
 }
 

trunk/src/test/compile-fail/writing-through-uninit-vec.rs

@@ -1,5 +1,5 @@
 // error-pattern: Unsatisfied precondition constraint
 
-fn test() { let w: vec[int]; w.(5) = 0; }
+fn test() { let w: [int]; w.(5) = 0; }
 
 fn main() { test(); }

trunk/src/test/compile-fail/writing-to-immutable-vec.rs

@@ -1,2 +1,2 @@
 // error-pattern:assignment to immutable vec content
-fn main() { let v: vec[int] = [1, 2, 3]; v.(1) = 4; }
+fn main() { let v: [int] = ~[1, 2, 3]; v.(1) = 4; }

trunk/src/test/run-fail/vec-overrun.rs

@@ -3,7 +3,7 @@
 // error-pattern:bounds check
 // no-valgrind
 fn main() {
-    let v: vec[int] = [10];
+    let v: [int] = ~[10];
     let x: int = 0;
     assert (v.(x) == 10);
     // Bounds-check failure.

trunk/src/test/run-fail/vec-underrun.rs

@@ -3,7 +3,7 @@
 // error-pattern:bounds check
 // no-valgrind
 fn main() {
-    let v: vec[int] = [10, 20];
+    let v: [int] = ~[10, 20];
     let x: int = 0;
     assert (v.(x) == 10);
     // Bounds-check failure.

trunk/src/test/run-pass/alt-join.rs

@@ -7,12 +7,12 @@ import std::option::some;
 
 fn foo[T](y: &option::t[T]) {
     let x: int;
-    let rs: vec[int] = [];
+    let rs: [int] = ~[];
     /* tests that x doesn't get put in the precondition for the
        entire if expression */
 
     if true {
-    } else { alt y { none[T]. { x = 17; } _ { x = 42; } } rs += [x]; }
+    } else { alt y { none[T]. { x = 17; } _ { x = 42; } } rs += ~[x]; }
     ret;
 }
 

trunk/src/test/run-pass/argv.rs

@@ -1,7 +1,8 @@
-
+use std;
+import std::ivec;
 
 fn main(args: vec[str]) {
-    let vs: vec[str] = ["hi", "there", "this", "is", "a", "vec"];
-    let vvs: vec[vec[str]] = [args, vs];
-    for vs: vec[str]  in vvs { for s: str  in vs { log s; } }
+    let vs: [str] = ~["hi", "there", "this", "is", "a", "vec"];
+    let vvs: [[str]] = ~[ivec::from_vec(args), vs];
+    for vs: [str]  in vvs { for s: str  in vs { log s; } }
 }

trunk/src/test/run-pass/bind-parameterized-args.rs

@@ -1,7 +1,7 @@
 fn main() {
-    fn echo[T](c: int, x: vec[T]) { }
+    fn echo[T](c: int, x: &[T]) { }
 
-    let y: fn(vec[int])  = bind echo(42, _);
+    let y: fn(&[int])  = bind echo(42, _);
 
-    y([1]);
+    y(~[1]);
 }

trunk/src/test/run-pass/block-iter-1.rs

@@ -1,7 +1,7 @@
-fn iter_vec[T](v: &vec[T], f: &block(&T) ) { for x: T  in v { f(x); } }
+fn iter_vec[T](v: &[T], f: &block(&T) ) { for x: T  in v { f(x); } }
 
 fn main() {
-    let v = [1, 2, 3, 4, 5, 6, 7];
+    let v = ~[1, 2, 3, 4, 5, 6, 7];
     let odds = 0;
     iter_vec(v,
              block (i: &int) {

trunk/src/test/run-pass/block-iter-2.rs

@@ -1,7 +1,7 @@
-fn iter_vec[T](v: &vec[T], f: &block(&T) ) { for x: T  in v { f(x); } }
+fn iter_vec[T](v: &[T], f: &block(&T) ) { for x: T  in v { f(x); } }
 
 fn main() {
-    let v = [1, 2, 3, 4, 5];
+    let v = ~[1, 2, 3, 4, 5];
     let sum = 0;
     iter_vec(v,
              block (i: &int) {

trunk/src/test/run-pass/box-inside-if.rs

@@ -2,14 +2,14 @@
 
 // -*- rust -*-
 
-fn some_vec(x: int) -> vec[int] { ret []; }
+fn some_box(x: int) -> @int { ret @x; }
 
 fn is_odd(n: int) -> bool { ret true; }
 
-fn length_is_even(vs: vec[int]) -> bool { ret true; }
+fn length_is_even(vs: @int) -> bool { ret true; }
 
 fn foo(acc: int, n: int) {
-    if is_odd(n) && length_is_even(some_vec(1)) { log_err "bloop"; }
+    if is_odd(n) && length_is_even(some_box(1)) { log_err "bloop"; }
 }
 
 fn main() { foo(67, 5); }

trunk/src/test/run-pass/box-inside-if2.rs

@@ -2,14 +2,14 @@
 
 // -*- rust -*-
 
-fn some_vec(x: int) -> vec[int] { ret []; }
+fn some_box(x: int) -> @int { ret @x; }
 
 fn is_odd(n: int) -> bool { ret true; }
 
-fn length_is_even(vs: vec[int]) -> bool { ret true; }
+fn length_is_even(vs: @int) -> bool { ret true; }
 
 fn foo(acc: int, n: int) {
-    if is_odd(n) || length_is_even(some_vec(1)) { log_err "bloop"; }
+    if is_odd(n) || length_is_even(some_box(1)) { log_err "bloop"; }
 }
 
 fn main() { foo(67, 5); }

trunk/src/test/run-pass/break.rs

@@ -6,15 +6,15 @@ fn main() {
     assert (i == 10);
     do  { i += 1; if i == 20 { break; } } while i < 30
     assert (i == 20);
-    for x: int  in [1, 2, 3, 4, 5, 6] {
+    for x: int  in ~[1, 2, 3, 4, 5, 6] {
         if x == 3 { break; }
         assert (x <= 3);
     }
     i = 0;
     while i < 10 { i += 1; if i % 2 == 0 { cont; } assert (i % 2 != 0); }
     i = 0;
     do  { i += 1; if i % 2 == 0 { cont; } assert (i % 2 != 0); } while i < 10
-    for x: int  in [1, 2, 3, 4, 5, 6] {
+    for x: int  in ~[1, 2, 3, 4, 5, 6] {
         if x % 2 == 0 { cont; }
         assert (x % 2 != 0);
     }

trunk/src/test/run-pass/empty-mutable-vec.rs

@@ -1,3 +1,3 @@
 
 
-fn main() { let v: vec[mutable int] = [mutable ]; }
+fn main() { let v: [mutable int] = ~[mutable ]; }

trunk/src/test/run-pass/expr-alt-fail.rs

@@ -4,7 +4,7 @@ fn test_simple() {
 }
 
 fn test_box() {
-    let r = alt true { true { [10] } false { fail } };
+    let r = alt true { true { ~[10] } false { fail } };
     assert (r.(0) == 10);
 }
 

trunk/src/test/run-pass/expr-alt-generic-box2.rs

@@ -10,9 +10,9 @@ fn test_generic[T](expected: &T, eq: &compare[T]) {
 }
 
 fn test_vec() {
-    fn compare_vec(v1: &vec[int], v2: &vec[int]) -> bool { ret v1 == v2; }
-    let eq = bind compare_vec(_, _);
-    test_generic[vec[int]]([1, 2, 3], eq);
+    fn compare_box(v1: &@int, v2: &@int) -> bool { ret v1 == v2; }
+    let eq = bind compare_box(_, _);
+    test_generic[@int](@1, eq);
 }
 
 fn main() { test_vec(); }

trunk/src/test/run-pass/expr-block-generic-box2.rs

@@ -10,9 +10,9 @@ fn test_generic[T](expected: &T, eq: &compare[T]) {
 }
 
 fn test_vec() {
-    fn compare_vec(v1: &vec[int], v2: &vec[int]) -> bool { ret v1 == v2; }
+    fn compare_vec(v1: &@int, v2: &@int) -> bool { ret v1 == v2; }
     let eq = bind compare_vec(_, _);
-    test_generic[vec[int]]([1, 2], eq);
+    test_generic[@int](@1, eq);
 }
 
 fn main() { test_vec(); }

trunk/src/test/run-pass/expr-block-ref.rs

@@ -1,2 +1,2 @@
 // Regression test for issue #388
-fn main() { let x = { { [10] } }; }
+fn main() { let x = { { @10 } }; }

trunk/src/test/run-pass/expr-elseif-ref.rs

@@ -1,7 +1,7 @@
 // Make sure we drop the refs of the temporaries needed to return the
 // values from the else if branch
 fn main() {
-    let y: vec[uint] = [10u];
+    let y: @uint = @10u;
     let x = if false { y } else if (true) { y } else { y };
-    assert (y.(0) == 10u);
+    assert (y == 10u);
 }

trunk/src/test/run-pass/expr-elseif-ref2.rs

@@ -1,4 +1,4 @@
 // Regression test for issue #388
 fn main() {
-    let x = if false { [0u] } else if (true) { [10u] } else { [0u] };
+    let x = if false { @0u } else if (true) { @10u } else { @0u };
 }

trunk/src/test/run-pass/expr-fn.rs

@@ -4,7 +4,7 @@ fn test_int() {
 }
 
 fn test_vec() {
-    fn f() -> vec[int] { [10, 11] }
+    fn f() -> [int] { ~[10, 11] }
     assert (f().(1) == 11);
 }
 

trunk/src/test/run-pass/expr-if-generic-box2.rs

@@ -10,9 +10,9 @@ fn test_generic[T](expected: &T, not_expected: &T, eq: &compare[T]) {
 }
 
 fn test_vec() {
-    fn compare_vec(v1: &vec[int], v2: &vec[int]) -> bool { ret v1 == v2; }
-    let eq = bind compare_vec(_, _);
-    test_generic[vec[int]]([1, 2], [2, 3], eq);
+    fn compare_box(v1: &@int, v2: &@int) -> bool { ret v1 == v2; }
+    let eq = bind compare_box(_, _);
+    test_generic[@int](@1, @2, eq);
 }
 
 fn main() { test_vec(); }

trunk/src/test/run-pass/for-loop-fail.rs

@@ -1 +1 @@
-fn main() { let x: vec[int] = []; for i: int  in x { fail "moop"; } }
+fn main() { let x: [int] = ~[]; for i: int  in x { fail "moop"; } }

trunk/src/test/run-pass/foreach-nested-2.rs

@@ -10,7 +10,7 @@ iter range(start: int, stop: int) -> int {
 }
 
 fn main() {
-    let a: vec[mutable int] = [mutable -1, -1, -1, -1, -1, -1, -1, -1];
+    let a: [mutable int] = ~[mutable -1, -1, -1, -1, -1, -1, -1, -1];
     let p: int = 0;
     for each i: int  in two() {
         for each j: int  in range(0, 2) {