---

yaml
---
r: 52316
b: refs/heads/dist-snap
c: 4bcd19f
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 3ea3136e84659773fea9e6f89cb7ddf76cee2324
+refs/heads/dist-snap: 4bcd19f6be51d7fb26b0930c8a3354b9222143ff
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/front/config.rs

@@ -133,14 +133,19 @@ fn filter_stmt(cx: ctxt, &&stmt: @ast::stmt) ->
     }
 }
 
-fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) ->
-   ast::blk_ {
+fn fold_block(
+    cx: ctxt,
+    b: ast::blk_,
+    fld: fold::ast_fold
+) -> ast::blk_ {
     let filtered_stmts = vec::filter_map(b.stmts, |a| filter_stmt(cx, *a));
-    return {view_items: /*bad*/copy b.view_items,
-         stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
-         expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
-         id: b.id,
-         rules: b.rules};
+    ast::blk_ {
+        view_items: /*bad*/copy b.view_items,
+        stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)),
+        expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
+        id: b.id,
+        rules: b.rules,
+    }
 }
 
 fn item_in_cfg(cx: ctxt, item: @ast::item) -> bool {

branches/dist-snap/src/librustc/front/test.rs

@@ -469,7 +469,7 @@ fn mk_test_wrapper(cx: test_ctxt,
         cf: ast::return_val
     };
 
-    let wrapper_body: ast::blk = nospan({
+    let wrapper_body = nospan(ast::blk_ {
         view_items: ~[],
         stmts: ~[@call_stmt],
         expr: option::None,

branches/dist-snap/src/librustc/middle/astencode.rs

@@ -267,7 +267,10 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
             }
         };
         // XXX: Bad copy.
-        let blk_sans_items = { stmts: stmts_sans_items,.. copy blk };
+        let blk_sans_items = ast::blk_ {
+            stmts: stmts_sans_items,
+            .. copy blk
+        };
         fold::noop_fold_block(blk_sans_items, fld)
     }
 

branches/dist-snap/src/librustc/middle/check_match.rs

@@ -478,7 +478,7 @@ fn ctor_arity(cx: @MatchCheckCtxt, ctor: ctor, ty: ty::t) -> uint {
 }
 
 fn wild() -> @pat {
-    @{id: 0, node: pat_wild, span: ast_util::dummy_sp()}
+    @pat {id: 0, node: pat_wild, span: ast_util::dummy_sp()}
 }
 
 fn specialize(cx: @MatchCheckCtxt, r: ~[@pat], ctor_id: ctor, arity: uint,

branches/dist-snap/src/librustc/middle/trans/_match.rs

@@ -499,7 +499,7 @@ fn enter_opt(bcx: block, m: &[@Match/&r], opt: &Opt, col: uint,
     let _indenter = indenter();
 
     let tcx = bcx.tcx();
-    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, tcx.def_map, m, col, val) |p| {
         match /*bad*/copy p.node {
             ast::pat_enum(_, subpats) => {
@@ -600,7 +600,7 @@ fn enter_rec_or_struct(bcx: block, dm: DefMap, m: &[@Match/&r], col: uint,
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match /*bad*/copy p.node {
             ast::pat_rec(fpats, _) | ast::pat_struct(_, fpats, _) => {
@@ -632,7 +632,7 @@ fn enter_tup(bcx: block, dm: DefMap, m: &[@Match/&r],
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match /*bad*/copy p.node {
             ast::pat_tup(elts) => {
@@ -657,7 +657,7 @@ fn enter_tuple_struct(bcx: block, dm: DefMap, m: &[@Match/&r], col: uint,
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match /*bad*/copy p.node {
             ast::pat_enum(_, Some(elts)) => Some(elts),
@@ -680,7 +680,7 @@ fn enter_box(bcx: block, dm: DefMap, m: &[@Match/&r],
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match p.node {
             ast::pat_box(sub) => {
@@ -705,7 +705,7 @@ fn enter_uniq(bcx: block, dm: DefMap, m: &[@Match/&r],
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
     do enter_match(bcx, dm, m, col, val) |p| {
         match p.node {
             ast::pat_uniq(sub) => {
@@ -730,7 +730,7 @@ fn enter_region(bcx: block, dm: DefMap, m: &[@Match/&r],
            bcx.val_str(val));
     let _indenter = indenter();
 
-    let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
+    let dummy = @ast::pat { id: 0, node: ast::pat_wild, span: dummy_sp() };
     do enter_match(bcx, dm, m, col, val) |p| {
         match p.node {
             ast::pat_region(sub) => {

branches/dist-snap/src/libsyntax/ast.rs

@@ -323,11 +323,18 @@ struct blk_ {
 
 #[auto_encode]
 #[auto_decode]
-type pat = {id: node_id, node: pat_, span: span};
+struct pat {
+    id: node_id,
+    node: pat_,
+    span: span,
+}
 
 #[auto_encode]
 #[auto_decode]
-type field_pat = {ident: ident, pat: @pat};
+struct field_pat {
+    ident: ident,
+    pat: @pat,
+}
 
 #[auto_encode]
 #[auto_decode]
@@ -637,8 +644,13 @@ enum stmt_ {
 // a refinement on pat.
 #[auto_encode]
 #[auto_decode]
-type local_ =  {is_mutbl: bool, ty: @Ty, pat: @pat,
-                init: Option<@expr>, id: node_id};
+struct local_ {
+    is_mutbl: bool,
+    ty: @Ty,
+    pat: @pat,
+    init: Option<@expr>,
+    id: node_id,
+}
 
 type local = spanned<local_>;
 
@@ -650,7 +662,11 @@ enum decl_ { decl_local(~[@local]), decl_item(@item), }
 
 #[auto_encode]
 #[auto_decode]
-type arm = {pats: ~[@pat], guard: Option<@expr>, body: blk};
+struct arm {
+    pats: ~[@pat],
+    guard: Option<@expr>,
+    body: blk,
+}
 
 #[auto_encode]
 #[auto_decode]

branches/dist-snap/src/libsyntax/ast_util.rs

@@ -312,9 +312,9 @@ fn ident_to_path(s: span, +i: ident) -> @path {
 }
 
 fn ident_to_pat(id: node_id, s: span, +i: ident) -> @pat {
-    @{id: id,
-      node: pat_ident(bind_by_value, ident_to_path(s, i), None),
-      span: s}
+    @ast::pat { id: id,
+                node: pat_ident(bind_by_value, ident_to_path(s, i), None),
+                span: s }
 }
 
 pure fn is_unguarded(a: &arm) -> bool {

branches/dist-snap/src/libsyntax/ext/auto_encode.rs

@@ -317,11 +317,14 @@ priv impl ext_ctxt {
     }
 
     fn binder_pat(span: span, nm: ast::ident) -> @ast::pat {
-        @{id: self.next_id(),
-          node: ast::pat_ident(ast::bind_by_ref(ast::m_imm),
-                               self.path(span, ~[nm]),
-                               None),
-          span: span}
+        @ast::pat {
+            id: self.next_id(),
+            node: ast::pat_ident(
+                ast::bind_by_ref(ast::m_imm),
+                self.path(span, ~[nm]),
+                None),
+            span: span,
+        }
     }
 
     fn stmt(expr: @ast::expr) -> @ast::stmt {
@@ -579,12 +582,14 @@ fn mk_ser_method(
     let ser_inputs = ~[{
         mode: ast::infer(cx.next_id()),
         ty: ty_s,
-        pat: @{id: cx.next_id(),
-               node: ast::pat_ident(
-                    ast::bind_by_value,
-                    ast_util::ident_to_path(span, cx.ident_of(~"__s")),
-                    None),
-               span: span},
+        pat: @ast::pat {
+            id: cx.next_id(),
+            node: ast::pat_ident(
+                ast::bind_by_value,
+                ast_util::ident_to_path(span, cx.ident_of(~"__s")),
+                None),
+            span: span,
+        },
         id: cx.next_id(),
     }];
 
@@ -640,12 +645,14 @@ fn mk_deser_method(
     let deser_inputs = ~[{
         mode: ast::infer(cx.next_id()),
         ty: ty_d,
-        pat: @{id: cx.next_id(),
-               node: ast::pat_ident(
-                    ast::bind_by_value,
-                    ast_util::ident_to_path(span, cx.ident_of(~"__d")),
-                    None),
-               span: span},
+        pat: @ast::pat {
+            id: cx.next_id(),
+            node: ast::pat_ident(
+                ast::bind_by_value,
+                ast_util::ident_to_path(span, cx.ident_of(~"__d")),
+                None),
+            span: span,
+        },
         id: cx.next_id(),
     }];
 
@@ -967,7 +974,7 @@ fn ser_variant(
         )
     };
 
-    let pat = @{
+    let pat = @ast::pat {
         id: cx.next_id(),
         node: pat_node,
         span: span,
@@ -1020,7 +1027,7 @@ fn ser_variant(
         ]
     );
 
-    { pats: ~[pat], guard: None, body: cx.expr_blk(body) }
+    ast::arm { pats: ~[pat], guard: None, body: cx.expr_blk(body) }
 }
 
 fn mk_enum_ser_body(
@@ -1132,21 +1139,25 @@ fn mk_enum_deser_body(
                 fail ~"enum variants unimplemented",
         };
 
-        let pat = @{
+        let pat = @ast::pat {
             id: cx.next_id(),
             node: ast::pat_lit(cx.lit_uint(span, v_idx)),
             span: span,
         };
 
-        {
+        ast::arm {
             pats: ~[pat],
             guard: None,
             body: cx.expr_blk(body),
         }
     };
 
-    let impossible_case = {
-        pats: ~[@{ id: cx.next_id(), node: ast::pat_wild, span: span}],
+    let impossible_case = ast::arm {
+        pats: ~[@ast::pat {
+            id: cx.next_id(),
+            node: ast::pat_wild,
+            span: span,
+        }],
         guard: None,
 
         // FIXME(#3198): proper error message
@@ -1167,13 +1178,14 @@ fn mk_enum_deser_body(
                         node: ast::ty_infer,
                         span: span
                     },
-                    pat: @{id: cx.next_id(),
-                           node: ast::pat_ident(
-                                ast::bind_by_value,
-                                ast_util::ident_to_path(span,
-                                                        cx.ident_of(~"i")),
-                                None),
-                           span: span},
+                    pat: @ast::pat {
+                        id: cx.next_id(),
+                        node: ast::pat_ident(
+                            ast::bind_by_value,
+                            ast_util::ident_to_path(span, cx.ident_of(~"i")),
+                            None),
+                        span: span,
+                    },
                     id: cx.next_id(),
                 }],
                 output: @{

branches/dist-snap/src/libsyntax/ext/build.rs

@@ -181,18 +181,25 @@ fn mk_glob_use(cx: ext_ctxt, sp: span,
 fn mk_local(cx: ext_ctxt, sp: span, mutbl: bool,
             ident: ast::ident, ex: @ast::expr) -> @ast::stmt {
 
-    let pat : @ast::pat = @{id: cx.next_id(),
-                            node: ast::pat_ident(ast::bind_by_value,
-                                                 mk_raw_path(sp, ~[ident]),
-                                                 None),
-                           span: sp};
+    let pat = @ast::pat {
+        id: cx.next_id(),
+        node: ast::pat_ident(
+            ast::bind_by_value,
+            mk_raw_path(sp, ~[ident]),
+            None),
+        span: sp,
+    };
     let ty : @ast::Ty = @{ id: cx.next_id(), node: ast::ty_infer, span: sp };
-    let local : @ast::local = @ast::spanned { node: { is_mutbl: mutbl,
-                                                      ty: ty,
-                                                      pat: pat,
-                                                      init: Some(ex),
-                                                      id: cx.next_id()},
-                                              span: sp};
+    let local = @ast::spanned {
+        node: ast::local_ {
+            is_mutbl: mutbl,
+            ty: ty,
+            pat: pat,
+            init: Some(ex),
+            id: cx.next_id(),
+        },
+        span: sp,
+    };
     let decl = ast::spanned {node: ast::decl_local(~[local]), span: sp};
     @ast::spanned { node: ast::stmt_decl(@decl, cx.next_id()), span: sp }
 }
@@ -243,7 +250,7 @@ fn mk_managed(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_unary(ast::box(ast::m_imm), e))
 }
 fn mk_pat(cx: ext_ctxt, span: span, +pat: ast::pat_) -> @ast::pat {
-    @{ id: cx.next_id(), node: move pat, span: span }
+    @ast::pat { id: cx.next_id(), node: pat, span: span }
 }
 fn mk_pat_ident(cx: ext_ctxt, span: span, ident: ast::ident) -> @ast::pat {
     let path = mk_raw_path(span, ~[ ident ]);