---

yaml
---
r: 7534
b: refs/heads/master
c: 59ebe6a
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: c6278e53dce084a2b9a284026be45fdad6a07478
+refs/heads/master: 59ebe6af187ce0504b40c177f1700b090b226625

trunk/src/comp/syntax/print/pprust.rs

@@ -451,7 +451,7 @@ fn print_item(s: ps, &&item: @ast::item) {
                   }
                   _ {}
                 }
-                word(s.s, ";");
+                word(s.s, ",");
                 end(s);
                 maybe_print_trailing_comment(s, v.span, none::<uint>);
             }

trunk/src/test/bench/99bob-pattern.rs

@@ -8,7 +8,7 @@ use std;
 import int;
 import str;
 
-enum bottle { none; dual; single; multiple(int); }
+enum bottle { none, dual, single, multiple(int), }
 
 fn show(b: bottle) {
     alt b {

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

@@ -1,7 +1,7 @@
 use std;
 import int;
 
-enum tree { nil; node(~tree, ~tree, int); }
+enum tree { nil, node(~tree, ~tree, int), }
 
 fn item_check(t: ~tree) -> int {
     alt *t {

trunk/src/test/bench/sudoku.rs

@@ -25,7 +25,7 @@ export grid_t, read_grid, solve_grid, write_grid;
 type grid = [[mutable u8]];
 
 // exported type of sudoku grids
-enum grid_t { grid_ctor(grid); }
+enum grid_t { grid_ctor(grid), }
 
 // read a sudoku problem from file f
 fn read_grid(f: io::reader) -> grid_t {

trunk/src/test/bench/task-perf-word-count.rs

@@ -52,11 +52,11 @@ mod map_reduce {
     type reducer = fn@(str, getter);
 
     enum ctrl_proto {
-        find_reducer(str, chan<chan<reduce_proto>>);
-        mapper_done;
+        find_reducer(str, chan<chan<reduce_proto>>),
+        mapper_done,
     }
 
-    enum reduce_proto { emit_val(int); done; ref; release; }
+    enum reduce_proto { emit_val(int), done, ref, release, }
 
     fn start_mappers(ctrl: chan<ctrl_proto>, -inputs: [str]) ->
        [joinable_task] {

trunk/src/test/compile-fail/alt-tag-nullary.rs

@@ -1,7 +1,7 @@
 // error-pattern: mismatched types
 
-enum a { A; }
-enum b { B; }
+enum a { A, }
+enum b { B, }
 
 fn main() { let x: a = A; alt x { B { } } }
 

trunk/src/test/compile-fail/alt-tag-unary.rs

@@ -1,7 +1,7 @@
 // error-pattern: mismatched types
 
-enum a { A(int); }
-enum b { B(int); }
+enum a { A(int), }
+enum b { B(int), }
 
 fn main() { let x: a = A(0); alt x { B(y) { } } }
 

trunk/src/test/compile-fail/bogus-tag.rs

@@ -2,7 +2,7 @@
 
 // error-pattern: unresolved
 
-enum color { rgb(int, int, int); rgba(int, int, int, int); }
+enum color { rgb(int, int, int), rgba(int, int, int, int), }
 
 fn main() {
     let red: color = rgb(255, 0, 0);

trunk/src/test/compile-fail/export-no-tag-variants.rs

@@ -6,7 +6,7 @@
 mod foo {
     export t;
 
-    enum t { t1; }
+    enum t { t1, }
 }
 
 fn main() { let x = foo::t1; }

trunk/src/test/compile-fail/export-tag-variant.rs

@@ -5,7 +5,7 @@ mod foo {
 
     fn x() { }
 
-    enum y { y1; }
+    enum y { y1, }
 }
 
 fn main() { let z = foo::y1; }

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

@@ -3,6 +3,6 @@
 
 // error-pattern: enum of infinite size
 
-enum mlist { cons(int, mlist); nil; }
+enum mlist { cons(int, mlist), nil, }
 
 fn main() { let a = cons(10, cons(11, nil)); }

trunk/src/test/compile-fail/let-destruct-refutable.rs

@@ -1,6 +1,6 @@
 // error-pattern:refutable pattern
 
-enum xx { xx(int); yy; }
+enum xx { xx(int), yy, }
 
 fn main() {
     let @{x: xx(x), y: y} = @{x: xx(10), y: 20};

trunk/src/test/compile-fail/name-clash-nullary-2.rs

@@ -1,5 +1,5 @@
 // error-pattern:Declaration of thpppt shadows
-enum ack { thpppt; ffff; }
+enum ack { thpppt, ffff, }
 
 fn main() {
   let thpppt: int = 42;

trunk/src/test/compile-fail/occurs-check-3.rs

@@ -1,4 +1,4 @@
 // error-pattern:mismatched types
 // From Issue #778
-enum clam<T> { a(T); }
+enum clam<T> { a(T), }
 fn main() { let c; c = a(c); alt c { a::<int>(_) { } } }

trunk/src/test/compile-fail/or-patter-mismatch.rs

@@ -1,5 +1,5 @@
 // error-pattern: mismatched types
 
-enum blah { a(int, int, uint); b(int, int); }
+enum blah { a(int, int, uint), b(int, int), }
 
 fn main() { alt a(1, 1, 2u) { a(_, x, y) | b(x, y) { } } }

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

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

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

@@ -5,7 +5,7 @@ import option::some;
 
 // error-pattern: mismatched types
 
-enum bar { t1((), option::t<[int]>); t2; }
+enum bar { t1((), option::t<[int]>), t2, }
 
 fn foo(t: bar) {
     alt t {

trunk/src/test/compile-fail/tag-variant-cast-non-nullary.rs

@@ -1,8 +1,8 @@
 //error-pattern: non-scalar cast
 
 enum non_nullary {
-    nullary;
-    other(int);
+    nullary,
+    other(int),
 }
 
 fn main() {

trunk/src/test/compile-fail/tag-variant-disr-dup.rs

@@ -3,9 +3,9 @@
 // black and white have the same discriminator value ...
 
 enum color {
-    red = 0xff0000;
-    green = 0x00ff00;
-    blue = 0x0000ff;
-    black = 0x000000;
-    white = 0x000000;
+    red = 0xff0000,
+    green = 0x00ff00,
+    blue = 0x0000ff,
+    black = 0x000000,
+    white = 0x000000,
 }

trunk/src/test/compile-fail/tag-variant-disr-non-nullary.rs

@@ -1,10 +1,10 @@
 //error-pattern: discriminator values can only be used with a c-like enum
 
 enum color {
-    red = 0xff0000;
-    green = 0x00ff00;
-    blue = 0x0000ff;
-    black = 0x000000;
-    white = 0xffffff;
-    other (str);
+    red = 0xff0000,
+    green = 0x00ff00,
+    blue = 0x0000ff,
+    black = 0x000000,
+    white = 0xffffff,
+    other (str),
 }

trunk/src/test/compile-fail/tag-variant-disr-type-mismatch.rs

@@ -1,8 +1,8 @@
 //error-pattern: mismatched types
 
 enum color {
-    red = 1u;
-    blue = 2;
+    red = 1u,
+    blue = 2,
 }
 
 fn main() {}

trunk/src/test/compile-fail/unreachable-arm.rs

@@ -1,5 +1,5 @@
 // error-pattern:unreachable pattern
 
-enum foo { a(@foo, int); b(uint); }
+enum foo { a(@foo, int), b(uint), }
 
 fn main() { alt b(1u) { b(_) | a(@_, 1) { } a(_, 1) { } } }

trunk/src/test/pretty/tag-blank-lines.rs

@@ -1,8 +1,8 @@
 // pp-exact
 
 enum foo {
-    foo; // a foo.
-    bar;
+    foo, // a foo.
+    bar,
 }
 
 fn main() { }

trunk/src/test/run-fail/non-exhaustive-match.rs

@@ -4,6 +4,6 @@
 // -*- rust -*-
 
 // error-pattern:non-exhaustive match failure
-enum t { a; b; }
+enum t { a, b, }
 
 fn main() { let x = a; alt x { b { } } }

trunk/src/test/run-pass/alias-uninit-value.rs

@@ -5,7 +5,7 @@ use std;
 import option;
 import option::none;
 
-enum sty { ty_nil; }
+enum sty { ty_nil, }
 
 type raw_t = {struct: sty, cname: option::t<str>, hash: uint};
 

trunk/src/test/run-pass/alloca-from-derived-tydesc.rs

@@ -1,4 +1,4 @@
-enum option<T> { some(T); none; }
+enum option<T> { some(T), none, }
 
 type r<T> = {mutable v: [option<T>]};
 

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

@@ -1,7 +1,7 @@
 
 
 mod m1 {
-    enum foo { foo1; foo2; }
+    enum foo { foo1, foo2, }
 }
 
 fn bar(x: m1::foo) { alt x { m1::foo1 { } } }

trunk/src/test/run-pass/alt-pattern-drop.rs

@@ -5,7 +5,7 @@ use std;
 
 import std::dbg;
 
-enum t { make_t(@int); clam; }
+enum t { make_t(@int), clam, }
 
 fn foo(s: @int) {
     let count = dbg::refcount(s);

trunk/src/test/run-pass/alt-pattern-no-type-params.rs

@@ -1,4 +1,4 @@
-enum maybe<T> { nothing; just(T); }
+enum maybe<T> { nothing, just(T), }
 
 fn foo(x: maybe<int>) {
     alt x { nothing { #error("A"); } just(a) { #error("B"); } }

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

@@ -1,6 +1,6 @@
 
 
-enum thing { a; b; c; }
+enum thing { a, b, c, }
 
 fn foo(it: block(int)) { it(10); }
 

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

@@ -3,7 +3,7 @@
 fn main() {
     alt "test" { "not-test" { fail; } "test" { } _ { fail; } }
 
-    enum t { tag1(str); tag2; }
+    enum t { tag1(str), tag2, }
 
 
     alt tag1("test") {

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

@@ -3,9 +3,9 @@
 
 // -*- rust -*-
 enum color {
-    rgb(int, int, int);
-    rgba(int, int, int, int);
-    hsl(int, int, int);
+    rgb(int, int, int),
+    rgba(int, int, int, int),
+    hsl(int, int, int),
 }
 
 fn process(c: color) -> int {

trunk/src/test/run-pass/box-pattern.rs

@@ -1,5 +1,5 @@
 type foo = {a: int, b: uint};
-enum bar { u(@foo); w(int); }
+enum bar { u(@foo), w(int), }
 
 fn main() {
     assert (alt u(@{a: 10, b: 40u}) {

trunk/src/test/run-pass/chan-leak.rs

@@ -8,7 +8,7 @@ import comm;
 import comm::port;
 import comm::recv;
 
-enum request { quit; close(chan<bool>); }
+enum request { quit, close(chan<bool>), }
 
 type ctx = chan<request>;
 

trunk/src/test/run-pass/conditional-compile.rs

@@ -20,9 +20,9 @@ type t = int;
 type t = bool;
 
 #[cfg(bogus)]
-enum tg { foo; }
+enum tg { foo, }
 
-enum tg { bar; }
+enum tg { bar, }
 
 #[cfg(bogus)]
 resource r(i: int) { }

trunk/src/test/run-pass/constrained-type.rs

@@ -1,6 +1,6 @@
 // -*- rust -*-
 
-enum list { cons(int, @list); nil; }
+enum list { cons(int, @list), nil, }
 
 type bubu = {x: int, y: int};
 

trunk/src/test/run-pass/cycle-collection.rs

@@ -1,6 +1,6 @@
 enum taggy {
-    cons(@mutable taggy);
-    nil;
+    cons(@mutable taggy),
+    nil,
 }
 
 fn f() {

trunk/src/test/run-pass/drop-on-empty-block-exit.rs

@@ -1,5 +1,5 @@
 
 
-enum t { foo(@int); }
+enum t { foo(@int), }
 
 fn main() { let tt = foo(@10); alt tt { foo(z) { } } }

trunk/src/test/run-pass/empty-tag.rs

@@ -1,4 +1,4 @@
-enum chan { chan_t; }
+enum chan { chan_t, }
 
 fn wrapper3(i: chan) {
     assert i == chan_t;

trunk/src/test/run-pass/enum-disr-val-pretty.rs

@@ -1,6 +1,6 @@
 // pp-exact
 
-enum color { red = 1; green; blue; imaginary = -1; }
+enum color { red = 1, green, blue, imaginary = -1, }
 
 fn main() {
     test_color(red, 1, "red");

trunk/src/test/run-pass/export-abstract-tag.rs

@@ -5,7 +5,7 @@ mod foo {
     export t;
     export f;
 
-    enum t { t1; }
+    enum t { t1, }
 
     fn f() -> t { ret t1; }
 }

trunk/src/test/run-pass/export-non-interference.rs

@@ -2,6 +2,6 @@
 export foo;
 export main;
 
-enum list_cell<T> { cons(@list_cell<T>); }
+enum list_cell<T> { cons(@list_cell<T>), }
 
 fn main() { }

trunk/src/test/run-pass/export-tag-variant.rs

@@ -2,7 +2,7 @@
 
 mod foo {
     export t1;
-    enum t { t1; }
+    enum t { t1, }
 }
 
 fn main() { let v = foo::t1; }