testsuite: Eliminate uses of structural records from most run-pass tests

Except the pipes tests (that needs a snapshot)

119 files changed, 600 insertions, 432 deletions

diff --git a/src/test/auxiliary/cci_nested_lib.rs b/src/test/auxiliary/cci_nested_lib.rs
index 291a506c4eb..d20653e429a 100644
--- a/src/test/auxiliary/cci_nested_lib.rs
+++ b/src/test/auxiliary/cci_nested_lib.rs
@@ -13,11 +13,12 @@
 
 use dvec::DVec;
 
-type entry<A,B> = {key: A, value: B};
-struct alist<A,B> { eq_fn: fn@(A,A) -> bool, data: DVec<entry<A,B>> }
+struct Entry<A,B> {key: A, value: B}
+
+struct alist<A,B> { eq_fn: fn@(A,A) -> bool, data: DVec<Entry<A,B>> }
 
 fn alist_add<A: Copy, B: Copy>(lst: alist<A,B>, k: A, v: B) {
-    lst.data.push({key:k, value:v});
+    lst.data.push(Entry{key:k, value:v});
 }
 
 fn alist_get<A: Copy, B: Copy>(lst: alist<A,B>, k: A) -> B {
diff --git a/src/test/auxiliary/crateresolve5-1.rs b/src/test/auxiliary/crateresolve5-1.rs
index de893c28cdd..e07f24c2fb7 100644
--- a/src/test/auxiliary/crateresolve5-1.rs
+++ b/src/test/auxiliary/crateresolve5-1.rs
@@ -14,8 +14,10 @@
 #[crate_type = "lib"];
 #[legacy_exports];
 
-fn structural() -> { name: ~str, val: int } {
-    { name: ~"crateresolve5", val: 10 }
+struct NameVal { name: ~str, val: int }
+
+fn struct_nameval() -> NameVal {
+    NameVal { name: ~"crateresolve5", val: 10 }
 }
 
 enum e {
diff --git a/src/test/auxiliary/crateresolve5-2.rs b/src/test/auxiliary/crateresolve5-2.rs
index 67af05a2890..be7e993d29c 100644
--- a/src/test/auxiliary/crateresolve5-2.rs
+++ b/src/test/auxiliary/crateresolve5-2.rs
@@ -14,8 +14,9 @@
 #[crate_type = "lib"];
 #[legacy_exports];
 
-fn structural() -> { name: ~str, val: int } {
-    { name: ~"crateresolve5", val: 10 }
+struct NameVal { name: ~str, val: int }
+fn struct_nameval() -> NameVal {
+    NameVal { name: ~"crateresolve5", val: 10 }
 }
 
 enum e {
diff --git a/src/test/run-pass/alias-uninit-value.rs b/src/test/run-pass/alias-uninit-value.rs
index beb1a5fc6c2..888acf30b2a 100644
--- a/src/test/run-pass/alias-uninit-value.rs
+++ b/src/test/run-pass/alias-uninit-value.rs
@@ -14,10 +14,10 @@
 
 enum sty { ty_nil, }
 
-type raw_t = {struct_: sty, cname: Option<~str>, hash: uint};
+struct RawT {struct_: sty, cname: Option<~str>, hash: uint}
 
-fn mk_raw_ty(st: sty, cname: Option<~str>) -> raw_t {
-    return {struct_: st, cname: cname, hash: 0u};
+fn mk_raw_ty(st: sty, cname: Option<~str>) -> RawT {
+    return RawT {struct_: st, cname: cname, hash: 0u};
 }
 
 fn main() { mk_raw_ty(ty_nil, None::<~str>); }
diff --git a/src/test/run-pass/alignment-gep-tup-like-2.rs b/src/test/run-pass/alignment-gep-tup-like-2.rs
index ded15ca94f1..2e0e3ea8f55 100644
--- a/src/test/run-pass/alignment-gep-tup-like-2.rs
+++ b/src/test/run-pass/alignment-gep-tup-like-2.rs
@@ -8,18 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type pair<A,B> = {
+struct Pair<A,B> {
     a: A, b: B
-};
+}
 
-enum rec<A> = _rec<A>;
-type _rec<A> = {
+enum RecEnum<A> = Rec<A>;
+struct Rec<A> {
     val: A,
-    mut rec: Option<@rec<A>>
-};
+    mut rec: Option<@RecEnum<A>>
+}
 
 fn make_cycle<A:Copy>(a: A) {
-    let g: @rec<A> = @rec({val: a, mut rec: None});
+    let g: @RecEnum<A> = @RecEnum(Rec {val: a, mut rec: None});
     g.rec = Some(g);
 }
 
diff --git a/src/test/run-pass/alloca-from-derived-tydesc.rs b/src/test/run-pass/alloca-from-derived-tydesc.rs
index 869604442ea..2901754c8f2 100644
--- a/src/test/run-pass/alloca-from-derived-tydesc.rs
+++ b/src/test/run-pass/alloca-from-derived-tydesc.rs
@@ -10,8 +10,8 @@
 
 enum option<T> { some(T), none, }
 
-type r<T> = {mut v: ~[option<T>]};
+struct R<T> {mut v: ~[option<T>]}
 
 fn f<T>() -> ~[T] { return ~[]; }
 
-fn main() { let r: r<int> = {mut v: ~[]}; r.v = f(); }
+fn main() { let r: R<int> = R {mut v: ~[]}; r.v = f(); }
diff --git a/src/test/run-pass/alt-implicit-copy-unique.rs b/src/test/run-pass/alt-implicit-copy-unique.rs
index f703eed6a21..a30a0c64215 100644
--- a/src/test/run-pass/alt-implicit-copy-unique.rs
+++ b/src/test/run-pass/alt-implicit-copy-unique.rs
@@ -8,10 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Pair { mut a: ~int, mut b: ~int }
+
 fn main() {
-    let x = ~{mut a: ~10, b: ~20};
+    let x = ~Pair {mut a: ~10, b: ~20};
     match x {
-      ~{a: ref mut a, b: ref b} => {
+      ~Pair {a: ref mut a, b: ref b} => {
         assert **a == 10; *a = ~30; assert **a == 30;
       }
     }
diff --git a/src/test/run-pass/alt-naked-record-expr.rs b/src/test/run-pass/alt-naked-record-expr.rs
index 063e01fc02f..f23cf72cf1f 100644
--- a/src/test/run-pass/alt-naked-record-expr.rs
+++ b/src/test/run-pass/alt-naked-record-expr.rs
@@ -8,9 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct X { x: int }
+
 fn main() {
     let x = match 0 {
-      _ => {
+      _ => X {
         x: 0
       }.x
     };
diff --git a/src/test/run-pass/alt-naked-record.rs b/src/test/run-pass/alt-naked-record.rs
index 0d3d8768e96..dbb8b07b8e8 100644
--- a/src/test/run-pass/alt-naked-record.rs
+++ b/src/test/run-pass/alt-naked-record.rs
@@ -8,9 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct X { x: int }
+
 fn main() {
     let x = match 0 {
-      _ => {
+      _ => X {
         x: 0
       }
     };
diff --git a/src/test/run-pass/alt-ref-binding-mut.rs b/src/test/run-pass/alt-ref-binding-mut.rs
index 2ec0c1d81ce..fc124041fd4 100644
--- a/src/test/run-pass/alt-ref-binding-mut.rs
+++ b/src/test/run-pass/alt-ref-binding-mut.rs
@@ -8,18 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type rec = {
+struct Rec {
     f: int
-};
+}
 
-fn destructure(x: &mut rec) {
+fn destructure(x: &mut Rec) {
     match *x {
-      {f: ref mut f} => *f += 1
+      Rec {f: ref mut f} => *f += 1
     }
 }
 
 fn main() {
-    let mut v = {f: 22};
+    let mut v = Rec {f: 22};
     destructure(&mut v);
     assert v.f == 23;
 }
diff --git a/src/test/run-pass/argument-passing.rs b/src/test/run-pass/argument-passing.rs
index d38683f7eab..560a6cbb823 100644
--- a/src/test/run-pass/argument-passing.rs
+++ b/src/test/run-pass/argument-passing.rs
@@ -11,7 +11,9 @@
 // xfail-fast
 #[legacy_modes];
 
-fn f1(a: {mut x: int}, b: &mut int, -c: int) -> int {
+struct X { mut x: int }
+
+fn f1(a: X, b: &mut int, -c: int) -> int {
     let r = a.x + *b + c;
     a.x = 0;
     *b = 10;
@@ -21,7 +23,7 @@ fn f1(a: {mut x: int}, b: &mut int, -c: int) -> int {
 fn f2(a: int, f: fn(int)) -> int { f(1); return a; }
 
 fn main() {
-    let mut a = {mut x: 1}, b = 2, c = 3;
+    let mut a = X {mut x: 1}, b = 2, c = 3;
     assert (f1(a, &mut b, move c) == 6);
     assert (a.x == 0);
     assert (b == 10);
diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs
index f96cfeb3f37..a2031019a4d 100644
--- a/src/test/run-pass/auto-instantiate.rs
+++ b/src/test/run-pass/auto-instantiate.rs
@@ -12,9 +12,13 @@
 
 
 // -*- rust -*-
-fn f<T: Copy, U: Copy>(x: T, y: U) -> {a: T, b: U} { return {a: x, b: y}; }
+
+struct Pair<T, U> { a: T, b: U }
+struct Triple { x: int, y: int, z: int }
+
+fn f<T: Copy, U: Copy>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; }
 
 fn main() {
-    log(debug, f({x: 3, y: 4, z: 5}, 4).a.x);
+    log(debug, f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
     log(debug, f(5, 6).a);
 }
diff --git a/src/test/run-pass/borrowck-binding-mutbl.rs b/src/test/run-pass/borrowck-binding-mutbl.rs
index 04e00b5972c..7a620d58481 100644
--- a/src/test/run-pass/borrowck-binding-mutbl.rs
+++ b/src/test/run-pass/borrowck-binding-mutbl.rs
@@ -8,14 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct F { mut f: ~[int] }
+
 fn impure(_v: &[int]) {
 }
 
 fn main() {
-    let x = {mut f: ~[3]};
+    let x = F {f: ~[3]};
 
     match x {
-      {f: ref mut v} => {
+      F {f: ref mut v} => {
         impure(*v);
       }
     }
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index ece12f8d4c0..b6c205524a8 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type ints = {sum: ~int, values: ~[int]};
+struct Ints {sum: ~int, values: ~[int]}
 
-fn add_int(x: &mut ints, v: int) {
+fn add_int(x: &mut Ints, v: int) {
     *x.sum += v;
     let mut values = ~[];
     x.values <-> values;
@@ -18,13 +18,13 @@ fn add_int(x: &mut ints, v: int) {
     x.values <-> values;
 }
 
-fn iter_ints(x: &ints, f: fn(x: &int) -> bool) {
+fn iter_ints(x: &Ints, f: fn(x: &int) -> bool) {
     let l = x.values.len();
     uint::range(0, l, |i| f(&x.values[i]))
 }
 
 fn main() {
-    let mut ints = ~{sum: ~0, values: ~[]};
+    let mut ints = ~Ints {sum: ~0, values: ~[]};
     add_int(ints, 22);
     add_int(ints, 44);
 
diff --git a/src/test/run-pass/borrowck-preserve-box-in-discr.rs b/src/test/run-pass/borrowck-preserve-box-in-discr.rs
index 5cee34b9228..14757bfa3d8 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-discr.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-discr.rs
@@ -10,14 +10,16 @@
 
 // exec-env:RUST_POISON_ON_FREE=1
 
+struct F { f: ~int }
+
 fn main() {
-    let mut x = @{f: ~3};
+    let mut x = @F {f: ~3};
     match x {
-      @{f: ref b_x} => {
+      @F {f: ref b_x} => {
         assert **b_x == 3;
         assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(**b_x));
 
-        x = @{f: ~4};
+        x = @F {f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(**b_x)) as uint);
         assert **b_x == 3;
diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs
index 333845c9cad..87592f54817 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-field.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs
@@ -17,12 +17,14 @@ fn borrow(x: &int, f: fn(x: &int)) {
     assert before == after;
 }
 
+struct F { f: ~int }
+
 fn main() {
-    let mut x = @{f: ~3};
+    let mut x = @F {f: ~3};
     do borrow(x.f) |b_x| {
         assert *b_x == 3;
         assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
-        x = @{f: ~4};
+        x = @F {f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
diff --git a/src/test/run-pass/borrowck-preserve-box-in-pat.rs b/src/test/run-pass/borrowck-preserve-box-in-pat.rs
index f641131e48e..ccf9be1d585 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-pat.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-pat.rs
@@ -10,14 +10,16 @@
 
 // exec-env:RUST_POISON_ON_FREE=1
 
+struct F { f: ~int }
+
 fn main() {
-    let mut x = @mut @{f: ~3};
+    let mut x = @mut @F {f: ~3};
     match x {
-      @@{f: ref b_x} => {
+      @@F{f: ref b_x} => {
         assert **b_x == 3;
         assert ptr::addr_of(&(x.f)) == ptr::addr_of(b_x);
 
-        *x = @{f: ~4};
+        *x = @F {f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(**b_x)) as uint);
         assert **b_x == 3;
diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
index 90fe4000ddb..1f6bfe20bb1 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
@@ -17,12 +17,14 @@ fn borrow(x: &int, f: fn(x: &int)) {
     assert before == after;
 }
 
+struct F { f: ~int }
+
 fn main() {
-    let mut x = ~mut @{f: ~3};
+    let mut x = ~mut @F{f: ~3};
     do borrow(x.f) |b_x| {
         assert *b_x == 3;
         assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
-        *x = @{f: ~4};
+        *x = @F{f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs
index 93ec2119307..30250c26a9a 100644
--- a/src/test/run-pass/borrowck-preserve-expl-deref.rs
+++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs
@@ -17,12 +17,14 @@ fn borrow(x: &int, f: fn(x: &int)) {
     assert before == after;
 }
 
+struct F { f: ~int }
+
 fn main() {
-    let mut x = @{f: ~3};
+    let mut x = @F {f: ~3};
     do borrow((*x).f) |b_x| {
         assert *b_x == 3;
         assert ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x));
-        x = @{f: ~4};
+        x = @F {f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
         assert *b_x == 3;
diff --git a/src/test/run-pass/borrowck-root-while-cond-2.rs b/src/test/run-pass/borrowck-root-while-cond-2.rs
index 0ce704d4670..0e4f15d49db 100644
--- a/src/test/run-pass/borrowck-root-while-cond-2.rs
+++ b/src/test/run-pass/borrowck-root-while-cond-2.rs
@@ -8,7 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct F { mut f: @G }
+struct G { g: ~[int] }
+
 fn main() {
-    let rec = @{mut f: @{g: ~[1, 2, 3]}};
+    let rec = @F {mut f: @G {g: ~[1, 2, 3]}};
     while rec.f.g.len() == 23 {}
 }
diff --git a/src/test/run-pass/borrowck-root-while-cond.rs b/src/test/run-pass/borrowck-root-while-cond.rs
index 893cc6c9732..e8e3cf297ba 100644
--- a/src/test/run-pass/borrowck-root-while-cond.rs
+++ b/src/test/run-pass/borrowck-root-while-cond.rs
@@ -10,7 +10,9 @@
 
 fn borrow<T>(x: &r/T) -> &r/T {x}
 
+struct Rec { mut f: @int }
+
 fn main() {
-    let rec = @{mut f: @22};
+    let rec = @Rec {mut f: @22};
     while *borrow(rec.f) == 23 {}
 }
diff --git a/src/test/run-pass/box-pattern.rs b/src/test/run-pass/box-pattern.rs
index 3688fe94815..91e416b72e1 100644
--- a/src/test/run-pass/box-pattern.rs
+++ b/src/test/run-pass/box-pattern.rs
@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type foo = {a: int, b: uint};
-enum bar { u(@foo), w(int), }
+struct Foo {a: int, b: uint}
+enum bar { u(@Foo), w(int), }
 
 fn main() {
-    assert (match u(@{a: 10, b: 40u}) {
-              u(@{a: a, b: b}) => { a + (b as int) }
+    assert (match u(@Foo{a: 10, b: 40u}) {
+              u(@Foo{a: a, b: b}) => { a + (b as int) }
               _ => { 66 }
             } == 50);
 }
diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs
index 57bec6c0c27..35585014713 100644
--- a/src/test/run-pass/box-unbox.rs
+++ b/src/test/run-pass/box-unbox.rs
@@ -10,13 +10,13 @@
 
 
 
-type box<T: Copy> = {c: @T};
+struct Box<T: Copy> {c: @T}
 
-fn unbox<T: Copy>(b: box<T>) -> T { return *b.c; }
+fn unbox<T: Copy>(b: Box<T>) -> T { return *b.c; }
 
 fn main() {
     let foo: int = 17;
-    let bfoo: box<int> = {c: @foo};
+    let bfoo: Box<int> = Box {c: @foo};
     debug!("see what's in our box");
     assert (unbox::<int>(bfoo) == foo);
 }
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index 4defb3c6f37..3c55409dde8 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -14,11 +14,13 @@
 
 fn foo<T: Copy Const>(x: T) -> T { x }
 
+struct F { field: int }
+
 fn main() {
     foo(1);
     foo(~"hi");
     foo(~[1, 2, 3]);
-    foo({field: 42});
+    foo(F{field: 42});
     foo((1, 2u));
     foo(@1);
     foo(~1);
diff --git a/src/test/run-pass/const-fields-and-indexing.rs b/src/test/run-pass/const-fields-and-indexing.rs
index dd5e94b52eb..6dccecb5aa8 100644
--- a/src/test/run-pass/const-fields-and-indexing.rs
+++ b/src/test/run-pass/const-fields-and-indexing.rs
@@ -13,11 +13,16 @@ const p : int = x[2];
 const y : &[int] = &[1,2,3,4];
 const q : int = y[2];
 
-const s : {a: int, b: int} = {a: 10, b: 20};
+struct S {a: int, b: int}
+
+const s : S = S {a: 10, b: 20};
 const t : int = s.b;
 
-const k : {a: int, b: int, c: {d: int, e: int}} = {a: 10, b: 20, c: {d: 30,
-                                                                     e: 40}};
+struct K {a: int, b: int, c: D}
+struct D { d: int, e: int }
+
+const k : K = K {a: 10, b: 20, c: D {d: 30,
+                                     e: 40}};
 const m : int = k.c.e;
 
 fn main() {
diff --git a/src/test/run-pass/const-rec-and-tup.rs b/src/test/run-pass/const-rec-and-tup.rs
index 4764bb25248..b3d971a2cef 100644
--- a/src/test/run-pass/const-rec-and-tup.rs
+++ b/src/test/run-pass/const-rec-and-tup.rs
@@ -8,13 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Pair { a: float, b: float }
+
+struct AnotherPair { x: (i64, i64), y: Pair }
+
 const x : (i32,i32) = (0xfeedf00dd,0xca11ab1e);
-const y : { x: (i64, i64),
-            y: { a: float,
-                 b: float } } = { x: (0xf0f0f0f0_f0f0f0f0,
-                                      0xabababab_abababab),
-                                  y: { a: 3.14159265358979323846,
-                                       b: 2.7182818284590452354 } };
+const y : AnotherPair = AnotherPair{ x: (0xf0f0f0f0_f0f0f0f0,
+                                         0xabababab_abababab),
+                           y: Pair { a: 3.14159265358979323846,
+                                     b: 2.7182818284590452354 }};
 
 fn main() {
     let (p, _) = y.x;
diff --git a/src/test/run-pass/const-region-ptrs.rs b/src/test/run-pass/const-region-ptrs.rs
index ce5e9ade8ca..c8b08b1e35a 100644
--- a/src/test/run-pass/const-region-ptrs.rs
+++ b/src/test/run-pass/const-region-ptrs.rs
@@ -9,9 +9,11 @@
 // except according to those terms.
 
 
+struct Pair { a: int, b: &int }
+
 const x: &int = &10;
 
-const y: &{a: int, b: &int} = &{a: 15, b: x};
+const y: &Pair = &Pair {a: 15, b: x};
 
 fn main() {
     io::println(fmt!("x = %?", *x));
diff --git a/src/test/run-pass/crateresolve5.rs b/src/test/run-pass/crateresolve5.rs
index 4b4c91ae6f0..0b0d9a839ce 100644
--- a/src/test/run-pass/crateresolve5.rs
+++ b/src/test/run-pass/crateresolve5.rs
@@ -17,8 +17,8 @@ extern mod cr5_2 (name = "crateresolve5", vers = "0.2");
 
 fn main() {
     // Structural types can be used between two versions of the same crate
-    assert cr5_1::structural().name == cr5_2::structural().name;
-    assert cr5_1::structural().val == cr5_2::structural().val;
+    assert cr5_1::struct_nameval().name == cr5_2::struct_nameval().name;
+    assert cr5_1::struct_nameval().val == cr5_2::struct_nameval().val;
     // Make sure these are actually two different crates
     assert cr5_1::f() == 10 && cr5_2::f() == 20;
 }
diff --git a/src/test/run-pass/early-vtbl-resolution.rs b/src/test/run-pass/early-vtbl-resolution.rs
index 23a9bfeccc3..2e647d25c74 100644
--- a/src/test/run-pass/early-vtbl-resolution.rs
+++ b/src/test/run-pass/early-vtbl-resolution.rs
@@ -17,9 +17,11 @@ impl<A> int: thing<A> {
 }
 fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() }
 
+struct A { a: int }
+
 fn main() {
 
-    for iter::eachi(&(Some({a: 0}))) |i, a| { 
+    for iter::eachi(&(Some(A {a: 0}))) |i, a| { 
         debug!("%u %d", i, a.a);
     }
 
diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs
index 674746530fa..bb57710969f 100644
--- a/src/test/run-pass/explicit-self-generic.rs
+++ b/src/test/run-pass/explicit-self-generic.rs
@@ -18,14 +18,14 @@ extern mod std;
 type HashFn<K> = pure fn~(K) -> uint;
 type EqFn<K> = pure fn~(K, K) -> bool;
 
+struct LM { resize_at: uint, size: uint }
+
 enum LinearMap<K,V> {
-    LinearMap_({
-        resize_at: uint,
-        size: uint})
+    LinearMap_(LM)
 }
 
 fn linear_map<K,V>() -> LinearMap<K,V> {
-    LinearMap_({
+    LinearMap_(LM{
         resize_at: 32,
         size: 0})
 }
diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs
index 06b9f0d8ca5..b4a80906b33 100644
--- a/src/test/run-pass/explicit-self.rs
+++ b/src/test/run-pass/explicit-self.rs
@@ -11,11 +11,11 @@
 
 const tau: float = 2.0*3.14159265358979323;
 
-type point = {x: float, y: float};
-type size = {w: float, h: float};
+struct Point {x: float, y: float}
+struct Size {w: float, h: float}
 enum shape {
-    circle(point, float),
-    rectangle(point, size)
+    circle(Point, float),
+    rectangle(Point, Size)
 }
 
 
@@ -37,16 +37,18 @@ impl shape {
 fn select_based_on_unit_circle<T>(
     threshold: float, a: &r/T, b: &r/T) -> &r/T {
 
-    let shape = &circle({x: 0.0, y: 0.0}, 1.0);
+    let shape = &circle(Point{x: 0.0, y: 0.0}, 1.0);
     shape.select(threshold, a, b)
 }
 
 
 struct thing {
-    x: {mut a: @int}
+    x: A
 }
 
-fn thing(x: {mut a: @int}) -> thing {
+struct A { mut a: @int }
+
+fn thing(x: A) -> thing {
     thing {
         x: copy x
     }
@@ -56,7 +58,7 @@ impl thing {
     fn foo(@self) -> int { *self.x.a }
     fn bar(~self) -> int { *self.x.a }
     fn quux(&self) -> int { *self.x.a }
-    fn baz(&self) -> &self/{mut a: @int} { &self.x }
+    fn baz(&self) -> &self/A { &self.x }
     fn spam(self) -> int { *self.x.a }
 }
 
@@ -65,14 +67,14 @@ impl thing: Nus { fn f(&self) {} }
 
 fn main() {
 
-    let x = @thing({mut a: @10});
+    let x = @thing(A {mut a: @10});
     assert x.foo() == 10;
     assert x.quux() == 10;
 
-    let y = ~thing({mut a: @10});
+    let y = ~thing(A {mut a: @10});
     assert (copy y).bar() == 10;
     assert y.quux() == 10;
 
-    let z = thing({mut a: @11});
+    let z = thing(A {mut a: @11});
     assert z.spam() == 11;
 }
diff --git a/src/test/run-pass/expr-alt-generic.rs b/src/test/run-pass/expr-alt-generic.rs
index 43b480cd8a4..61e92500cc8 100644
--- a/src/test/run-pass/expr-alt-generic.rs
+++ b/src/test/run-pass/expr-alt-generic.rs
@@ -24,13 +24,13 @@ fn test_bool() {
     test_generic::<bool>(true, compare_bool);
 }
 
-type t = {a: int, b: int};
+struct Pair { a: int, b: int }
 
 fn test_rec() {
-    fn compare_rec(t1: t, t2: t) -> bool {
+    fn compare_rec(t1: Pair, t2: Pair) -> bool {
         t1.a == t2.a && t1.b == t2.b
     }
-    test_generic::<t>({a: 1, b: 2}, compare_rec);
+    test_generic::<Pair>(Pair {a: 1, b: 2}, compare_rec);
 }
 
 fn main() { test_bool(); test_rec(); }
diff --git a/src/test/run-pass/expr-alt-struct.rs b/src/test/run-pass/expr-alt-struct.rs
index c14eb1072aa..1cc9d4ba684 100644
--- a/src/test/run-pass/expr-alt-struct.rs
+++ b/src/test/run-pass/expr-alt-struct.rs
@@ -13,9 +13,11 @@
 
 // -*- rust -*-
 
-// Tests for match as expressions resulting in structural types
+// Tests for match as expressions resulting in struct types
+struct R { i: int }
+
 fn test_rec() {
-    let rs = match true { true => {i: 100}, _ => fail };
+    let rs = match true { true => R {i: 100}, _ => fail };
     assert (rs.i == 100);
 }
 
diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs
index 22c01f7893a..6cfc06307c4 100644
--- a/src/test/run-pass/expr-block-generic.rs
+++ b/src/test/run-pass/expr-block-generic.rs
@@ -26,13 +26,13 @@ fn test_bool() {
     test_generic::<bool>(true, compare_bool);
 }
 
-type t = {a: int, b: int};
+struct Pair {a: int, b: int}
 
 fn test_rec() {
-    fn compare_rec(t1: t, t2: t) -> bool {
+    fn compare_rec(t1: Pair, t2: Pair) -> bool {
         t1.a == t2.a && t1.b == t2.b
     }
-    test_generic::<t>({a: 1, b: 2}, compare_rec);
+    test_generic::<Pair>(Pair {a: 1, b: 2}, compare_rec);
 }
 
 fn main() { test_bool(); test_rec(); }
diff --git a/src/test/run-pass/expr-block-slot.rs b/src/test/run-pass/expr-block-slot.rs
index d35a49409ba..8c173ae5d76 100644
--- a/src/test/run-pass/expr-block-slot.rs
+++ b/src/test/run-pass/expr-block-slot.rs
@@ -9,9 +9,13 @@
 // except according to those terms.
 
 // Regression test for issue #377
+
+struct A { a: int }
+struct V { v: int }
+
 fn main() {
-    let a = { let b = {a: 3}; b };
+    let a = { let b = A {a: 3}; b };
     assert (a.a == 3);
-    let c = { let d = {v: 3}; d };
+    let c = { let d = V {v: 3}; d };
     assert (c.v == 3);
 }
diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs
index 6ae823df618..490f3950f9f 100644
--- a/src/test/run-pass/expr-block.rs
+++ b/src/test/run-pass/expr-block.rs
@@ -16,7 +16,9 @@
 // Tests for standalone blocks as expressions
 fn test_basic() { let rs: bool = { true }; assert (rs); }
 
-fn test_rec() { let rs = { {v1: 10, v2: 20} }; assert (rs.v2 == 20); }
+struct RS { v1: int, v2: int }
+
+fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; assert (rs.v2 == 20); }
 
 fn test_filled_with_stuff() {
     let rs = { let mut a = 0; while a < 10 { a += 1; } a };
diff --git a/src/test/run-pass/expr-copy.rs b/src/test/run-pass/expr-copy.rs
index 8dedfb73e9b..69dcac9f03a 100644
--- a/src/test/run-pass/expr-copy.rs
+++ b/src/test/run-pass/expr-copy.rs
@@ -11,12 +11,14 @@
 // xfail-fast
 #[legacy_modes];
 
-fn f(arg: {mut a: int}) {
+fn f(arg: A) {
     arg.a = 100;
 }
 
+struct A { mut a: int }
+
 fn main() {
-    let x = {mut a: 10};
+    let x = A {a: 10};
     f(x);
     assert x.a == 100;
     x.a = 20;
diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs
index 9347566d700..92f9117dde8 100644
--- a/src/test/run-pass/expr-if-generic.rs
+++ b/src/test/run-pass/expr-if-generic.rs
@@ -25,13 +25,13 @@ fn test_bool() {
     test_generic::<bool>(true, false, compare_bool);
 }
 
-type t = {a: int, b: int};
+struct Pair {a: int, b: int}
 
 fn test_rec() {
-    fn compare_rec(t1: t, t2: t) -> bool {
+    fn compare_rec(t1: Pair, t2: Pair) -> bool {
         t1.a == t2.a && t1.b == t2.b
     }
-    test_generic::<t>({a: 1, b: 2}, {a: 2, b: 3}, compare_rec);
+    test_generic::<Pair>(Pair{a: 1, b: 2}, Pair{a: 2, b: 3}, compare_rec);
 }
 
 fn main() { test_bool(); test_rec(); }
diff --git a/src/test/run-pass/expr-if-struct.rs b/src/test/run-pass/expr-if-struct.rs
index 6f22ea908ad..506d607e7e8 100644
--- a/src/test/run-pass/expr-if-struct.rs
+++ b/src/test/run-pass/expr-if-struct.rs
@@ -13,9 +13,12 @@
 
 // -*- rust -*-
 
-// Tests for if as expressions returning structural types
+// Tests for if as expressions returning nominal types
+
+struct I { i: int }
+
 fn test_rec() {
-    let rs = if true { {i: 100} } else { {i: 101} };
+    let rs = if true { I {i: 100} } else { I {i: 101} };
     assert (rs.i == 100);
 }
 
diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs
index c9a2db9c6f1..2d77a775f34 100644
--- a/src/test/run-pass/exterior.rs
+++ b/src/test/run-pass/exterior.rs
@@ -12,13 +12,13 @@
 
 
 // -*- rust -*-
-type point = {x: int, y: int, mut z: int};
+struct Point {x: int, y: int, mut z: int}
 
-fn f(p: @point) { assert (p.z == 12); p.z = 13; assert (p.z == 13); }
+fn f(p: @Point) { assert (p.z == 12); p.z = 13; assert (p.z == 13); }
 
 fn main() {
-    let a: point = {x: 10, y: 11, mut z: 12};
-    let b: @point = @copy a;
+    let a: Point = Point {x: 10, y: 11, mut z: 12};
+    let b: @Point = @copy a;
     assert (b.z == 12);
     f(b);
     assert (a.z == 12);
diff --git a/src/test/run-pass/fixed_length_vec_glue.rs b/src/test/run-pass/fixed_length_vec_glue.rs
index 253b68db44e..3d6e781c512 100644
--- a/src/test/run-pass/fixed_length_vec_glue.rs
+++ b/src/test/run-pass/fixed_length_vec_glue.rs
@@ -8,9 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Struc { a: u8, b: [int * 3], c: int }
+
 fn main() {
     let arr = [1,2,3];
-    let struc = {a: 13u8, b: arr, c: 42};
+    let struc = Struc {a: 13u8, b: arr, c: 42};
     let s = sys::log_str(&struc);
     assert(s == ~"{a: 13, b: [1, 2, 3], c: 42}");
 }
diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs
index 4ab3f5449e4..47da343764c 100644
--- a/src/test/run-pass/for-destruct.rs
+++ b/src/test/run-pass/for-destruct.rs
@@ -8,8 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Pair { x: int, y: int }
+
 fn main() {
-    for vec::each(~[{x: 10, y: 20}, {x: 30, y: 0}]) |elt| {
+    for vec::each(~[Pair {x: 10, y: 20}, Pair {x: 30, y: 0}]) |elt| {
         assert (elt.x + elt.y == 30);
     }
 }
diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs
index fa6b81175b0..f68cf1676c7 100644
--- a/src/test/run-pass/generic-box.rs
+++ b/src/test/run-pass/generic-box.rs
@@ -10,9 +10,11 @@
 
 
 
-fn box<T: Copy>(x: {x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { return @x; }
+fn box<T: Copy>(x: Box<T>) -> @Box<T> { return @x; }
+
+struct Box<T> {x: T, y: T, z: T}
 
 fn main() {
-    let x: @{x: int, y: int, z: int} = box::<int>({x: 1, y: 2, z: 3});
+    let x: @Box<int> = box::<int>(Box{x: 1, y: 2, z: 3});
     assert (x.y == 2);
 }
diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs
index 7cf3f3981ea..03f5a84de69 100644
--- a/src/test/run-pass/generic-derived-type.rs
+++ b/src/test/run-pass/generic-derived-type.rs
@@ -12,11 +12,12 @@
 
 fn g<X: Copy>(x: X) -> X { return x; }
 
-fn f<T: Copy>(t: T) -> {a: T, b: T} {
-    type pair = {a: T, b: T};
+struct Pair<T> {a: T, b: T}
 
-    let x: pair = {a: t, b: t};
-    return g::<pair>(x);
+fn f<T: Copy>(t: T) -> Pair<T> {
+
+    let x: Pair<T> = Pair {a: t, b: t};
+    return g::<Pair<T>>(x);
 }
 
 fn main() {
diff --git a/src/test/run-pass/generic-drop-glue.rs b/src/test/run-pass/generic-drop-glue.rs
index fe1db75f4b8..aad24e99058 100644
--- a/src/test/run-pass/generic-drop-glue.rs
+++ b/src/test/run-pass/generic-drop-glue.rs
@@ -9,7 +9,8 @@
 // except according to those terms.
 
 
+struct Pair { x: @int, y: @int }
 
 fn f<T: Copy>(t: T) { let t1: T = t; }
 
-fn main() { let x = {x: @10, y: @12}; f(x); }
+fn main() { let x = Pair {x: @10, y: @12}; f(x); }
diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs
index b26e1aebe1a..738bb73b0be 100644
--- a/src/test/run-pass/generic-exterior-box.rs
+++ b/src/test/run-pass/generic-exterior-box.rs
@@ -10,12 +10,12 @@
 
 
 
-type recbox<T: Copy> = {x: @T};
+struct Recbox<T: Copy> {x: @T}
 
-fn reclift<T: Copy>(t: T) -> recbox<T> { return {x: @t}; }
+fn reclift<T: Copy>(t: T) -> Recbox<T> { return Recbox {x: @t}; }
 
 fn main() {
     let foo: int = 17;
-    let rbfoo: recbox<int> = reclift::<int>(foo);
+    let rbfoo: Recbox<int> = reclift::<int>(foo);
     assert (*rbfoo.x == foo);
 }
diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs
index 975ce3bc616..2095578aefa 100644
--- a/src/test/run-pass/generic-exterior-unique.rs
+++ b/src/test/run-pass/generic-exterior-unique.rs
@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type recbox<T: Copy> = {x: ~T};
+struct Recbox<T: Copy> {x: ~T}
 
-fn reclift<T: Copy>(t: T) -> recbox<T> { return {x: ~t}; }
+fn reclift<T: Copy>(t: T) -> Recbox<T> { return Recbox {x: ~t}; }
 
 fn main() {
     let foo: int = 17;
-    let rbfoo: recbox<int> = reclift::<int>(foo);
+    let rbfoo: Recbox<int> = reclift::<int>(foo);
     assert (*rbfoo.x == foo);
 }
diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
index fadc501d869..13ed32e0c2d 100644
--- a/src/test/run-pass/generic-fn.rs
+++ b/src/test/run-pass/generic-fn.rs
@@ -14,22 +14,22 @@
 // -*- rust -*-
 fn id<T: Copy>(x: T) -> T { return x; }
 
-type triple = {x: int, y: int, z: int};
+struct Triple {x: int, y: int, z: int}
 
 fn main() {
     let mut x = 62;
     let mut y = 63;
     let a = 'a';
     let mut b = 'b';
-    let p: triple = {x: 65, y: 66, z: 67};
-    let mut q: triple = {x: 68, y: 69, z: 70};
+    let p: Triple = Triple {x: 65, y: 66, z: 67};
+    let mut q: Triple = Triple {x: 68, y: 69, z: 70};
     y = id::<int>(x);
     log(debug, y);
     assert (x == y);
     b = id::<char>(a);
     log(debug, b);
     assert (a == b);
-    q = id::<triple>(p);
+    q = id::<Triple>(p);
     x = p.z;
     y = q.z;
     log(debug, y);
diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs
index 0f41be3e6fc..9fd5f4fadff 100644
--- a/src/test/run-pass/generic-tag-values.rs
+++ b/src/test/run-pass/generic-tag-values.rs
@@ -14,10 +14,12 @@
 // -*- rust -*-
 enum noption<T> { some(T), }
 
+struct Pair { x: int, y: int }
+
 fn main() {
     let nop: noption<int> = some::<int>(5);
     match nop { some::<int>(n) => { log(debug, n); assert (n == 5); } }
-    let nop2: noption<{x: int, y: int}> = some({x: 17, y: 42});
+    let nop2: noption<Pair> = some(Pair{x: 17, y: 42});
     match nop2 {
       some(t) => {
         log(debug, t.x);
diff --git a/src/test/run-pass/generic-type.rs b/src/test/run-pass/generic-type.rs
index bf006b4ff58..e0f6363eb6b 100644
--- a/src/test/run-pass/generic-type.rs
+++ b/src/test/run-pass/generic-type.rs
@@ -10,10 +10,10 @@
 
 
 
-type pair<T> = {x: T, y: T};
+struct Pair<T> {x: T, y: T}
 
 fn main() {
-    let x: pair<int> = {x: 10, y: 12};
+    let x: Pair<int> = Pair {x: 10, y: 12};
     assert (x.x == 10);
     assert (x.y == 12);
 }
diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs
index d6296fff2f4..01e899db23a 100644
--- a/src/test/run-pass/generic-unique.rs
+++ b/src/test/run-pass/generic-unique.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Triple<T> { x: T, y: T, z: T }
 
-fn box<T: Copy>(x: {x: T, y: T, z: T}) -> ~{x: T, y: T, z: T} { return ~x; }
+fn box<T: Copy>(x: Triple<T>) -> ~Triple<T> { return ~x; }
 
 fn main() {
-    let x: ~{x: int, y: int, z: int} = box::<int>({x: 1, y: 2, z: 3});
+    let x: ~Triple<int> = box::<int>(Triple{x: 1, y: 2, z: 3});
     assert (x.y == 2);
 }
diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs
index 628cbe9b7cc..2ba0660cc70 100644
--- a/src/test/run-pass/guards.rs
+++ b/src/test/run-pass/guards.rs
@@ -8,16 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Pair { x: int, y: int }
+
 fn main() {
     let a =
         match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } };
     assert (a == 2);
 
     let b =
-        match {x: 10, y: 20} {
+        match Pair {x: 10, y: 20} {
           x if x.x < 5 && x.y < 5 => { 1 }
-          {x: x, y: y} if x == 10 && y == 20 => { 2 }
-          {x: x, y: y} => { 3 }
+          Pair {x: x, y: y} if x == 10 && y == 20 => { 2 }
+          Pair {x: x, y: y} => { 3 }
         };
     assert (b == 2);
 }
diff --git a/src/test/run-pass/infer-with-expected.rs b/src/test/run-pass/infer-with-expected.rs
index de1ecd38316..c87987aac3a 100644
--- a/src/test/run-pass/infer-with-expected.rs
+++ b/src/test/run-pass/infer-with-expected.rs
@@ -13,10 +13,13 @@
 // type must be known in this context' if the passing down doesn't
 // happen.)
 
-fn eat_tup(_r: ~@(int, fn@({x: int, y: int}) -> int)) {}
-fn eat_rec(_r: @~{a: int, b: fn@({x: int, y: int}) -> int}) {}
+fn eat_tup(_r: ~@(int, fn@(Pair) -> int)) {}
+fn eat_rec(_r: @~Rec) {}
+
+struct Rec { a: int, b: fn(Pair) -> int }
+struct Pair { x: int, y: int }
 
 fn main() {
     eat_tup(~@(10, |a| a.x ));
-    eat_rec(@~{a: 10, b: |a| a.x });
+    eat_rec(@~Rec{a: 10, b: |a| a.x });
 }
diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs
index 1e5342fca3b..11efd61072c 100644
--- a/src/test/run-pass/init-res-into-things.rs
+++ b/src/test/run-pass/init-res-into-things.rs
@@ -15,6 +15,8 @@ struct r {
   i: @mut int,
 }
 
+struct Box { x: r }
+
 impl r : Drop {
     fn finalize(&self) {
         *(self.i) = *(self.i) + 1;
@@ -38,7 +40,7 @@ fn test_box() {
 fn test_rec() {
     let i = @mut 0;
     {
-        let a = move {x: r(i)};
+        let a = move Box {x: r(i)};
     }
     assert *i == 1;
 }
@@ -74,7 +76,7 @@ fn test_unique() {
 fn test_box_rec() {
     let i = @mut 0;
     {
-        let a = move @{
+        let a = move @Box {
             x: r(i)
         };
     }
diff --git a/src/test/run-pass/instantiable.rs b/src/test/run-pass/instantiable.rs
index c98d321a9fc..57065ec44a5 100644
--- a/src/test/run-pass/instantiable.rs
+++ b/src/test/run-pass/instantiable.rs
@@ -11,9 +11,11 @@
 
 // check that we do not report a type like this as uninstantiable,
 // even though it would be if the nxt field had type @foo:
-enum foo = {x: uint, nxt: *foo};
+enum foo = X;
+
+struct X { x: uint, nxt: *foo }
 
 fn main() {
-    let x = foo({x: 0u, nxt: ptr::null()});
+    let x = foo(X {x: 0, nxt: ptr::null()});
 }
 
diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs
index 8eca57eacbf..a29d6d1e3e4 100644
--- a/src/test/run-pass/issue-1112.rs
+++ b/src/test/run-pass/issue-1112.rs
@@ -11,7 +11,7 @@
 // Issue #1112
 // Alignment of interior pointers to dynamic-size types
 
-type x<T> = {
+struct X<T> {
     a: T,
     b: u8,
     c: bool,
@@ -19,10 +19,10 @@ type x<T> = {
     e: u16,
     f: u8,
     g: u8
-};
+}
 
 fn main() {
-    let x: x<int> = {
+    let x: X<int> = X {
         a: 12345678,
         b: 9u8,
         c: true,
@@ -34,7 +34,7 @@ fn main() {
     bar(x);
 }
 
-fn bar<T>(x: x<T>) {
+fn bar<T>(x: X<T>) {
     assert x.b == 9u8;
     assert x.c == true;
     assert x.d == 10u8;
diff --git a/src/test/run-pass/issue-1989.rs b/src/test/run-pass/issue-1989.rs
index 9c2a6f9f30e..ab0e0aa1aba 100644
--- a/src/test/run-pass/issue-1989.rs
+++ b/src/test/run-pass/issue-1989.rs
@@ -12,16 +12,16 @@
 
 enum maybe_pointy {
     none,
-    p(@pointy)
+    p(@Pointy)
 }
 
-type pointy = {
+struct Pointy {
     mut a : maybe_pointy,
     mut f : fn@()->(),
-};
+}
 
-fn empty_pointy() -> @pointy {
-    return @{
+fn empty_pointy() -> @Pointy {
+    return @Pointy{
         mut a : none,
         mut f : fn@()->(){},
     }
diff --git a/src/test/run-pass/issue-2463.rs b/src/test/run-pass/issue-2463.rs
index 9ac1a886168..b787677db68 100644
--- a/src/test/run-pass/issue-2463.rs
+++ b/src/test/run-pass/issue-2463.rs
@@ -8,20 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Pair { f: int, g: int }
+
 fn main() {
 
-    let x = {
+    let x = Pair {
         f: 0,
         g: 0,
     };
 
-    let y = {
+    let y = Pair {
         f: 1,
         g: 1,
         .. x
     };
 
-    let z = {
+    let z = Pair {
         f: 1,
         .. x
     };
diff --git a/src/test/run-pass/issue-2633.rs b/src/test/run-pass/issue-2633.rs
index 103ae4fe8c4..e209a9a03ed 100644
--- a/src/test/run-pass/issue-2633.rs
+++ b/src/test/run-pass/issue-2633.rs
@@ -18,14 +18,14 @@ fn cat() -> cat {
     }
 }
 
-type kitty_info = {kitty: cat};
+struct KittyInfo {kitty: cat}
 
 // Code compiles and runs successfully if we add a + before the first arg
-fn nyan(kitty: cat, _kitty_info: kitty_info) {
+fn nyan(kitty: cat, _kitty_info: KittyInfo) {
     (kitty.meow)();
 }
 
 fn main() {
     let mut kitty = cat();
-    nyan(copy kitty, {kitty: copy kitty});
+    nyan(copy kitty, KittyInfo {kitty: copy kitty});
 }
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index cc3b3d62332..f8f2fc461c3 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -14,6 +14,12 @@
 pub mod pipes {
     use core::cast::{forget, transmute};
 
+    pub struct Stuff<T> {
+        mut state: state,
+        mut blocked_task: Option<task::Task>,
+        mut payload: Option<T>
+    }
+
     pub enum state {
         empty,
         full,
@@ -36,7 +42,7 @@ pub mod pipes {
 
     pub fn packet<T: Owned>() -> *packet<T> {
         unsafe {
-            let p: *packet<T> = cast::transmute(~{
+            let p: *packet<T> = cast::transmute(~Stuff{
                 mut state: empty,
                 mut blocked_task: None::<task::Task>,
                 mut payload: None::<T>
diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs
index 20efa7af487..d77a0817b82 100644
--- a/src/test/run-pass/issue-2989.rs
+++ b/src/test/run-pass/issue-2989.rs
@@ -22,7 +22,7 @@ impl (): methods {
 
 // the position of this function is significant! - if it comes before methods
 // then it works, if it comes after it then it doesnt!
-fn to_bools(bitv: {storage: ~[u64]}) -> ~[bool] {
+fn to_bools(bitv: Storage) -> ~[bool] {
     vec::from_fn(8, |i| {
         let w = i / 64;
         let b = i % 64;
@@ -31,9 +31,11 @@ fn to_bools(bitv: {storage: ~[u64]}) -> ~[bool] {
     })
 }
 
+struct Storage { storage: ~[u64] }
+
 fn main() {
     let bools = ~[false, false, true, false, false, true, true, false];
-    let bools2 = to_bools({storage: ~[0b01100100]});
+    let bools2 = to_bools(Storage{storage: ~[0b01100100]});
 
     for uint::range(0, 8) |i| {
         io::println(fmt!("%u => %u vs %u", i, bools[i] as uint, bools2[i] as uint));
diff --git a/src/test/run-pass/issue-980.rs b/src/test/run-pass/issue-980.rs
index 050f5697321..f29231b53d0 100644
--- a/src/test/run-pass/issue-980.rs
+++ b/src/test/run-pass/issue-980.rs
@@ -10,14 +10,14 @@
 
 enum maybe_pointy {
     no_pointy,
-    yes_pointy(@pointy),
+    yes_pointy(@Pointy),
 }
 
-type pointy = {
+struct Pointy {
     mut x : maybe_pointy
-};
+}
 
 fn main() {
-    let m = @{ mut x : no_pointy };
+    let m = @Pointy { mut x : no_pointy };
     m.x = yes_pointy(m);
 }
diff --git a/src/test/run-pass/lambda-infer-unresolved.rs b/src/test/run-pass/lambda-infer-unresolved.rs
index ed0efa0e4bd..1e94f6af90f 100644
--- a/src/test/run-pass/lambda-infer-unresolved.rs
+++ b/src/test/run-pass/lambda-infer-unresolved.rs
@@ -10,8 +10,12 @@
 
 // This should typecheck even though the type of e is not fully
 // resolved when we finish typechecking the fn@.
+
+
+struct Refs { mut refs: ~[int], n: int }
+
 fn main() {
-    let e = @{mut refs: ~[], n: 0};
+    let e = @Refs{mut refs: ~[], n: 0};
     let f = fn@ () { log(error, e.n); };
     e.refs += ~[1];
 }
diff --git a/src/test/run-pass/large-records.rs b/src/test/run-pass/large-records.rs
index a45fe552d1a..21b68a07560 100644
--- a/src/test/run-pass/large-records.rs
+++ b/src/test/run-pass/large-records.rs
@@ -12,9 +12,8 @@
 
 
 // -*- rust -*-
-fn f() {
-    let foo:
-            {a: int,
+
+struct Large {a: int,
              b: int,
              c: int,
              d: int,
@@ -25,8 +24,10 @@ fn f() {
              i: int,
              j: int,
              k: int,
-             l: int} =
-        {a: 0,
+             l: int}
+fn f() {
+    let foo: Large =
+        Large {a: 0,
          b: 0,
          c: 0,
          d: 0,
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index c7bfe2b6b8f..ee08b18de16 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -10,9 +10,11 @@
 
 // Make sure #1399 stays fixed
 
+struct A { a: ~int }
+
 fn foo() -> fn@() -> int {
     let k = ~22;
-    let _u = {a: copy k};
+    let _u = A {a: copy k};
     return fn@(move k) -> int { 22 };
 }
 
diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs
index e9028e5d3f9..885b3a83da6 100644
--- a/src/test/run-pass/last-use-is-capture.rs
+++ b/src/test/run-pass/last-use-is-capture.rs
@@ -10,9 +10,11 @@
 
 // Make sure #1399 stays fixed
 
+struct A { a: ~int }
+
 fn main() {
     fn invoke(f: fn@()) { f(); }
     let k = ~22;
-    let _u = {a: copy k};
+    let _u = A {a: copy k};
     invoke(|| log(error, copy k) )
 }
diff --git a/src/test/run-pass/let-destruct-fresh-mem.rs b/src/test/run-pass/let-destruct-fresh-mem.rs
index 4e0e8376f6a..ba7fd4fee5e 100644
--- a/src/test/run-pass/let-destruct-fresh-mem.rs
+++ b/src/test/run-pass/let-destruct-fresh-mem.rs
@@ -8,9 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct X { x: int, y: @A }
+struct A { a: int }
+
 fn main() {
-    let u = {x: 10, y: @{a: 20}};
-    let mut {x: x, y: @{a: a}} = u;
+    let u = X {x: 10, y: @A {a: 20}};
+    let mut X {x: x, y: @A {a: a}} = u;
     x = 100;
     a = 100;
     assert (x == 100);
diff --git a/src/test/run-pass/let-destruct.rs b/src/test/run-pass/let-destruct.rs
index 6c3a84e616f..be9c8bdf2d6 100644
--- a/src/test/run-pass/let-destruct.rs
+++ b/src/test/run-pass/let-destruct.rs
@@ -10,7 +10,9 @@
 
 enum xx = int;
 
+struct X { x: xx, y: int }
+
 fn main() {
-    let @{x: xx(x), y: y} = @{x: xx(10), y: 20};
+    let @X {x: xx(x), y: y} = @X{x: xx(10), y: 20};
     assert (x + y == 30);
 }
diff --git a/src/test/run-pass/log-linearized.rs b/src/test/run-pass/log-linearized.rs
index 0378a8648a1..73e16085c4e 100644
--- a/src/test/run-pass/log-linearized.rs
+++ b/src/test/run-pass/log-linearized.rs
@@ -15,11 +15,13 @@ enum option<T> {
     some(T),
 }
 
-type smallintmap<T> = @{mut v: ~[mut option<T>]};
+struct Smallintmap<T> {mut v: ~[mut option<T>]}
 
-fn mk<T>() -> smallintmap<T> {
+struct V<T> { v: ~[mut option<T>] }
+
+fn mk<T>() -> @Smallintmap<T> {
     let v: ~[mut option<T>] = ~[mut];
-    return @{mut v: move v};
+    return @Smallintmap {mut v: move v};
 }
 
 fn f<T,U>() {
diff --git a/src/test/run-pass/morestack4.rs b/src/test/run-pass/morestack4.rs
index 44309bbcaec..35b2993ca33 100644
--- a/src/test/run-pass/morestack4.rs
+++ b/src/test/run-pass/morestack4.rs
@@ -11,7 +11,7 @@
 // This is testing for stack frames greater than 256 bytes,
 // for which function prologues are generated differently
 
-type biggy = {
+struct Biggy {
     a00: u64,
     a01: u64,
     a02: u64,
@@ -52,17 +52,17 @@ type biggy = {
     a37: u64,
     a38: u64,
     a39: u64,
-};
+}
 
 
-fn getbig(i: biggy) {
+fn getbig(i: Biggy) {
     if i.a00 != 0u64 {
-        getbig({a00: i.a00 - 1u64,.. i});
+        getbig(Biggy{a00: i.a00 - 1u64,.. i});
     }
 }
 
 fn main() {
-    getbig({
+    getbig(Biggy {
         a00: 10000u64,
         a01: 10000u64,
         a02: 10000u64,
diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs
index b99b8a67a2c..e477442376e 100644
--- a/src/test/run-pass/move-1-unique.rs
+++ b/src/test/run-pass/move-1-unique.rs
@@ -8,16 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Triple { x: int, y: int, z: int }
 
-fn test(x: bool, foo: ~{x: int, y: int, z: int}) -> int {
+fn test(x: bool, foo: ~Triple) -> int {
     let bar = foo;
-    let mut y: ~{x: int, y: int, z: int};
-    if x { y = move bar; } else { y = ~{x: 4, y: 5, z: 6}; }
+    let mut y: ~Triple;
+    if x { y = move bar; } else { y = ~Triple{x: 4, y: 5, z: 6}; }
     return y.y;
 }
 
 fn main() {
-    let x = ~{x: 1, y: 2, z: 3};
+    let x = ~Triple{x: 1, y: 2, z: 3};
     assert (test(true, x) == 2);
     assert (test(true, x) == 2);
     assert (test(true, x) == 2);
diff --git a/src/test/run-pass/move-1.rs b/src/test/run-pass/move-1.rs
index 191d4e1c7d7..4c7e5682a13 100644
--- a/src/test/run-pass/move-1.rs
+++ b/src/test/run-pass/move-1.rs
@@ -8,15 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn test(x: bool, foo: @{x: int, y: int, z: int}) -> int {
+struct Triple { x: int, y: int, z: int }
+
+fn test(x: bool, foo: @Triple) -> int {
     let bar = foo;
-    let mut y: @{x: int, y: int, z: int};
-    if x { y = move bar; } else { y = @{x: 4, y: 5, z: 6}; }
+    let mut y: @Triple;
+    if x { y = move bar; } else { y = @Triple{x: 4, y: 5, z: 6}; }
     return y.y;
 }
 
 fn main() {
-    let x = @{x: 1, y: 2, z: 3};
+    let x = @Triple {x: 1, y: 2, z: 3};
     assert (test(true, x) == 2);
     assert (test(true, x) == 2);
     assert (test(true, x) == 2);
diff --git a/src/test/run-pass/move-2-unique.rs b/src/test/run-pass/move-2-unique.rs
index 8ed113e0983..096daf315eb 100644
--- a/src/test/run-pass/move-2-unique.rs
+++ b/src/test/run-pass/move-2-unique.rs
@@ -9,5 +9,6 @@
 // except according to those terms.
 
 
+struct X { x: int, y: int, z: int }
 
-fn main() { let x = ~{x: 1, y: 2, z: 3}; let y = move x; assert (y.y == 2); }
+fn main() { let x = ~X{x: 1, y: 2, z: 3}; let y = move x; assert (y.y == 2); }
diff --git a/src/test/run-pass/move-2.rs b/src/test/run-pass/move-2.rs
index da7d23ebddc..23746c924ad 100644
--- a/src/test/run-pass/move-2.rs
+++ b/src/test/run-pass/move-2.rs
@@ -9,5 +9,6 @@
 // except according to those terms.
 
 
+struct X { x: int, y: int, z: int }
 
-fn main() { let x = @{x: 1, y: 2, z: 3}; let y = move x; assert (y.y == 2); }
+fn main() { let x = @X {x: 1, y: 2, z: 3}; let y = move x; assert (y.y == 2); }
diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs
index 9fd122060cc..e16955f31e8 100644
--- a/src/test/run-pass/move-3-unique.rs
+++ b/src/test/run-pass/move-3-unique.rs
@@ -10,15 +10,17 @@
 
 extern mod std;
 
-fn test(x: bool, foo: ~{x: int, y: int, z: int}) -> int {
+struct Triple { x: int, y: int, z: int }
+
+fn test(x: bool, foo: ~Triple) -> int {
     let bar = foo;
-    let mut y: ~{x: int, y: int, z: int};
-    if x { y = move bar; } else { y = ~{x: 4, y: 5, z: 6}; }
+    let mut y: ~Triple;
+    if x { y = move bar; } else { y = ~Triple {x: 4, y: 5, z: 6}; }
     return y.y;
 }
 
 fn main() {
-    let x = ~{x: 1, y: 2, z: 3};
+    let x = ~Triple{x: 1, y: 2, z: 3};
     for uint::range(0u, 10000u) |_i| {
         assert (test(true, x) == 2);
     }
diff --git a/src/test/run-pass/move-3.rs b/src/test/run-pass/move-3.rs
index 9ecb6d28dd5..80de11091ee 100644
--- a/src/test/run-pass/move-3.rs
+++ b/src/test/run-pass/move-3.rs
@@ -10,15 +10,17 @@
 
 extern mod std;
 
-fn test(x: bool, foo: @{x: int, y: int, z: int}) -> int {
+struct Triple { x: int, y: int, z: int }
+
+fn test(x: bool, foo: @Triple) -> int {
     let bar = foo;
-    let mut y: @{x: int, y: int, z: int};
-    if x { y = move bar; } else { y = @{x: 4, y: 5, z: 6}; }
+    let mut y: @Triple;
+    if x { y = move bar; } else { y = @Triple{x: 4, y: 5, z: 6}; }
     return y.y;
 }
 
 fn main() {
-    let x = @{x: 1, y: 2, z: 3};
+    let x = @Triple{x: 1, y: 2, z: 3};
     for uint::range(0u, 10000u) |i| {
         assert (test(true, x) == 2);
     }
diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs
index 9608f3e08f7..0c2ce79e6aa 100644
--- a/src/test/run-pass/move-4-unique.rs
+++ b/src/test/run-pass/move-4-unique.rs
@@ -10,7 +10,9 @@
 
 extern mod std;
 
-fn test(foo: ~{a: int, b: int, c: int}) -> ~{a: int, b: int, c: int} {
+struct Triple {a: int, b: int, c: int}
+
+fn test(foo: ~Triple) -> ~Triple {
     let foo = foo;
     let bar = move foo;
     let baz = move bar;
@@ -18,4 +20,4 @@ fn test(foo: ~{a: int, b: int, c: int}) -> ~{a: int, b: int, c: int} {
     return quux;
 }
 
-fn main() { let x = ~{a: 1, b: 2, c: 3}; let y = test(x); assert (y.c == 3); }
+fn main() { let x = ~Triple{a: 1, b: 2, c: 3}; let y = test(x); assert (y.c == 3); }
diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs
index 5545bc96a3d..351b78807b8 100644
--- a/src/test/run-pass/move-4.rs
+++ b/src/test/run-pass/move-4.rs
@@ -11,7 +11,9 @@
 
 extern mod std;
 
-fn test(foo: @{a: int, b: int, c: int}) -> @{a: int, b: int, c: int} {
+struct Triple { a: int, b: int, c: int }
+
+fn test(foo: @Triple) -> @Triple {
     let foo = foo;
     let bar = move foo;
     let baz = move bar;
@@ -19,4 +21,8 @@ fn test(foo: @{a: int, b: int, c: int}) -> @{a: int, b: int, c: int} {
     return quux;
 }
 
-fn main() { let x = @{a: 1, b: 2, c: 3}; let y = test(x); assert (y.c == 3); }
+fn main() {
+    let x = @Triple{a: 1, b: 2, c: 3};
+    let y = test(x);
+    assert (y.c == 3);
+}
diff --git a/src/test/run-pass/mutable-vec-drop.rs b/src/test/run-pass/mutable-vec-drop.rs
index 54bd9c69b79..f774e421348 100644
--- a/src/test/run-pass/mutable-vec-drop.rs
+++ b/src/test/run-pass/mutable-vec-drop.rs
@@ -9,8 +9,10 @@
 // except according to those terms.
 
 
+struct Pair { a: int, b: int}
+
 fn main() {
     // This just tests whether the vec leaks its members.
-    let pvec: ~[mut @{a: int, b: int}] =
-        ~[mut @{a: 1, b: 2}, @{a: 3, b: 4}, @{a: 5, b: 6}];
+    let pvec: ~[mut @Pair] =
+        ~[mut @Pair{a: 1, b: 2}, @Pair{a: 3, b: 4}, @Pair{a: 5, b: 6}];
 }
diff --git a/src/test/run-pass/nested-exhaustive-alt.rs b/src/test/run-pass/nested-exhaustive-alt.rs
index b110bb6a604..c6eb91c564d 100644
--- a/src/test/run-pass/nested-exhaustive-alt.rs
+++ b/src/test/run-pass/nested-exhaustive-alt.rs
@@ -8,11 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Foo { foo: bool, bar: Option<int>, baz: int }
+
 fn main() {
-    match @{foo: true, bar: Some(10), baz: 20} {
-      @{foo: true, bar: Some(_), _} => {}
-      @{foo: false, bar: None, _} => {}
-      @{foo: true, bar: None, _} => {}
-      @{foo: false, bar: Some(_), _} => {}
+    match @Foo{foo: true, bar: Some(10), baz: 20} {
+      @Foo{foo: true, bar: Some(_), _} => {}
+      @Foo{foo: false, bar: None, _} => {}
+      @Foo{foo: true, bar: None, _} => {}
+      @Foo{foo: false, bar: Some(_), _} => {}
     }
 }
diff --git a/src/test/run-pass/nested-patterns.rs b/src/test/run-pass/nested-patterns.rs
index 17e0fdd5610..06d630255c0 100644
--- a/src/test/run-pass/nested-patterns.rs
+++ b/src/test/run-pass/nested-patterns.rs
@@ -8,15 +8,20 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct A { a: int, b: @int }
+struct B { a: int, b: C }
+struct D { a: int, d: C }
+struct C { mut c: int }
+
 fn main() {
-    match {a: 10, b: @20} {
-        x@{a, b: @20} => { assert x.a == 10; assert a == 10; }
-        {b, _} => { fail; }
+    match A {a: 10, b: @20} {
+        x@A {a, b: @20} => { assert x.a == 10; assert a == 10; }
+        A {b, _} => { fail; }
     }
-    let x@{b, _} = {a: 10, b: {mut c: 20}};
+    let x@B {b, _} = B {a: 10, b: C {mut c: 20}};
     x.b.c = 30;
     assert b.c == 20;
-    let y@{d, _} = {a: 10, d: {mut c: 20}};
+    let y@D {d, _} = D {a: 10, d: C {mut c: 20}};
     y.d.c = 30;
     assert d.c == 20;
 }
diff --git a/src/test/run-pass/newtype.rs b/src/test/run-pass/newtype.rs
index aaf7d1d3bbb..cb781ae6a99 100644
--- a/src/test/run-pass/newtype.rs
+++ b/src/test/run-pass/newtype.rs
@@ -8,11 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-enum mytype = {compute: extern fn(mytype) -> int, val: int};
+enum mytype = Mytype;
+
+struct Mytype {compute: extern fn(mytype) -> int, val: int}
 
 fn compute(i: mytype) -> int { return i.val + 20; }
 
 fn main() {
-    let myval = mytype({compute: compute, val: 30});
+    let myval = mytype(Mytype{compute: compute, val: 30});
     assert ((myval.compute)(myval) == 50);
 }
diff --git a/src/test/run-pass/output-slot-variants.rs b/src/test/run-pass/output-slot-variants.rs
index 0a0f8ec7114..3667a980251 100644
--- a/src/test/run-pass/output-slot-variants.rs
+++ b/src/test/run-pass/output-slot-variants.rs
@@ -8,27 +8,28 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
+struct A { a: int, b: int }
+struct Abox { a: @int, b: @int }
 
 fn ret_int_i() -> int { return 10; }
 
 fn ret_ext_i() -> @int { return @10; }
 
-fn ret_int_rec() -> {a: int, b: int} { return {a: 10, b: 10}; }
+fn ret_int_rec() -> A { return A {a: 10, b: 10}; }
 
-fn ret_ext_rec() -> @{a: int, b: int} { return @{a: 10, b: 10}; }
+fn ret_ext_rec() -> @A { return @A {a: 10, b: 10}; }
 
-fn ret_ext_mem() -> {a: @int, b: @int} { return {a: @10, b: @10}; }
+fn ret_ext_mem() -> Abox { return Abox {a: @10, b: @10}; }
 
-fn ret_ext_ext_mem() -> @{a: @int, b: @int} { return @{a: @10, b: @10}; }
+fn ret_ext_ext_mem() -> @Abox { return @Abox{a: @10, b: @10}; }
 
 fn main() {
     let mut int_i: int;
     let mut ext_i: @int;
-    let mut int_rec: {a: int, b: int};
-    let mut ext_rec: @{a: int, b: int};
-    let mut ext_mem: {a: @int, b: @int};
-    let mut ext_ext_mem: @{a: @int, b: @int};
+    let mut int_rec: A;
+    let mut ext_rec: @A;
+    let mut ext_mem: Abox;
+    let mut ext_ext_mem: @Abox;
     int_i = ret_int_i(); // initializing
 
     int_i = ret_int_i(); // non-initializing
diff --git a/src/test/run-pass/pass-by-copy.rs b/src/test/run-pass/pass-by-copy.rs
index ea16f005c6b..2821ab3e3eb 100644
--- a/src/test/run-pass/pass-by-copy.rs
+++ b/src/test/run-pass/pass-by-copy.rs
@@ -8,11 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn magic(+x: {a: @int}) { log(debug, x); }
+fn magic(+x: A) { log(debug, x); }
 fn magic2(+x: @int) { log(debug, x); }
 
+struct A { a: @int }
+
 fn main() {
-    let a = {a: @10}, b = @10;
-    magic(a); magic({a: @20});
+    let a = A {a: @10}, b = @10;
+    magic(a); magic(A {a: @20});
     magic2(b); magic2(@20);
 }
diff --git a/src/test/run-pass/pure-fmt.rs b/src/test/run-pass/pure-fmt.rs
index f3801dcc96d..572720f5808 100644
--- a/src/test/run-pass/pure-fmt.rs
+++ b/src/test/run-pass/pure-fmt.rs
@@ -10,9 +10,12 @@
 
 // Testing that calling fmt! (via debug!) doesn't complain about impure borrows
 
+struct Big { b: @~str, c: uint, d: int, e: char,
+            f: float, g: bool }
+
 pure fn foo() {
-    let a = {
-        b: @"hi",
+    let a = Big {
+        b: @~"hi",
         c: 0,
         d: 1,
         e: 'a',
diff --git a/src/test/run-pass/pure-sum.rs b/src/test/run-pass/pure-sum.rs
index ad66bf6dafa..84792d52c13 100644
--- a/src/test/run-pass/pure-sum.rs
+++ b/src/test/run-pass/pure-sum.rs
@@ -29,7 +29,7 @@ pure fn sums_to_using_uniq(v: ~[int], sum: int) -> bool {
 }
 
 pure fn sums_to_using_rec(v: ~[int], sum: int) -> bool {
-    let mut i = 0u, sum0 = {f: 0};
+    let mut i = 0u, sum0 = F {f: 0};
     while i < v.len() {
         sum0.f += v[i];
         i += 1u;
@@ -37,8 +37,10 @@ pure fn sums_to_using_rec(v: ~[int], sum: int) -> bool {
     return sum0.f == sum;
 }
 
+struct F<T> { f: T }
+
 pure fn sums_to_using_uniq_rec(v: ~[int], sum: int) -> bool {
-    let mut i = 0u, sum0 = {f: ~mut 0};
+    let mut i = 0u, sum0 = F {f: ~mut 0};
     while i < v.len() {
         *sum0.f += v[i];
         i += 1u;
diff --git a/src/test/run-pass/readalias.rs b/src/test/run-pass/readalias.rs
index a81a3891644..5c3f77b994b 100644
--- a/src/test/run-pass/readalias.rs
+++ b/src/test/run-pass/readalias.rs
@@ -12,8 +12,8 @@
 
 
 // -*- rust -*-
-type point = {x: int, y: int, z: int};
+struct Point {x: int, y: int, z: int}
 
-fn f(p: point) { assert (p.z == 12); }
+fn f(p: Point) { assert (p.z == 12); }
 
-fn main() { let x: point = {x: 10, y: 11, z: 12}; f(x); }
+fn main() { let x: Point = Point {x: 10, y: 11, z: 12}; f(x); }
diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs
index d24b0888c44..11e2f79aa60 100644
--- a/src/test/run-pass/rec-align-u32.rs
+++ b/src/test/run-pass/rec-align-u32.rs
@@ -18,16 +18,16 @@ extern mod rusti {
 }
 
 // This is the type with the questionable alignment
-type inner = {
+struct Inner {
     c64: u32
-};
+}
 
 // This is the type that contains the type with the
 // questionable alignment, for testing
-type outer = {
+struct Outer {
     c8: u8,
-    t: inner
-};
+    t: Inner
+}
 
 
 #[cfg(target_arch = "x86")]
@@ -46,21 +46,21 @@ mod m {
 
 fn main() {
     unsafe {
-        let x = {c8: 22u8, t: {c64: 44u32}};
+        let x = Outer {c8: 22u8, t: Inner {c64: 44u32}};
 
         // Send it through the shape code
         let y = fmt!("%?", x);
 
-        debug!("align inner = %?", rusti::min_align_of::<inner>());
-        debug!("size outer = %?", sys::size_of::<outer>());
+        debug!("align inner = %?", rusti::min_align_of::<Inner>());
+        debug!("size outer = %?", sys::size_of::<Outer>());
         debug!("y = %s", y);
 
         // per clang/gcc the alignment of `inner` is 4 on x86.
-        assert rusti::min_align_of::<inner>() == m::align();
+        assert rusti::min_align_of::<Inner>() == m::align();
 
         // per clang/gcc the size of `outer` should be 12
         // because `inner`s alignment was 4.
-        assert sys::size_of::<outer>() == m::size();
+        assert sys::size_of::<Outer>() == m::size();
 
         assert y == ~"{c8: 22, t: {c64: 44}}";
     }
diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs
index dc9fa146ef9..5fdabdc360c 100644
--- a/src/test/run-pass/rec-align-u64.rs
+++ b/src/test/run-pass/rec-align-u64.rs
@@ -18,16 +18,16 @@ extern mod rusti {
 }
 
 // This is the type with the questionable alignment
-type inner = {
+struct Inner {
     c64: u64
-};
+}
 
 // This is the type that contains the type with the
 // questionable alignment, for testing
-type outer = {
+struct Outer {
     c8: u8,
-    t: inner
-};
+    t: Inner
+}
 
 
 #[cfg(target_os = "linux")]
@@ -63,21 +63,21 @@ mod m {
 
 fn main() {
     unsafe {
-        let x = {c8: 22u8, t: {c64: 44u64}};
+        let x = Outer {c8: 22u8, t: Inner {c64: 44u64}};
 
         // Send it through the shape code
         let y = fmt!("%?", x);
 
-        debug!("align inner = %?", rusti::min_align_of::<inner>());
-        debug!("size outer = %?", sys::size_of::<outer>());
+        debug!("align inner = %?", rusti::min_align_of::<Inner>());
+        debug!("size outer = %?", sys::size_of::<Outer>());
         debug!("y = %s", y);
 
-        // per clang/gcc the alignment of `inner` is 4 on x86.
-        assert rusti::min_align_of::<inner>() == m::m::align();
+        // per clang/gcc the alignment of `Inner` is 4 on x86.
+        assert rusti::min_align_of::<Inner>() == m::m::align();
 
-        // per clang/gcc the size of `outer` should be 12
-        // because `inner`s alignment was 4.
-        assert sys::size_of::<outer>() == m::m::size();
+        // per clang/gcc the size of `Outer` should be 12
+        // because `Inner`s alignment was 4.
+        assert sys::size_of::<Outer>() == m::m::size();
 
         assert y == ~"{c8: 22, t: {c64: 44}}";
     }
diff --git a/src/test/run-pass/rec-auto.rs b/src/test/run-pass/rec-auto.rs
index 8fab506a49e..05428879fd2 100644
--- a/src/test/run-pass/rec-auto.rs
+++ b/src/test/run-pass/rec-auto.rs
@@ -14,8 +14,11 @@
 // -*- rust -*-
 
 // Issue #50.
+
+struct X { foo: ~str, bar: ~str }
+
 fn main() {
-    let x = {foo: ~"hello", bar: ~"world"};
+    let x = X {foo: ~"hello", bar: ~"world"};
     log(debug, copy x.foo);
     log(debug, copy x.bar);
 }
diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs
index 317752d9d47..ca353455c13 100644
--- a/src/test/run-pass/rec-extend.rs
+++ b/src/test/run-pass/rec-extend.rs
@@ -12,12 +12,12 @@
 
 
 // -*- rust -*-
-type point = {x: int, y: int};
+struct Point {x: int, y: int}
 
 fn main() {
-    let origin: point = {x: 0, y: 0};
-    let right: point = {x: origin.x + 10,.. origin};
-    let up: point = {y: origin.y + 10,.. origin};
+    let origin: Point = Point {x: 0, y: 0};
+    let right: Point = Point {x: origin.x + 10,.. origin};
+    let up: Point = Point {y: origin.y + 10,.. origin};
     assert (origin.x == 0);
     assert (origin.y == 0);
     assert (right.x == 10);
diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs
index 254ce630338..8c20e4f342b 100644
--- a/src/test/run-pass/rec-tup.rs
+++ b/src/test/run-pass/rec-tup.rs
@@ -9,12 +9,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type point = {x: int, y: int};
+struct Point {x: int, y: int}
 
-type rect = (point, point);
+type rect = (Point, Point);
 
-fn fst(r: rect) -> point { let (fst, _) = r; return fst; }
-fn snd(r: rect) -> point { let (_, snd) = r; return snd; }
+fn fst(r: rect) -> Point { let (fst, _) = r; return fst; }
+fn snd(r: rect) -> Point { let (_, snd) = r; return snd; }
 
 fn f(r: rect, x1: int, y1: int, x2: int, y2: int) {
     assert (fst(r).x == x1);
@@ -24,7 +24,7 @@ fn f(r: rect, x1: int, y1: int, x2: int, y2: int) {
 }
 
 fn main() {
-    let r: rect = ({x: 10, y: 20}, {x: 11, y: 22});
+    let r: rect = (Point {x: 10, y: 20}, Point {x: 11, y: 22});
     assert (fst(r).x == 10);
     assert (fst(r).y == 20);
     assert (snd(r).x == 11);
diff --git a/src/test/run-pass/rec.rs b/src/test/run-pass/rec.rs
index 8b4f3780be0..6ff36355875 100644
--- a/src/test/run-pass/rec.rs
+++ b/src/test/run-pass/rec.rs
@@ -12,9 +12,9 @@
 
 
 // -*- rust -*-
-type rect = {x: int, y: int, w: int, h: int};
+struct Rect {x: int, y: int, w: int, h: int}
 
-fn f(r: rect, x: int, y: int, w: int, h: int) {
+fn f(r: Rect, x: int, y: int, w: int, h: int) {
     assert (r.x == x);
     assert (r.y == y);
     assert (r.w == w);
@@ -22,12 +22,12 @@ fn f(r: rect, x: int, y: int, w: int, h: int) {
 }
 
 fn main() {
-    let r: rect = {x: 10, y: 20, w: 100, h: 200};
+    let r: Rect = Rect {x: 10, y: 20, w: 100, h: 200};
     assert (r.x == 10);
     assert (r.y == 20);
     assert (r.w == 100);
     assert (r.h == 200);
-    let r2: rect = r;
+    let r2: Rect = r;
     let x: int = r2.x;
     assert (x == 10);
     f(r, 10, 20, 100, 200);
diff --git a/src/test/run-pass/record-pat.rs b/src/test/run-pass/record-pat.rs
index a88a1d1459c..026b9c93203 100644
--- a/src/test/run-pass/record-pat.rs
+++ b/src/test/run-pass/record-pat.rs
@@ -9,17 +9,17 @@
 // except according to those terms.
 
 enum t1 { a(int), b(uint), }
-type t2 = {x: t1, y: int};
-enum t3 { c(t2, uint), }
+struct T2 {x: t1, y: int}
+enum t3 { c(T2, uint), }
 
 fn m(in: t3) -> int {
     match in {
-      c({x: a(m), _}, _) => { return m; }
-      c({x: b(m), y: y}, z) => { return ((m + z) as int) + y; }
+      c(T2 {x: a(m), _}, _) => { return m; }
+      c(T2 {x: b(m), y: y}, z) => { return ((m + z) as int) + y; }
     }
 }
 
 fn main() {
-    assert (m(c({x: a(10), y: 5}, 4u)) == 10);
-    assert (m(c({x: b(10u), y: 5}, 4u)) == 19);
+    assert (m(c(T2 {x: a(10), y: 5}, 4u)) == 10);
+    assert (m(c(T2 {x: b(10u), y: 5}, 4u)) == 19);
 }
diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
index ff9e133fe15..d072df4d8e8 100644
--- a/src/test/run-pass/reflect-visit-data.rs
+++ b/src/test/run-pass/reflect-visit-data.rs
@@ -29,9 +29,7 @@ fn align(size: uint, align: uint) -> uint {
     ((size + align) - 1u) & !(align - 1u)
 }
 
-enum ptr_visit_adaptor<V: TyVisitor movable_ptr> = {
-    inner: V
-};
+enum ptr_visit_adaptor<V: TyVisitor movable_ptr> = Inner<V>;
 
 impl<V: TyVisitor movable_ptr> ptr_visit_adaptor<V> {
 
@@ -469,11 +467,13 @@ impl<V: TyVisitor movable_ptr> ptr_visit_adaptor<V>: TyVisitor {
     }
 }
 
-enum my_visitor = @{
+enum my_visitor = @Stuff;
+
+struct Stuff {
     mut ptr1: *c_void,
     mut ptr2: *c_void,
     mut vals: ~[~str]
-};
+}
 
 impl my_visitor {
     fn get<T>(f: fn(T)) {
@@ -485,13 +485,15 @@ impl my_visitor {
     fn visit_inner(inner: *TyDesc) -> bool {
         unsafe {
             let u = my_visitor(*self);
-            let v = ptr_visit_adaptor({inner: u});
+            let v = ptr_visit_adaptor::<my_visitor>(Inner {inner: u});
             visit_tydesc(inner, v as TyVisitor);
             true
         }
     }
 }
 
+struct Inner<V> { inner: V }
+
 impl my_visitor: movable_ptr {
     fn move_ptr(adjustment: fn(*c_void) -> *c_void) {
         self.ptr1 = adjustment(self.ptr1);
@@ -622,14 +624,16 @@ fn get_tydesc_for<T>(&&_t: T) -> *TyDesc {
     get_tydesc::<T>()
 }
 
+struct Triple { x: int, y: int, z: int }
+
 fn main() {
     unsafe {
-        let r = (1,2,3,true,false,{x:5,y:4,z:3});
+        let r = (1,2,3,true,false, Triple {x:5,y:4,z:3});
         let p = ptr::addr_of(&r) as *c_void;
-        let u = my_visitor(@{mut ptr1: p,
+        let u = my_visitor(@Stuff {mut ptr1: p,
                              mut ptr2: p,
                              mut vals: ~[]});
-        let v = ptr_visit_adaptor({inner: u});
+        let v = ptr_visit_adaptor(Inner {inner: u});
         let td = get_tydesc_for(r);
         unsafe { error!("tydesc sz: %u, align: %u",
                         (*td).size, (*td).align); }
diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs
index b8c0bfeb763..e1d54f33dcb 100644
--- a/src/test/run-pass/regions-infer-borrow-scope.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope.rs
@@ -8,14 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type point = {x: int, y: int};
+struct Point {x: int, y: int}
 
-fn x_coord(p: &r/point) -> &r/int {
+fn x_coord(p: &r/Point) -> &r/int {
     return &p.x;
 }
 
 fn main() {
-    let p = @{x: 3, y: 4};
+    let p = @Point {x: 3, y: 4};
     let xc = x_coord(p);
     assert *xc == 3;
 }
diff --git a/src/test/run-pass/regions-mock-trans-impls.rs b/src/test/run-pass/regions-mock-trans-impls.rs
index 0fd1b361b29..71bf0ac8269 100644
--- a/src/test/run-pass/regions-mock-trans-impls.rs
+++ b/src/test/run-pass/regions-mock-trans-impls.rs
@@ -14,36 +14,36 @@ extern mod std;
 use libc, sys, cast;
 use std::arena::Arena;
 
-type bcx = {
-    fcx: &fcx
-};
+struct Bcx {
+    fcx: &Fcx
+}
 
-type fcx = {
+struct Fcx {
     arena: &Arena,
-    ccx: &ccx
-};
+    ccx: &Ccx
+}
 
-type ccx = {
+struct Ccx {
     x: int
-};
+}
 
-fn h(bcx : &r/bcx) -> &r/bcx {
-    return bcx.fcx.arena.alloc(|| { fcx: bcx.fcx });
+fn h(bcx : &r/Bcx) -> &r/Bcx {
+    return bcx.fcx.arena.alloc(|| Bcx { fcx: bcx.fcx });
 }
 
-fn g(fcx : &fcx) {
-    let bcx = { fcx: fcx };
+fn g(fcx : &Fcx) {
+    let bcx = Bcx { fcx: fcx };
     h(&bcx);
 }
 
-fn f(ccx : &ccx) {
+fn f(ccx : &Ccx) {
     let a = Arena();
-    let fcx = &{ arena: &a, ccx: ccx };
+    let fcx = &Fcx { arena: &a, ccx: ccx };
     return g(fcx);
 }
 
 fn main() {
-    let ccx = { x: 0 };
+    let ccx = Ccx { x: 0 };
     f(&ccx);
 }
 
diff --git a/src/test/run-pass/regions-mock-trans.rs b/src/test/run-pass/regions-mock-trans.rs
index 09de1650027..2ef63af3be1 100644
--- a/src/test/run-pass/regions-mock-trans.rs
+++ b/src/test/run-pass/regions-mock-trans.rs
@@ -10,46 +10,46 @@
 
 enum arena = ();
 
-type bcx = {
-    fcx: &fcx
-};
+struct Bcx {
+    fcx: &Fcx
+}
 
-type fcx = {
+struct Fcx {
     arena: &arena,
-    ccx: &ccx
-};
+    ccx: &Ccx
+}
 
-type ccx = {
+struct Ccx {
     x: int
-};
+}
 
-fn alloc(_bcx : &arena) -> &bcx {   
+fn alloc(_bcx : &arena) -> &Bcx {   
     unsafe {
         return cast::reinterpret_cast(
-            &libc::malloc(sys::size_of::<bcx/&blk>() as libc::size_t));
+            &libc::malloc(sys::size_of::<Bcx/&blk>() as libc::size_t));
     }
 }
 
-fn h(bcx : &bcx) -> &bcx {
+fn h(bcx : &Bcx) -> &Bcx {
     return alloc(bcx.fcx.arena);
 }
 
-fn g(fcx : &fcx) {
-    let bcx = { fcx: fcx };
+fn g(fcx : &Fcx) {
+    let bcx = Bcx { fcx: fcx };
     let bcx2 = h(&bcx);
     unsafe {
         libc::free(cast::reinterpret_cast(&bcx2));
     }
 }
 
-fn f(ccx : &ccx) {
+fn f(ccx : &Ccx) {
     let a = arena(());
-    let fcx = { arena: &a, ccx: ccx };
+    let fcx = Fcx { arena: &a, ccx: ccx };
     return g(&fcx);
 }
 
 fn main() {
-    let ccx = { x: 0 };
+    let ccx = Ccx { x: 0 };
     f(&ccx);
 }
 
diff --git a/src/test/run-pass/regions-self-impls.rs b/src/test/run-pass/regions-self-impls.rs
index 9d1a37ce152..975d96dc420 100644
--- a/src/test/run-pass/regions-self-impls.rs
+++ b/src/test/run-pass/regions-self-impls.rs
@@ -8,18 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type clam = { chowder: &int };
+struct Clam { chowder: &int }
 
 trait get_chowder {
     fn get_chowder() -> &self/int;
 }
 
-impl clam: get_chowder {
+impl Clam: get_chowder {
     fn get_chowder() -> &self/int { return self.chowder; }
 }
 
 fn main() {
-    let clam = { chowder: &3 };
+    let clam = Clam { chowder: &3 };
     log(debug, *clam.get_chowder());
     clam.get_chowder();
 }
diff --git a/src/test/run-pass/regions-trait.rs b/src/test/run-pass/regions-trait.rs
index 356e0a6c9f2..575fefa9db5 100644
--- a/src/test/run-pass/regions-trait.rs
+++ b/src/test/run-pass/regions-trait.rs
@@ -8,16 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type ctxt = { v: uint };
+struct Ctxt { v: uint }
 
 trait get_ctxt {
-    fn get_ctxt() -> &self/ctxt;
+    fn get_ctxt() -> &self/Ctxt;
 }
 
-type has_ctxt = { c: &ctxt };
+struct HasCtxt { c: &Ctxt }
 
-impl has_ctxt: get_ctxt {
-    fn get_ctxt() -> &self/ctxt {
+impl HasCtxt: get_ctxt {
+    fn get_ctxt() -> &self/Ctxt {
         self.c
     }
 }
@@ -27,8 +27,8 @@ fn get_v(gc: get_ctxt) -> uint {
 }
 
 fn main() {
-    let ctxt = { v: 22u };
-    let hc = { c: &ctxt };
+    let ctxt = Ctxt { v: 22 };
+    let hc = HasCtxt { c: &ctxt };
 
-    assert get_v(hc as get_ctxt) == 22u;
+    assert get_v(hc as get_ctxt) == 22;
 }
diff --git a/src/test/run-pass/resource-cycle.rs b/src/test/run-pass/resource-cycle.rs
index 80aaad5c90f..f2926c5e1c5 100644
--- a/src/test/run-pass/resource-cycle.rs
+++ b/src/test/run-pass/resource-cycle.rs
@@ -34,10 +34,12 @@ fn r(v: *int) -> r {
     }
 }
 
-enum t = {
+enum t = Node;
+
+struct Node {
     mut next: Option<@t>,
     r: r
-};
+}
 
 fn main() {
     unsafe {
@@ -48,7 +50,7 @@ fn main() {
         let i2p = cast::reinterpret_cast(&i2);
         cast::forget(move i2);
 
-        let x1 = @t({
+        let x1 = @t(Node{
             mut next: None,
               r: {
               let rs = r(i1p);
@@ -61,7 +63,7 @@ fn main() {
             cast::reinterpret_cast::<@t, uint>(&x1),
             cast::reinterpret_cast::<*r, uint>(&ptr::addr_of(&(x1.r))));
 
-        let x2 = @t({
+        let x2 = @t(Node{
             mut next: None,
               r: {
               let rs = r(i2p);
diff --git a/src/test/run-pass/resource-cycle2.rs b/src/test/run-pass/resource-cycle2.rs
index 3a1f6d812a8..56ca229b055 100644
--- a/src/test/run-pass/resource-cycle2.rs
+++ b/src/test/run-pass/resource-cycle2.rs
@@ -10,14 +10,14 @@
 
 // Don't leak the unique pointers
 
-type u = {
+struct U {
     a: int,
     b: int,
     c: *int
-};
+}
 
 struct r {
-  v: u,
+  v: U,
 }
 
 impl r : Drop {
@@ -28,16 +28,18 @@ impl r : Drop {
     }
 }
 
-fn r(v: u) -> r {
+fn r(v: U) -> r {
     r {
         v: v
     }
 }
 
-enum t = {
+enum t = Node;
+
+struct Node {
     mut next: Option<@t>,
     r: r
-};
+}
 
 fn main() {
     unsafe {
@@ -48,14 +50,14 @@ fn main() {
         let i2p = cast::reinterpret_cast(&i2);
         cast::forget(move i2);
 
-        let u1 = {a: 0xB, b: 0xC, c: i1p};
-        let u2 = {a: 0xB, b: 0xC, c: i2p};
+        let u1 = U {a: 0xB, b: 0xC, c: i1p};
+        let u2 = U {a: 0xB, b: 0xC, c: i2p};
 
-        let x1 = @t({
+        let x1 = @t(Node {
             mut next: None,
             r: r(u1)
         });
-        let x2 = @t({
+        let x2 = @t(Node {
             mut next: None,
             r: r(u2)
         });
diff --git a/src/test/run-pass/resource-cycle3.rs b/src/test/run-pass/resource-cycle3.rs
index 7a4e9e6faf5..59a6d703c7c 100644
--- a/src/test/run-pass/resource-cycle3.rs
+++ b/src/test/run-pass/resource-cycle3.rs
@@ -12,19 +12,19 @@
 
 // Don't leak the unique pointers
 
-type u = {
+struct U {
     a: int,
     b: int,
     c: *int
-};
+}
 
-struct r {
-  v: u,
+struct R {
+  v: U,
   w: int,
   x: *int,
 }
 
-impl r : Drop {
+impl R : Drop {
     fn finalize(&self) {
         unsafe {
             let _v2: ~int = cast::reinterpret_cast(&self.v.c);
@@ -33,9 +33,9 @@ impl r : Drop {
     }
 }
 
-fn r(v: u, w: int, _x: *int) -> r {
+fn r(v: U, w: int, _x: *int) -> R {
     unsafe {
-        r {
+        R {
             v: v,
             w: w,
             x: cast::reinterpret_cast(&0)
@@ -43,10 +43,12 @@ fn r(v: u, w: int, _x: *int) -> r {
     }
 }
 
-enum t = {
+enum t = Node;
+
+struct Node {
     mut next: Option<@t>,
-    r: r
-};
+    r: R
+}
 
 fn main() { 
     unsafe {
@@ -57,14 +59,14 @@ fn main() {
         let i2p = cast::reinterpret_cast(&i2);
         cast::forget(move i2);
 
-        let u1 = {a: 0xB, b: 0xC, c: i1p};
-        let u2 = {a: 0xB, b: 0xC, c: i2p};
+        let u1 = U {a: 0xB, b: 0xC, c: i1p};
+        let u2 = U {a: 0xB, b: 0xC, c: i2p};
 
-        let x1 = @t({
+        let x1 = @t(Node{
             mut next: None,
             r: r(u1, 42, i1p)
         });
-        let x2 = @t({
+        let x2 = @t(Node{
             mut next: None,
             r: r(u2, 42, i2p)
         });
diff --git a/src/test/run-pass/resource-generic.rs b/src/test/run-pass/resource-generic.rs
index c96ee8ddce7..e528cd32974 100644
--- a/src/test/run-pass/resource-generic.rs
+++ b/src/test/run-pass/resource-generic.rs
@@ -11,8 +11,10 @@
 // xfail-fast
 #[legacy_modes];
 
+struct Arg<T> {val: T, fin: extern fn(T)}
+
 struct finish<T: Copy> {
-  arg: {val: T, fin: extern fn(T)},
+  arg: Arg<T>
 }
 
 impl<T: Copy> finish<T> : Drop {
@@ -21,7 +23,7 @@ impl<T: Copy> finish<T> : Drop {
     }
 }
 
-fn finish<T: Copy>(arg: {val: T, fin: extern fn(T)}) -> finish<T> {
+fn finish<T: Copy>(arg: Arg<T>) -> finish<T> {
     finish {
         arg: arg
     }
@@ -31,6 +33,6 @@ fn main() {
     let box = @mut 10;
     fn dec_box(&&i: @mut int) { *i -= 1; }
 
-    { let _i = move finish({val: box, fin: dec_box}); }
+    { let _i = move finish(Arg{val: box, fin: dec_box}); }
     assert (*box == 9);
 }
diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs
index 1ddeee336e3..2b43fca58b7 100644
--- a/src/test/run-pass/rt-circular-buffer.rs
+++ b/src/test/run-pass/rt-circular-buffer.rs
@@ -14,7 +14,7 @@
 // that has a size that is not a power of two
 
 // A 12-byte unit to ::core::oldcomm::send over the channel
-type record = {val1: u32, val2: u32, val3: u32};
+struct Record {val1: u32, val2: u32, val3: u32}
 
 
 // Assuming that the default buffer size needs to hold 8 units,
@@ -24,7 +24,7 @@ type record = {val1: u32, val2: u32, val3: u32};
 fn test_init() {
     let myport = ::core::oldcomm::Port();
     let mychan = ::core::oldcomm::Chan(&myport);
-    let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
+    let val: Record = Record {val1: 0u32, val2: 0u32, val3: 0u32};
     ::core::oldcomm::send(mychan, val);
 }
 
@@ -35,7 +35,7 @@ fn test_grow() {
     let myport = ::core::oldcomm::Port();
     let mychan = ::core::oldcomm::Chan(&myport);
     for uint::range(0u, 100u) |i| {
-        let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
+        let val: Record = Record {val1: 0u32, val2: 0u32, val3: 0u32};
         ::core::oldcomm::send(mychan, val);
     }
 }
@@ -53,7 +53,7 @@ fn test_shrink2() {
     let myport = ::core::oldcomm::Port();
     let mychan = ::core::oldcomm::Chan(&myport);
     for uint::range(0u, 100u) |_i| {
-        let val: record = {val1: 0u32, val2: 0u32, val3: 0u32};
+        let val: Record = Record {val1: 0u32, val2: 0u32, val3: 0u32};
         ::core::oldcomm::send(mychan, val);
     }
     for uint::range(0u, 100u) |_i| { let x = ::core::oldcomm::recv(myport); }
@@ -65,7 +65,7 @@ fn test_rotate() {
     let myport = ::core::oldcomm::Port();
     let mychan = ::core::oldcomm::Chan(&myport);
     for uint::range(0u, 100u) |i| {
-        let val = {val1: i as u32, val2: i as u32, val3: i as u32};
+        let val = Record {val1: i as u32, val2: i as u32, val3: i as u32};
         ::core::oldcomm::send(mychan, val);
         let x = ::core::oldcomm::recv(myport);
         assert (x.val1 == i as u32);
@@ -78,12 +78,12 @@ fn test_rotate() {
 // Test rotating and growing the buffer when
 // the unit size is not a power of two
 fn test_rotate_grow() {
-    let myport = ::core::oldcomm::Port::<record>();
+    let myport = ::core::oldcomm::Port::<Record>();
     let mychan = ::core::oldcomm::Chan(&myport);
     for uint::range(0u, 10u) |j| {
         for uint::range(0u, 10u) |i| {
-            let val: record =
-                {val1: i as u32, val2: i as u32, val3: i as u32};
+            let val: Record =
+                Record {val1: i as u32, val2: i as u32, val3: i as u32};
             ::core::oldcomm::send(mychan, val);
         }
         for uint::range(0u, 10u) |i| {
diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs
index 1a6cf7e04cc..44165119b0d 100644
--- a/src/test/run-pass/sendfn-generic-fn.rs
+++ b/src/test/run-pass/sendfn-generic-fn.rs
@@ -18,13 +18,13 @@ use oldcomm::send;
 
 fn main() { test05(); }
 
-type pair<A,B> = { a: A, b: B };
+struct Pair<A,B> { a: A, b: B }
 
-fn make_generic_record<A: Copy, B: Copy>(a: A, b: B) -> pair<A,B> {
-    return {a: a, b: b};
+fn make_generic_record<A: Copy, B: Copy>(a: A, b: B) -> Pair<A,B> {
+    return Pair {a: a, b: b};
 }
 
-fn test05_start(&&f: fn~(&&v: float, &&v: ~str) -> pair<float, ~str>) {
+fn test05_start(&&f: fn~(&&v: float, &&v: ~str) -> Pair<float, ~str>) {
     let p = f(22.22f, ~"Hi");
     log(debug, copy p);
     assert p.a == 22.22f;
@@ -36,8 +36,8 @@ fn test05_start(&&f: fn~(&&v: float, &&v: ~str) -> pair<float, ~str>) {
     assert q.b == ~"Ho";
 }
 
-fn spawn<A: Copy, B: Copy>(f: extern fn(fn~(A,B)->pair<A,B>)) {
-    let arg = fn~(a: A, b: B) -> pair<A,B> {
+fn spawn<A: Copy, B: Copy>(f: extern fn(fn~(A,B)->Pair<A,B>)) {
+    let arg = fn~(a: A, b: B) -> Pair<A,B> {
         return make_generic_record(a, b);
     };
     task::spawn(|| f(arg) );
diff --git a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
index 4139aedf881..53a09b385b3 100644
--- a/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
+++ b/src/test/run-pass/shape_intrinsic_tag_then_rec.rs
@@ -22,21 +22,23 @@ enum opt_span {
 
     //hack (as opposed to option), to make `span` compile
     os_none,
-    os_some(@span),
+    os_some(@Span),
 }
-type span = {lo: uint, hi: uint, expanded_from: opt_span};
-type spanned<T> = { data: T, span: span };
+struct Span {lo: uint, hi: uint, expanded_from: opt_span}
+struct Spanned<T> { data: T, span: Span }
 type ty_ = uint;
-type path_ = { global: bool, idents: ~[~str], types: ~[@ty] };
-type path = spanned<path_>;
-type ty = spanned<ty_>;
+struct Path_ { global: bool, idents: ~[~str], types: ~[@ty] }
+type path = Spanned<Path_>;
+type ty = Spanned<ty_>;
+
+struct X { sp: Span, path: path }
 
 fn main() {
-    let sp: span = {lo: 57451u, hi: 57542u, expanded_from: os_none};
-    let t: @ty = @{ data: 3u, span: sp };
-    let p_: path_ = { global: true, idents: ~[~"hi"], types: ~[t] };
-    let p: path = { data: p_, span: sp };
-    let x = { sp: sp, path: p };
+    let sp: Span = Span {lo: 57451u, hi: 57542u, expanded_from: os_none};
+    let t: @ty = @Spanned { data: 3u, span: sp };
+    let p_: Path_ = Path_ { global: true, idents: ~[~"hi"], types: ~[t] };
+    let p: path = Spanned { data: p_, span: sp };
+    let x = X { sp: sp, path: p };
     log(error, copy x.path);
     log(error, copy x);
 }
diff --git a/src/test/run-pass/struct-return.rs b/src/test/run-pass/struct-return.rs
index c4e38a1de2c..e09150eac76 100644
--- a/src/test/run-pass/struct-return.rs
+++ b/src/test/run-pass/struct-return.rs
@@ -8,19 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type quad = { a: u64, b: u64, c: u64, d: u64 };
-type floats = { a: f64, b: u8, c: f64 };
+struct Quad { a: u64, b: u64, c: u64, d: u64 }
+struct Floats { a: f64, b: u8, c: f64 }
 
 #[nolink]
 extern mod rustrt {
     #[legacy_exports];
-    fn debug_abi_1(++q: quad) -> quad;
-    fn debug_abi_2(++f: floats) -> floats;
+    fn debug_abi_1(++q: Quad) -> Quad;
+    fn debug_abi_2(++f: Floats) -> Floats;
 }
 
 fn test1() {
     unsafe {
-        let q = { a: 0xaaaa_aaaa_aaaa_aaaa_u64,
+        let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa_u64,
                  b: 0xbbbb_bbbb_bbbb_bbbb_u64,
                  c: 0xcccc_cccc_cccc_cccc_u64,
                  d: 0xdddd_dddd_dddd_dddd_u64 };
@@ -39,7 +39,7 @@ fn test1() {
 #[cfg(target_arch = "x86_64")]
 fn test2() {
     unsafe {
-        let f = { a: 1.234567890e-15_f64,
+        let f = Floats { a: 1.234567890e-15_f64,
                  b: 0b_1010_1010_u8,
                  c: 1.0987654321e-15_f64 };
         let ff = rustrt::debug_abi_2(f);
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index 76788731947..83e34ba84e1 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/src/test/run-pass/task-comm-16.rs
@@ -17,12 +17,12 @@ use pipes::Chan;
 
 // Tests of ports and channels on various types
 fn test_rec() {
-    type r = {val0: int, val1: u8, val2: char};
+    struct R {val0: int, val1: u8, val2: char}
 
     let (po, ch) = pipes::stream();
-    let r0: r = {val0: 0, val1: 1u8, val2: '2'};
+    let r0: R = R {val0: 0, val1: 1u8, val2: '2'};
     ch.send(r0);
-    let mut r1: r;
+    let mut r1: R;
     r1 = po.recv();
     assert (r1.val0 == 0);
     assert (r1.val1 == 1u8);
diff --git a/src/test/run-pass/trait-cast.rs b/src/test/run-pass/trait-cast.rs
index 96c51e98005..cbc093fcc19 100644
--- a/src/test/run-pass/trait-cast.rs
+++ b/src/test/run-pass/trait-cast.rs
@@ -10,12 +10,12 @@
 
 // Test cyclic detector when using trait instances.
 
-enum Tree = TreeR;
-type TreeR = @{
+enum Tree = @TreeR;
+struct TreeR {
     mut left: Option<Tree>,
     mut right: Option<Tree>,
     val: to_str
-};
+}
 
 trait to_str {
     fn to_str() -> ~str;
@@ -45,10 +45,10 @@ impl Tree: to_str {
 fn foo<T: to_str>(x: T) -> ~str { x.to_str() }
 
 fn main() {
-    let t1 = Tree(@{mut left: None,
+    let t1 = Tree(@TreeR{mut left: None,
                     mut right: None,
                     val: 1 as to_str });
-    let t2 = Tree(@{mut left: Some(t1),
+    let t2 = Tree(@TreeR{mut left: Some(t1),
                     mut right: Some(t1),
                     val: 2 as to_str });
     let expected = ~"[2, some([1, none, none]), some([1, none, none])]";
diff --git a/src/test/run-pass/type-namespace.rs b/src/test/run-pass/type-namespace.rs
index 866f4742f4e..4215a8597f2 100644
--- a/src/test/run-pass/type-namespace.rs
+++ b/src/test/run-pass/type-namespace.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type a = {a: int};
+struct A { a: int }
 
-fn a(a: a) -> int { return a.a; }
+fn a(a: A) -> int { return a.a; }
 
-fn main() { let x: a = {a: 1}; assert (a(x) == 1); }
+fn main() { let x: A = A {a: 1}; assert (a(x) == 1); }
diff --git a/src/test/run-pass/uniq-cc-generic.rs b/src/test/run-pass/uniq-cc-generic.rs
index b78c78ad9e9..b1cde5b2e85 100644
--- a/src/test/run-pass/uniq-cc-generic.rs
+++ b/src/test/run-pass/uniq-cc-generic.rs
@@ -10,20 +10,20 @@
 
 enum maybe_pointy {
     none,
-    p(@pointy),
+    p(@Pointy),
 }
 
-type pointy = {
+struct Pointy {
     mut a : maybe_pointy,
     d : fn~() -> uint,
-};
+}
 
 fn make_uniq_closure<A:Owned Copy>(a: A) -> fn~() -> uint {
     fn~() -> uint { ptr::addr_of(&a) as uint }
 }
 
-fn empty_pointy() -> @pointy {
-    return @{
+fn empty_pointy() -> @Pointy {
+    return @Pointy {
         mut a : none,
         d : make_uniq_closure(~"hi")
     }
diff --git a/src/test/run-pass/uniq-cc.rs b/src/test/run-pass/uniq-cc.rs
index 84a0dc212e5..deaf09a2392 100644
--- a/src/test/run-pass/uniq-cc.rs
+++ b/src/test/run-pass/uniq-cc.rs
@@ -10,17 +10,17 @@
 
 enum maybe_pointy {
     none,
-    p(@pointy),
+    p(@Pointy),
 }
 
-type pointy = {
+struct Pointy {
     mut a : maybe_pointy,
     c : ~int,
     d : fn~()->(),
-};
+}
 
-fn empty_pointy() -> @pointy {
-    return @{
+fn empty_pointy() -> @Pointy {
+    return @Pointy {
         mut a : none,
         c : ~22,
         d : fn~()->(){},
diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs
index 78dd7b48020..d53d89457f1 100644
--- a/src/test/run-pass/unique-autoderef-field.rs
+++ b/src/test/run-pass/unique-autoderef-field.rs
@@ -8,8 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct J { j: int }
+
 fn main() {
-    let i = ~{
+    let i = ~J {
         j: 100
     };
     assert i.j == 100;
diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs
index 76aa0d85439..5f88a9fce03 100644
--- a/src/test/run-pass/unique-destructure.rs
+++ b/src/test/run-pass/unique-destructure.rs
@@ -8,7 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct Foo { a: int, b: int }
+
 fn main() {
-    let ~{a, b} = ~{a: 100, b: 200};
+    let ~Foo{a, b} = ~Foo{a: 100, b: 200};
     assert a + b == 300;
 }
\ No newline at end of file
diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs
index ed885045e4b..48c90d3ba63 100644
--- a/src/test/run-pass/unique-pat-2.rs
+++ b/src/test/run-pass/unique-pat-2.rs
@@ -9,12 +9,13 @@
 // except according to those terms.
 
 
-type foo = {a: int, b: uint};
-enum bar { u(~foo), w(int), }
+struct Foo {a: int, b: uint}
+
+enum bar { u(~Foo), w(int), }
 
 fn main() {
-    assert (match u(~{a: 10, b: 40u}) {
-              u(~{a: a, b: b}) => { a + (b as int) }
+    assert (match u(~Foo{a: 10, b: 40u}) {
+              u(~Foo{a: a, b: b}) => { a + (b as int) }
               _ => { 66 }
             } == 50);
 }
diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs
index e92547ac89c..4beaa080f8b 100644
--- a/src/test/run-pass/unique-rec.rs
+++ b/src/test/run-pass/unique-rec.rs
@@ -8,9 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+struct X { x: int }
 
 fn main() {
-    let x = ~{x: 1};
+    let x = ~X {x: 1};
     let bar = x;
     assert bar.x == 1;
 }
diff --git a/src/test/run-pass/vec-drop.rs b/src/test/run-pass/vec-drop.rs
index 02e6276105f..f7d7c1474f7 100644
--- a/src/test/run-pass/vec-drop.rs
+++ b/src/test/run-pass/vec-drop.rs
@@ -10,9 +10,11 @@
 
 
 
+struct Pair { x: int, y: int }
+
 fn main() {
     // This just tests whether the vec leaks its members.
 
-    let pvec: ~[@{x: int, y: int}] =
-        ~[@{x: 1, y: 2}, @{x: 3, y: 4}, @{x: 5, y: 6}];
+    let pvec: ~[@Pair] =
+        ~[@Pair{x: 1, y: 2}, @Pair{x: 3, y: 4}, @Pair{x: 5, y: 6}];
 }
diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs
index 3857cbfb022..6d93f837aff 100644
--- a/src/test/run-pass/writealias.rs
+++ b/src/test/run-pass/writealias.rs
@@ -12,12 +12,12 @@
 
 
 // -*- rust -*-
-type point = {x: int, y: int, mut z: int};
+struct Point {x: int, y: int, mut z: int}
 
-fn f(p: &mut point) { p.z = 13; }
+fn f(p: &mut Point) { p.z = 13; }
 
 fn main() {
-    let mut x: point = {x: 10, y: 11, mut z: 12};
+    let mut x: Point = Point {x: 10, y: 11, mut z: 12};
     f(&mut x);
     assert (x.z == 13);
 }