convert ast::blk_ into a struct

8 files changed, 109 insertions, 66 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 0dd0555e8e8..6aa976691e8 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -313,11 +313,13 @@ type blk = spanned<blk_>;
 
 #[auto_encode]
 #[auto_decode]
-type blk_ = {view_items: ~[@view_item],
-             stmts: ~[@stmt],
-             expr: Option<@expr>,
-             id: node_id,
-             rules: blk_check_mode};
+struct blk_ {
+    view_items: ~[@view_item],
+    stmts: ~[@stmt],
+    expr: Option<@expr>,
+    id: node_id,
+    rules: blk_check_mode,
+}
 
 #[auto_encode]
 #[auto_decode]
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 113556e3895..235820fdd1c 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -289,10 +289,18 @@ fn block_from_expr(e: @expr) -> blk {
     return spanned {node: blk_, span: e.span};
 }
 
-fn default_block(+stmts1: ~[@stmt], expr1: Option<@expr>, id1: node_id) ->
-   blk_ {
-    {view_items: ~[], stmts: stmts1,
-     expr: expr1, id: id1, rules: default_blk}
+fn default_block(
+    +stmts1: ~[@stmt],
+    expr1: Option<@expr>,
+    id1: node_id
+) -> blk_ {
+    ast::blk_ {
+        view_items: ~[],
+        stmts: stmts1,
+        expr: expr1,
+        id: id1,
+        rules: default_blk,
+    }
 }
 
 fn ident_to_path(s: span, +i: ident) -> @path {
diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs
index 2e9876e2861..cd2cafb3699 100644
--- a/src/libsyntax/ext/auto_encode.rs
+++ b/src/libsyntax/ext/auto_encode.rs
@@ -356,21 +356,29 @@ priv impl ext_ctxt {
     }
 
     fn blk(span: span, stmts: ~[@ast::stmt]) -> ast::blk {
-        ast::spanned { node: { view_items: ~[],
-                               stmts: stmts,
-                               expr: None,
-                               id: self.next_id(),
-                               rules: ast::default_blk},
-                       span: span }
+        ast::spanned {
+            node: ast::blk_ {
+                view_items: ~[],
+                stmts: stmts,
+                expr: None,
+                id: self.next_id(),
+                rules: ast::default_blk,
+            },
+            span: span,
+        }
     }
 
     fn expr_blk(expr: @ast::expr) -> ast::blk {
-        ast::spanned { node: { view_items: ~[],
-                               stmts: ~[],
-                               expr: Some(expr),
-                               id: self.next_id(),
-                               rules: ast::default_blk},
-                       span: expr.span }
+        ast::spanned {
+            node: ast::blk_ {
+                view_items: ~[],
+                stmts: ~[],
+                expr: Some(expr),
+                id: self.next_id(),
+                rules: ast::default_blk,
+            },
+            span: expr.span,
+        }
     }
 
     fn expr_path(span: span, strs: ~[ast::ident]) -> @ast::expr {
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 4d02c4bc40c..df40dc1ed29 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -196,39 +196,45 @@ fn mk_local(cx: ext_ctxt, sp: span, mutbl: bool,
     let decl = ast::spanned {node: ast::decl_local(~[local]), span: sp};
     @ast::spanned { node: ast::stmt_decl(@decl, cx.next_id()), span: sp }
 }
-fn mk_block(cx: ext_ctxt, sp: span,
+fn mk_block(cx: ext_ctxt, span: span,
             view_items: ~[@ast::view_item],
             stmts: ~[@ast::stmt],
             expr: Option<@ast::expr>) -> @ast::expr {
-    let blk = ast::spanned { node: { view_items: view_items,
-                                     stmts: stmts,
-                                     expr: expr,
-                                     id: cx.next_id(),
-                                     rules: ast::default_blk },
-                             span: sp };
-    mk_expr(cx, sp, ast::expr_block(blk))
-}
-fn mk_block_(cx: ext_ctxt, sp: span, +stmts: ~[@ast::stmt]) -> ast::blk {
+    let blk = ast::spanned {
+        node: ast::blk_ {
+             view_items: view_items,
+             stmts: stmts,
+             expr: expr,
+             id: cx.next_id(),
+             rules: ast::default_blk,
+        },
+        span: span,
+    };
+    mk_expr(cx, span, ast::expr_block(blk))
+}
+fn mk_block_(cx: ext_ctxt, span: span, +stmts: ~[@ast::stmt]) -> ast::blk {
     ast::spanned {
-        node: {
+        node: ast::blk_ {
             view_items: ~[],
-            stmts: move stmts,
+            stmts: stmts,
             expr: None,
             id: cx.next_id(),
-            rules: ast::default_blk
+            rules: ast::default_blk,
         },
-        span: sp
+        span: span,
     }
 }
 fn mk_simple_block(cx: ext_ctxt, span: span, expr: @ast::expr) -> ast::blk {
-    let block = {
-        view_items: ~[],
-        stmts: ~[],
-        expr: Some(expr),
-        id: cx.next_id(),
-        rules: ast::default_blk
-    };
-    ast::spanned { node: block, span: span }
+    ast::spanned {
+        node: ast::blk_ {
+            view_items: ~[],
+            stmts: ~[],
+            expr: Some(expr),
+            id: cx.next_id(),
+            rules: ast::default_blk,
+        },
+        span: span,
+    }
 }
 fn mk_copy(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_copy(e))
diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs
index 66d8cde0124..f5b6ca953b3 100644
--- a/src/libsyntax/ext/pipes/ast_builder.rs
+++ b/src/libsyntax/ext/pipes/ast_builder.rs
@@ -193,11 +193,13 @@ impl ext_ctxt: ext_ctxt_ast_builder {
     }
 
     fn block(+stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk {
-        let blk = {view_items: ~[],
-                   stmts: stmts,
-                   expr: Some(e),
-                   id: self.next_id(),
-                   rules: ast::default_blk};
+        let blk = ast::blk_ {
+            view_items: ~[],
+            stmts: stmts,
+            expr: Some(e),
+            id: self.next_id(),
+            rules: ast::default_blk,
+        };
 
         spanned { node: blk, span: dummy_sp() }
     }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index c4c3b854e55..ecb53072f7e 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -319,11 +319,13 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
 
 
 fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
-    return {view_items: vec::map(b.view_items, |x| fld.fold_view_item(*x)),
-         stmts: vec::map(b.stmts, |x| fld.fold_stmt(*x)),
-         expr: option::map(&b.expr, |x| fld.fold_expr(*x)),
-         id: fld.new_id(b.id),
-         rules: b.rules};
+    ast::blk_ {
+        view_items: b.view_items.map(|x| fld.fold_view_item(*x)),
+        stmts: b.stmts.map(|x| fld.fold_stmt(*x)),
+        expr: b.expr.map(|x| fld.fold_expr(*x)),
+        id: fld.new_id(b.id),
+        rules: b.rules,
+    }
 }
 
 fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index 04316e05b64..f0cff630b11 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -30,8 +30,9 @@ fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
 
 fn expr_is_simple_block(e: @ast::expr) -> bool {
     match e.node {
-      ast::expr_block(ast::spanned {node: {rules: ast::default_blk, _}, _}) =>
-        true,
+        ast::expr_block(
+            ast::spanned { node: ast::blk_ { rules: ast::default_blk, _ }, _ }
+        ) => true,
       _ => false
     }
 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index ce1e67be79e..b7ecbbcaa19 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1574,8 +1574,13 @@ impl Parser {
         let lo = self.last_span.lo;
         let (decl, captures) = parse_decl();
         let body = parse_body();
-        let fakeblock = {view_items: ~[], stmts: ~[], expr: Some(body),
-                         id: self.get_id(), rules: default_blk};
+        let fakeblock = ast::blk_ {
+            view_items: ~[],
+            stmts: ~[],
+            expr: Some(body),
+            id: self.get_id(),
+            rules: default_blk,
+        };
         let fakeblock = spanned(body.span.lo, body.span.hi,
                                 fakeblock);
         return self.mk_expr(lo, body.span.hi,
@@ -1753,12 +1758,16 @@ impl Parser {
                 self.eat(token::COMMA);
             }
 
-            let blk = spanned { node: { view_items: ~[],
-                                        stmts: ~[],
-                                        expr: Some(expr),
-                                        id: self.get_id(),
-                                        rules: default_blk},
-                                span: expr.span };
+            let blk = spanned {
+                node: ast::blk_ {
+                    view_items: ~[],
+                    stmts: ~[],
+                    expr: Some(expr),
+                    id: self.get_id(),
+                    rules: default_blk,
+                },
+                span: expr.span,
+            };
 
             arms.push({pats: pats, guard: guard, body: blk});
         }
@@ -2378,9 +2387,14 @@ impl Parser {
         }
         let mut hi = self.span.hi;
         self.bump();
-        let bloc = {view_items: view_items, stmts: stmts, expr: expr,
-                    id: self.get_id(), rules: s};
-        return spanned(lo, hi, bloc);
+        let bloc = ast::blk_ {
+            view_items: view_items,
+            stmts: stmts,
+            expr: expr,
+            id: self.get_id(),
+            rules: s,
+        };
+        spanned(lo, hi, bloc)
     }
 
     fn mk_ty_path(i: ident) -> @Ty {