diff --git a/src/test/auxiliary/cci_nested_lib.rs b/src/test/auxiliary/cci_nested_lib.rs index 291a506c4ebb..d20653e429ae 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 = {key: A, value: B}; -struct alist { eq_fn: fn@(A,A) -> bool, data: DVec> } +struct Entry {key: A, value: B} + +struct alist { eq_fn: fn@(A,A) -> bool, data: DVec> } fn alist_add(lst: alist, k: A, v: B) { - lst.data.push({key:k, value:v}); + lst.data.push(Entry{key:k, value:v}); } fn alist_get(lst: alist, k: A) -> B { diff --git a/src/test/auxiliary/crateresolve5-1.rs b/src/test/auxiliary/crateresolve5-1.rs index de893c28cdda..e07f24c2fb77 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 67af05a28908..be7e993d29c0 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 beb1a5fc6c23..888acf30b2a9 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 ded15ca94f11..2e0e3ea8f559 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 = { +struct Pair { a: A, b: B -}; +} -enum rec = _rec; -type _rec = { +enum RecEnum = Rec; +struct Rec { val: A, - mut rec: Option<@rec> -}; + mut rec: Option<@RecEnum> +} fn make_cycle(a: A) { - let g: @rec = @rec({val: a, mut rec: None}); + let g: @RecEnum = @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 869604442ea4..2901754c8f2b 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 { some(T), none, } -type r = {mut v: ~[option]}; +struct R {mut v: ~[option]} fn f() -> ~[T] { return ~[]; } -fn main() { let r: r = {mut v: ~[]}; r.v = f(); } +fn main() { let r: R = 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 f703eed6a21c..a30a0c64215e 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 063e01fc02f4..f23cf72cf1f8 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 0d3d8768e968..dbb8b07b8e84 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 2ec0c1d81ce6..fc124041fd4e 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 d38683f7eaba..560a6cbb823d 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 f96cfeb3f37e..a2031019a4d1 100644 --- a/src/test/run-pass/auto-instantiate.rs +++ b/src/test/run-pass/auto-instantiate.rs @@ -12,9 +12,13 @@ // -*- rust -*- -fn f(x: T, y: U) -> {a: T, b: U} { return {a: x, b: y}; } + +struct Pair { a: T, b: U } +struct Triple { x: int, y: int, z: int } + +fn f(x: T, y: U) -> Pair { 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 04e00b5972c5..7a620d584819 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 ece12f8d4c0a..b6c205524a80 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 5cee34b9228a..14757bfa3d8a 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 333845c9cade..87592f548179 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 f641131e48ea..ccf9be1d585d 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 90fe4000ddb4..1f6bfe20bb12 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 93ec21193078..30250c26a9a6 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 0ce704d4670a..0e4f15d49db2 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 893cc6c9732c..e8e3cf297ba7 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(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 3688fe94815d..91e416b72e18 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 57bec6c0c27d..355850147131 100644 --- a/src/test/run-pass/box-unbox.rs +++ b/src/test/run-pass/box-unbox.rs @@ -10,13 +10,13 @@ -type box = {c: @T}; +struct Box {c: @T} -fn unbox(b: box) -> T { return *b.c; } +fn unbox(b: Box) -> T { return *b.c; } fn main() { let foo: int = 17; - let bfoo: box = {c: @foo}; + let bfoo: Box = Box {c: @foo}; debug!("see what's in our box"); assert (unbox::(bfoo) == foo); } diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs index 4defb3c6f375..3c55409dde88 100644 --- a/src/test/run-pass/const-bound.rs +++ b/src/test/run-pass/const-bound.rs @@ -14,11 +14,13 @@ fn foo(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 dd5e94b52eb2..6dccecb5aa8d 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 4764bb252484..b3d971a2cefd 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 ce5e9ade8cac..c8b08b1e35a7 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 4b4c91ae6f0b..0b0d9a839ce6 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 23a9bfeccc30..2e647d25c747 100644 --- a/src/test/run-pass/early-vtbl-resolution.rs +++ b/src/test/run-pass/early-vtbl-resolution.rs @@ -17,9 +17,11 @@ impl int: thing { } fn foo_func>(x: B) -> Option { 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 674746530fa2..bb57710969f5 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 = pure fn~(K) -> uint; type EqFn = pure fn~(K, K) -> bool; +struct LM { resize_at: uint, size: uint } + enum LinearMap { - LinearMap_({ - resize_at: uint, - size: uint}) + LinearMap_(LM) } fn linear_map() -> LinearMap { - 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 06b9f0d8ca5c..b4a80906b33a 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( 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 43b480cd8a49..61e92500cc8a 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::(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::({a: 1, b: 2}, compare_rec); + test_generic::(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 c14eb1072aa0..1cc9d4ba6842 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 22c01f7893aa..6cfc06307c41 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::(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::({a: 1, b: 2}, compare_rec); + test_generic::(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 d35a49409ba6..8c173ae5d76b 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 6ae823df6189..490f3950f9f3 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 8dedfb73e9b6..69dcac9f03a4 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 9347566d700e..92f9117dde8d 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::(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::({a: 1, b: 2}, {a: 2, b: 3}, compare_rec); + test_generic::(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 6f22ea908ad6..506d607e7e8f 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 c9a2db9c6f14..2d77a775f34f 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 253b68db44ee..3d6e781c512c 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 4ab3f5449e44..47da343764c1 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 fa6b81175b08..f68cf1676c72 100644 --- a/src/test/run-pass/generic-box.rs +++ b/src/test/run-pass/generic-box.rs @@ -10,9 +10,11 @@ -fn box(x: {x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { return @x; } +fn box(x: Box) -> @Box { return @x; } + +struct Box {x: T, y: T, z: T} fn main() { - let x: @{x: int, y: int, z: int} = box::({x: 1, y: 2, z: 3}); + let x: @Box = box::(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 7cf3f3981ea6..03f5a84de693 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: X) -> X { return x; } -fn f(t: T) -> {a: T, b: T} { - type pair = {a: T, b: T}; +struct Pair {a: T, b: T} - let x: pair = {a: t, b: t}; - return g::(x); +fn f(t: T) -> Pair { + + let x: Pair = Pair {a: t, b: t}; + return g::>(x); } fn main() { diff --git a/src/test/run-pass/generic-drop-glue.rs b/src/test/run-pass/generic-drop-glue.rs index fe1db75f4b8c..aad24e99058a 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: 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 b26e1aebe1a4..738bb73b0be4 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 = {x: @T}; +struct Recbox {x: @T} -fn reclift(t: T) -> recbox { return {x: @t}; } +fn reclift(t: T) -> Recbox { return Recbox {x: @t}; } fn main() { let foo: int = 17; - let rbfoo: recbox = reclift::(foo); + let rbfoo: Recbox = reclift::(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 975ce3bc616f..2095578aefad 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 = {x: ~T}; +struct Recbox {x: ~T} -fn reclift(t: T) -> recbox { return {x: ~t}; } +fn reclift(t: T) -> Recbox { return Recbox {x: ~t}; } fn main() { let foo: int = 17; - let rbfoo: recbox = reclift::(foo); + let rbfoo: Recbox = reclift::(foo); assert (*rbfoo.x == foo); } diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs index fadc501d8693..13ed32e0c2d6 100644 --- a/src/test/run-pass/generic-fn.rs +++ b/src/test/run-pass/generic-fn.rs @@ -14,22 +14,22 @@ // -*- rust -*- fn id(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::(x); log(debug, y); assert (x == y); b = id::(a); log(debug, b); assert (a == b); - q = id::(p); + q = id::(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 0f41be3e6fcf..9fd5f4fadff9 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 { some(T), } +struct Pair { x: int, y: int } + fn main() { let nop: noption = some::(5); match nop { some::(n) => { log(debug, n); assert (n == 5); } } - let nop2: noption<{x: int, y: int}> = some({x: 17, y: 42}); + let nop2: noption = 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 bf006b4ff58c..e0f6363eb6b3 100644 --- a/src/test/run-pass/generic-type.rs +++ b/src/test/run-pass/generic-type.rs @@ -10,10 +10,10 @@ -type pair = {x: T, y: T}; +struct Pair {x: T, y: T} fn main() { - let x: pair = {x: 10, y: 12}; + let x: Pair = 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 d6296fff2f43..01e899db23a6 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 { x: T, y: T, z: T } -fn box(x: {x: T, y: T, z: T}) -> ~{x: T, y: T, z: T} { return ~x; } +fn box(x: Triple) -> ~Triple { return ~x; } fn main() { - let x: ~{x: int, y: int, z: int} = box::({x: 1, y: 2, z: 3}); + let x: ~Triple = box::(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 628cbe9b7cc4..2ba0660cc705 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 de1ecd38316b..c87987aac3a8 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 1e5342fca3b7..11efd61072c8 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 c98d321a9fc9..57065ec44a51 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 8eca57eacbf7..a29d6d1e3e4b 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 = { +struct X { a: T, b: u8, c: bool, @@ -19,10 +19,10 @@ type x = { e: u16, f: u8, g: u8 -}; +} fn main() { - let x: x = { + let x: X = X { a: 12345678, b: 9u8, c: true, @@ -34,7 +34,7 @@ fn main() { bar(x); } -fn bar(x: x) { +fn bar(x: X) { 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 9c2a6f9f30ed..ab0e0aa1aba9 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 9ac1a8861681..b787677db681 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 103ae4fe8c40..e209a9a03ed4 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 cc3b3d623322..f8f2fc461c3f 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 { + mut state: state, + mut blocked_task: Option, + mut payload: Option + } + pub enum state { empty, full, @@ -36,7 +42,7 @@ pub mod pipes { pub fn packet() -> *packet { unsafe { - let p: *packet = cast::transmute(~{ + let p: *packet = cast::transmute(~Stuff{ mut state: empty, mut blocked_task: None::, mut payload: None:: diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs index 20efa7af4878..d77a0817b825 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 050f56973211..f29231b53d0c 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 ed0efa0e4bda..1e94f6af90f1 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 a45fe552d1a7..21b68a07560d 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 c7bfe2b6b8fd..ee08b18de161 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 e9028e5d3f9e..885b3a83da63 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 4e0e8376f6ab..ba7fd4fee5e2 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 6c3a84e616fa..be9c8bdf2d65 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 0378a8648a13..73e16085c4ee 100644 --- a/src/test/run-pass/log-linearized.rs +++ b/src/test/run-pass/log-linearized.rs @@ -15,11 +15,13 @@ enum option { some(T), } -type smallintmap = @{mut v: ~[mut option]}; +struct Smallintmap {mut v: ~[mut option]} -fn mk() -> smallintmap { +struct V { v: ~[mut option] } + +fn mk() -> @Smallintmap { let v: ~[mut option] = ~[mut]; - return @{mut v: move v}; + return @Smallintmap {mut v: move v}; } fn f() { diff --git a/src/test/run-pass/morestack4.rs b/src/test/run-pass/morestack4.rs index 44309bbcaec0..35b2993ca33c 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 b99b8a67a2ca..e477442376eb 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 191d4e1c7d7e..4c7e5682a130 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 8ed113e09831..096daf315eba 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 da7d23ebddcb..23746c924ad7 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 9fd122060cca..e16955f31e81 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 9ecb6d28dd5c..80de11091ee3 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 9608f3e08f71..0c2ce79e6aa7 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 5545bc96a3d4..351b78807b83 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 54bd9c69b794..f774e4213489 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 b110bb6a604c..c6eb91c564db 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, 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 17e0fdd56106..06d630255c0b 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 aaf7d1d3bbb2..cb781ae6a993 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 0a0f8ec71142..3667a9802516 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 ea16f005c6b3..2821ab3e3ebc 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 f3801dcc96d7..572720f58085 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 ad66bf6dafa2..84792d52c133 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 { 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 a81a3891644a..5c3f77b994b4 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 d24b0888c44c..11e2f79aa608 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::()); - debug!("size outer = %?", sys::size_of::()); + debug!("align inner = %?", rusti::min_align_of::()); + debug!("size outer = %?", sys::size_of::()); debug!("y = %s", y); // per clang/gcc the alignment of `inner` is 4 on x86. - assert rusti::min_align_of::() == m::align(); + assert rusti::min_align_of::() == m::align(); // per clang/gcc the size of `outer` should be 12 // because `inner`s alignment was 4. - assert sys::size_of::() == m::size(); + assert sys::size_of::() == 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 dc9fa146ef92..5fdabdc360cd 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::()); - debug!("size outer = %?", sys::size_of::()); + debug!("align inner = %?", rusti::min_align_of::()); + debug!("size outer = %?", sys::size_of::()); debug!("y = %s", y); - // per clang/gcc the alignment of `inner` is 4 on x86. - assert rusti::min_align_of::() == m::m::align(); + // per clang/gcc the alignment of `Inner` is 4 on x86. + assert rusti::min_align_of::() == m::m::align(); - // per clang/gcc the size of `outer` should be 12 - // because `inner`s alignment was 4. - assert sys::size_of::() == m::m::size(); + // per clang/gcc the size of `Outer` should be 12 + // because `Inner`s alignment was 4. + assert sys::size_of::() == 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 8fab506a49ec..05428879fd2e 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 317752d9d474..ca353455c137 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 254ce630338c..8c20e4f342ba 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 8b4f3780be00..6ff363558751 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 a88a1d1459c4..026b9c93203f 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 ff9e133fe153..d072df4d8e88 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 = { - inner: V -}; +enum ptr_visit_adaptor = Inner; impl ptr_visit_adaptor { @@ -469,11 +467,13 @@ impl ptr_visit_adaptor: 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(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::(Inner {inner: u}); visit_tydesc(inner, v as TyVisitor); true } } } +struct Inner { 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) -> *TyDesc { get_tydesc::() } +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 b8c0bfeb763a..e1d54f33dcb7 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 0fd1b361b297..71bf0ac82698 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 -}; - -type fcx = { - arena: &Arena, - ccx: &ccx -}; - -type ccx = { - x: int -}; - -fn h(bcx : &r/bcx) -> &r/bcx { - return bcx.fcx.arena.alloc(|| { fcx: bcx.fcx }); +struct Bcx { + fcx: &Fcx } -fn g(fcx : &fcx) { - let bcx = { fcx: fcx }; +struct Fcx { + arena: &Arena, + ccx: &Ccx +} + +struct Ccx { + x: int +} + +fn h(bcx : &r/Bcx) -> &r/Bcx { + return bcx.fcx.arena.alloc(|| Bcx { fcx: bcx.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 09de16500279..2ef63af3be19 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::() as libc::size_t)); + &libc::malloc(sys::size_of::() 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 9d1a37ce1528..975d96dc4206 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 356e0a6c9f28..575fefa9db51 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 80aaad5c90fa..f2926c5e1c5c 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 3a1f6d812a8e..56ca229b0555 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 7a4e9e6faf52..59a6d703c7ce 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 c96ee8ddce7d..e528cd32974b 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 {val: T, fin: extern fn(T)} + struct finish { - arg: {val: T, fin: extern fn(T)}, + arg: Arg } impl finish : Drop { @@ -21,7 +23,7 @@ impl finish : Drop { } } -fn finish(arg: {val: T, fin: extern fn(T)}) -> finish { +fn finish(arg: Arg) -> finish { 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 1ddeee336e3c..2b43fca58b72 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::(); + let myport = ::core::oldcomm::Port::(); 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 1a6cf7e04ccc..44165119b0d5 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: A, b: B }; +struct Pair { a: A, b: B } -fn make_generic_record(a: A, b: B) -> pair { - return {a: a, b: b}; +fn make_generic_record(a: A, b: B) -> Pair { + return Pair {a: a, b: b}; } -fn test05_start(&&f: fn~(&&v: float, &&v: ~str) -> pair) { +fn test05_start(&&f: fn~(&&v: float, &&v: ~str) -> Pair) { 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) { assert q.b == ~"Ho"; } -fn spawn(f: extern fn(fn~(A,B)->pair)) { - let arg = fn~(a: A, b: B) -> pair { +fn spawn(f: extern fn(fn~(A,B)->Pair)) { + let arg = fn~(a: A, b: B) -> Pair { 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 4139aedf8813..53a09b385b3c 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 = { data: T, span: span }; +struct Span {lo: uint, hi: uint, expanded_from: opt_span} +struct Spanned { data: T, span: Span } type ty_ = uint; -type path_ = { global: bool, idents: ~[~str], types: ~[@ty] }; -type path = spanned; -type ty = spanned; +struct Path_ { global: bool, idents: ~[~str], types: ~[@ty] } +type path = Spanned; +type ty = Spanned; + +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 c4e38a1de2ce..e09150eac767 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 767887319470..83e34ba84e16 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 96c51e980050..cbc093fcc192 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, mut right: Option, val: to_str -}; +} trait to_str { fn to_str() -> ~str; @@ -45,10 +45,10 @@ impl Tree: to_str { fn foo(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 866f4742f4e8..4215a8597f2c 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 b78c78ad9e98..b1cde5b2e85f 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: 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 84a0dc212e56..deaf09a23929 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 78dd7b480204..d53d89457f18 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 76aa0d85439e..5f88a9fce032 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 ed885045e4b1..48c90d3ba634 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 e92547ac89c6..4beaa080f8b9 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 02e6276105f0..f7d7c1474f79 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 3857cbfb022e..6d93f837affc 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); }