rustc: Make the pretty printer output commas after enum variants. Update all tests accordingly.

src/comp/syntax/print/pprust.rs

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

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

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

src/test/bench/shootout-binarytrees.rs

 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 {

src/test/bench/sudoku.rs

@@ -25,7 +25,7 @@
 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 {

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

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

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

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

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

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

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

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

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)); }
\ No newline at end of file

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

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

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

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

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

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

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

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

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

@@ -6,7 +6,7 @@
 
 // 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; } } }
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/test/run-pass/export-unexported-dep.rs

@@ -6,7 +6,7 @@ mod foo {
     export g;
 
     // not exported
-    enum t { t1; t2; }
+    enum t { t1, t2, }
 
     fn f() -> t { ret t1; }
 

src/test/run-pass/expr-alt-struct.rs

@@ -10,7 +10,7 @@ fn test_rec() {
 }
 
 fn test_tag() {
-    enum mood { happy; sad; }
+    enum mood { happy, sad, }
     let rs = alt true { true { happy } false { sad } };
     assert (rs == happy);
 }

src/test/run-pass/expr-if-struct.rs

@@ -10,7 +10,7 @@ fn test_rec() {
 }
 
 fn test_tag() {
-    enum mood { happy; sad; }
+    enum mood { happy, sad, }
     let rs = if true { happy } else { sad };
     assert (rs == happy);
 }

src/test/run-pass/generic-ivec-leak.rs

-enum wrapper<T> { wrapped(T); }
+enum wrapper<T> { wrapped(T), }
 
 fn main() { let w = wrapped([1, 2, 3, 4, 5]); }
 

src/test/run-pass/generic-recursive-tag.rs

 
 
-enum list<T> { cons(@T, @list<T>); nil; }
+enum list<T> { cons(@T, @list<T>), nil, }
 
 fn main() {
     let a: list<int> =

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

 
 
-enum foo<T> { arm(T); }
+enum foo<T> { arm(T), }
 
 fn altfoo<T>(f: foo<T>) {
     let hit = false;

src/test/run-pass/generic-tag-corruption.rs

@@ -2,6 +2,6 @@
 
 
 // This causes memory corruption in stage0.
-enum thing<K> { some(K); }
+enum thing<K> { some(K), }
 
 fn main() { let x = some("hi"); }

src/test/run-pass/generic-tag-local.rs

 
 
-enum clam<T> { a(T); }
+enum clam<T> { a(T), }
 
 fn main() { let c = a(3); }

src/test/run-pass/generic-tag-values.rs

@@ -2,7 +2,7 @@
 
 
 // -*- rust -*-
-enum noption<T> { some(T); }
+enum noption<T> { some(T), }
 
 fn main() {
     let nop: noption<int> = some::<int>(5);

src/test/run-pass/generic-tag.rs

 
 
-enum option<T> { some(@T); none; }
+enum option<T> { some(@T), none, }
 
 fn main() { let a: option<int> = some::<int>(@10); a = none::<int>; }

src/test/run-pass/hashmap-memory.rs

@@ -30,7 +30,7 @@ mod map_reduce {
 
     type mapper = native fn(str, putter);
 
-    enum ctrl_proto { find_reducer([u8], chan<int>); mapper_done; }
+    enum ctrl_proto { find_reducer([u8], chan<int>), mapper_done, }
 
     fn start_mappers(ctrl: chan<ctrl_proto>, inputs: [str]) {
         for i: str in inputs {

src/test/run-pass/init-res-into-things.rs

@@ -23,7 +23,7 @@ fn test_rec() {
 
 fn test_tag() {
     enum t {
-        t0(r);
+        t0(r),
     }
 
     let i = @mutable 0;

src/test/run-pass/issue-687.rs

@@ -7,7 +7,7 @@
 import comm::recv;
 import comm::send;
 
-enum msg { closed; received([u8]); }
+enum msg { closed, received([u8]), }
 
 fn producer(c: chan<[u8]>) {
     send(c, [1u8, 2u8, 3u8, 4u8]);

src/test/run-pass/issue-980.rs

 enum maybe_pointy {
-    no_pointy;
-    yes_pointy(@pointy);
+    no_pointy,
+    yes_pointy(@pointy),
 }
 
 type pointy = {

src/test/run-pass/leak-tag-copy.rs

 
 
-enum t { a; b(@int); }
+enum t { a, b(@int), }
 
 fn main() { let x = b(@10); x = a; }

src/test/run-pass/list.rs

@@ -2,6 +2,6 @@
 
 
 // -*- rust -*-
-enum list { cons(int, @list); nil; }
+enum list { cons(int, @list), nil, }
 
 fn main() { cons(10, @cons(11, @cons(12, @nil))); }

src/test/run-pass/log-knows-the-names-of-variants-in-std.rs

@@ -2,8 +2,8 @@
 import std::list;
 
 enum foo {
-  a(uint);
-  b(str);
+  a(uint),
+  b(str),
 }
 
 fn check_log<T>(exp: str, v: T) {

src/test/run-pass/log-knows-the-names-of-variants.rs

 enum foo {
-  a(uint);
-  b(str);
-  c;
+  a(uint),
+  b(str),
+  c,
 }
 
 fn main() {

src/test/run-pass/log-linearized.rs

 // Tests that shapes respect linearize_ty_params().
 
 enum option<T> {
-    none;
-    some(T);
+    none,
+    some(T),
 }
 
 type smallintmap<T> = @{mutable v: [mutable option<T>]};

src/test/run-pass/mlist-cycle.rs

@@ -4,7 +4,7 @@
 
 type cell = {mutable c: @list};
 
-enum list { link(@cell); nil; }
+enum list { link(@cell), nil, }
 
 fn main() {
     let first: @cell = @{mutable c: @nil()};

src/test/run-pass/mlist.rs

 // -*- rust -*-
-enum mlist { cons(int, @mlist); nil; }
+enum mlist { cons(int, @mlist), nil, }
 
 fn main() { cons(10, @cons(11, @cons(12, @nil))); }

src/test/run-pass/mutual-recursion-group.rs

@@ -2,12 +2,12 @@
 
 
 // -*- rust -*-
-enum colour { red; green; blue; }
+enum colour { red, green, blue, }
 
-enum tree { children(@list); leaf(colour); }
+enum tree { children(@list), leaf(colour), }
 
-enum list { cons(@tree, @list); nil; }
+enum list { cons(@tree, @list), nil, }
 
-enum small_list { kons(int, @small_list); neel; }
+enum small_list { kons(int, @small_list), neel, }
 
 fn main() { }

src/test/run-pass/nested-pattern.rs

@@ -6,7 +6,7 @@
 import option::some;
 import option::none;
 
-enum t { foo(int, uint); bar(int, option::t<int>); }
+enum t { foo(int, uint), bar(int, option::t<int>), }
 
 fn nested(o: t) {
     alt o {

src/test/run-pass/nullary-or-pattern.rs

-enum blah { a; b; }
+enum blah { a, b, }
 
 fn or_alt(q: blah) -> int {
   alt q { a | b { 42 } }

src/test/run-pass/or-pattern.rs

-enum blah { a(int, int, uint); b(int, int); c; }
+enum blah { a(int, int, uint), b(int, int), c, }
 
 fn or_alt(q: blah) -> int {
     alt q { a(x, y, _) | b(x, y) { ret x + y; } c { ret 0; } }

src/test/run-pass/record-pat.rs

-enum t1 { a(int); b(uint); }
+enum t1 { a(int), b(uint), }
 type t2 = {x: t1, y: int};
-enum t3 { c(t2, uint); }
+enum t3 { c(t2, uint), }
 
 fn m(in: t3) -> int {
     alt in {

src/test/run-pass/resource-in-struct.rs

@@ -5,7 +5,7 @@
 
 resource close_res(i: closable) { *i = false; }
 
-enum option<T> { none; some(T); }
+enum option<T> { none, some(T), }
 
 fn sink(res: option<close_res>) { }
 

src/test/run-pass/ret-none.rs

 
 
-enum option<T> { none; some(T); }
+enum option<T> { none, some(T), }
 
 fn f<T: copy>() -> option<T> { ret none; }
 

src/test/run-pass/shadow.rs

@@ -16,6 +16,6 @@ fn foo(c: [int]) {
     }
 }
 
-enum t<T> { none; some(T); }
+enum t<T> { none, some(T), }
 
 fn main() { let x = 10; let x = x + 20; assert (x == 30); foo([]); }

src/test/run-pass/shape_intrinsic_tag_then_rec.rs

@@ -10,8 +10,8 @@
 enum opt_span {
 
     //hack (as opposed to option::t), to make `span` compile
-    os_none;
-    os_some(@span);
+    os_none,
+    os_some(@span),
 }
 type span = {lo: uint, hi: uint, expanded_from: opt_span};
 type spanned<T> = { data: T, span: span };

src/test/run-pass/simple-alt-generic-tag.rs

 
 
-enum opt<T> { none; }
+enum opt<T> { none, }
 
 fn main() {
     let x = none::<int>;

src/test/run-pass/simple-generic-alt.rs

 
 
-enum clam<T> { a(T); }
+enum clam<T> { a(T), }
 
 fn main() { let c = a(2); alt c { a::<int>(_) { } } }

src/test/run-pass/simple-generic-tag.rs

 
 
-enum clam<T> { a(T); }
+enum clam<T> { a(T), }
 
 fn main() { }

src/test/run-pass/size-and-align.rs

@@ -2,7 +2,7 @@
 
 
 // -*- rust -*-
-enum clam<T> { a(T, int); b; }
+enum clam<T> { a(T, int), b, }
 
 fn uhoh<T>(v: [clam<T>]) {
     alt v[1] {

src/test/run-pass/structured-compare-recursive.rs

 
 
-enum taggy { foo(@taggy); bar; }
+enum taggy { foo(@taggy), bar, }
 
 fn main() { assert (bar <= bar); }

src/test/run-pass/structured-compare.rs

 
 
-enum foo { large; small; }
+enum foo { large, small, }
 
 fn main() {
     let a = {x: 1, y: 2, z: 3};

src/test/run-pass/tag-auto-disr-val-shape.rs

 // xfail-test
 
-enum color { red; green; blue; black; white; }
+enum color { red, green, blue, black, white, }
 
 fn main() {
     assert (uint::to_str(red as uint, 10) == #fmt["%?", red]);

src/test/run-pass/tag-disr-val-shape.rs

 // xfail-pretty Issue #1510
 
 enum color {
-    red = 0xff0000;
-    green = 0x00ff00;
-    blue = 0x0000ff;
-    black = 0x000000;
-    white = 0xFFFFFF;
+    red = 0xff0000,
+    green = 0x00ff00,
+    blue = 0x0000ff,
+    black = 0x000000,
+    white = 0xFFFFFF,
 }
 
 fn main() {

src/test/run-pass/tag-in-block.rs

@@ -2,7 +2,7 @@
 
 fn foo() {
     fn zed(z: bar) { }
-    enum bar { nil; }
+    enum bar { nil, }
     fn baz() { zed(nil); }
 }
 

src/test/run-pass/tag-variant-disr-val.rs

 enum color {
-    red = 0xff0000;
-    green = 0x00ff00;
-    blue = 0x0000ff;
-    black = 0x000000;
-    white = 0xFFFFFF;
-    imaginary = -1;
+    red = 0xff0000,
+    green = 0x00ff00,
+    blue = 0x0000ff,
+    black = 0x000000,
+    white = 0xFFFFFF,
+    imaginary = -1,
 }
 
 fn main() {

src/test/run-pass/tag.rs

@@ -2,7 +2,7 @@
 
 
 // -*- rust -*-
-enum colour { red(int, int); green; }
+enum colour { red(int, int), green, }
 
 fn f() { let x = red(1, 2); let y = green; assert (x != y); }
 

src/test/run-pass/task-comm-16.rs

@@ -50,7 +50,7 @@ fn test_str() {
 }
 
 fn test_tag() {
-    enum t { tag1; tag2(int); tag3(int, u8, char); }
+    enum t { tag1, tag2(int), tag3(int, u8, char), }
     let po = port();
     let ch = chan(po);
     send(ch, tag1);

src/test/run-pass/uniq-cc-generic.rs

 enum maybe_pointy {
-    none;
-    p(@pointy);
+    none,
+    p(@pointy),
 }
 
 type pointy = {

src/test/run-pass/uniq-cc.rs

 enum maybe_pointy {
-    none;
-    p(@pointy);
+    none,
+    p(@pointy),
 }
 
 type pointy = {

src/test/run-pass/unique-containing-tag.rs

 fn main() {
-    enum t { t1(int); t2(int); }
+    enum t { t1(int), t2(int), }
 
     let x = ~t1(10);
 

src/test/run-pass/unique-in-tag.rs

 fn test1() {
-    enum bar { u(~int); w(int); }
+    enum bar { u(~int), w(int), }
 
     let x = u(~10);
     assert alt x {

src/test/run-pass/unique-pat-2.rs

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

src/test/run-pass/unique-pat-3.rs

 
-enum bar { u(~int); w(int); }
+enum bar { u(~int), w(int), }
 
 fn main() {
     assert alt u(~10) {

src/test/run-pass/use-uninit-alt.rs

@@ -6,6 +6,6 @@ fn foo<T>(o: myoption<T>) -> int {
     ret x;
 }
 
-enum myoption<T> { none; some(T); }
+enum myoption<T> { none, some(T), }
 
 fn main() { log(debug, 5); }

src/test/run-pass/use-uninit-alt2.rs

@@ -6,6 +6,6 @@ fn foo<T>(o: myoption<T>) -> int {
     ret x;
 }
 
-enum myoption<T> { none; some(T); }
+enum myoption<T> { none, some(T), }
 
 fn main() { log(debug, 5); }

src/test/run-pass/while-prelude-drop.rs

 
-enum t { a; b(str); }
+enum t { a, b(str), }
 
 fn make(i: int) -> t {
     if i > 10 { ret a; }