Made ast::blk not use spanned<T> anymore.

11 files changed, 81 insertions, 84 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index b6275ed186c..6cf38d5ae1d 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -215,15 +215,16 @@ pub enum meta_item_ {
     meta_name_value(@str, lit),
 }
 
-pub type blk = spanned<blk_>;
+//pub type blk = spanned<blk_>;
 
 #[deriving(Eq, Encodable, Decodable,IterBytes)]
-pub struct blk_ {
+pub struct blk {
     view_items: ~[view_item],
     stmts: ~[@stmt],
     expr: Option<@expr>,
     id: node_id,
     rules: blk_check_mode,
+    span: span,
 }
 
 #[deriving(Eq, Encodable, Decodable,IterBytes)]
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index e7eedcaa62e..354471fc2a1 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -190,7 +190,7 @@ pub fn map_fn(
 }
 
 pub fn map_block(b: &blk, (cx,v): (@mut Ctx, visit::vt<@mut Ctx>)) {
-    cx.map.insert(b.node.id, node_block(/* FIXME (#2543) */ copy *b));
+    cx.map.insert(b.id, node_block(/* FIXME (#2543) */ copy *b));
     visit::visit_block(b, (cx, v));
 }
 
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index a1d209d19ac..00e667d7b88 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -11,7 +11,7 @@
 use ast::*;
 use ast;
 use ast_util;
-use codemap::{span, spanned};
+use codemap::{span, dummy_sp};
 use opt_vec;
 use parse::token;
 use visit;
@@ -194,21 +194,23 @@ pub fn is_call_expr(e: @expr) -> bool {
 }
 
 pub fn block_from_expr(e: @expr) -> blk {
-    let blk_ = default_block(~[], option::Some::<@expr>(e), e.id);
-    return spanned {node: blk_, span: e.span};
+    let mut blk = default_block(~[], option::Some::<@expr>(e), e.id);
+    blk.span = e.span;
+    return blk;
 }
 
 pub fn default_block(
     stmts1: ~[@stmt],
     expr1: Option<@expr>,
     id1: node_id
-) -> blk_ {
-    ast::blk_ {
+) -> blk {
+    ast::blk {
         view_items: ~[],
         stmts: stmts1,
         expr: expr1,
         id: id1,
         rules: default_blk,
+        span: dummy_sp(),
     }
 }
 
@@ -437,7 +439,7 @@ pub fn id_visitor<T: Copy>(vfn: @fn(node_id, T)) -> visit::vt<T> {
             visit::visit_local(l, (t, vt));
         },
         visit_block: |b, (t, vt)| {
-            vfn(b.node.id, copy t);
+            vfn(b.id, copy t);
             visit::visit_block(b, (t, vt));
         },
         visit_stmt: |s, (t, vt)| {
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 73220ec2881..83fce24bef8 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -400,14 +400,14 @@ impl AstBuilder for @ExtCtxt {
                view_items: ~[ast::view_item],
                stmts: ~[@ast::stmt],
                expr: Option<@ast::expr>) -> ast::blk {
-        respan(span,
-               ast::blk_ {
-                   view_items: view_items,
-                   stmts: stmts,
-                   expr: expr,
-                   id: self.next_id(),
-                   rules: ast::default_blk,
-               })
+           ast::blk {
+               view_items: view_items,
+               stmts: stmts,
+               expr: expr,
+               id: self.next_id(),
+               rules: ast::default_blk,
+               span: span,
+           }
     }
 
     fn expr(&self, span: span, node: ast::expr_) -> @ast::expr {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index c421da06795..3f7579c7691 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ast::{blk_, crate, expr_, expr_mac, mac_invoc_tt};
+use ast::{blk, crate, expr_, expr_mac, mac_invoc_tt};
 use ast::{item_mac, stmt_, stmt_mac, stmt_expr, stmt_semi};
 use ast::{illegal_ctxt};
 use ast;
@@ -394,13 +394,12 @@ pub fn new_name_finder() -> @Visitor<@mut ~[ast::ident]> {
 
 pub fn expand_block(extsbox: @mut SyntaxEnv,
                     _cx: @ExtCtxt,
-                    blk: &blk_,
-                    sp: span,
+                    blk: &blk,
                     fld: @ast_fold,
-                    orig: @fn(&blk_, span, @ast_fold) -> (blk_, span))
-                 -> (blk_, span) {
+                    orig: @fn(&blk, @ast_fold) -> blk)
+                 -> blk {
     // see note below about treatment of exts table
-    with_exts_frame!(extsbox,false,orig(blk,sp,fld))
+    with_exts_frame!(extsbox,false,orig(blk,fld))
 }
 
 
@@ -736,8 +735,8 @@ pub fn expand_crate(parse_sess: @mut parse::ParseSess,
             expand_item(extsbox, cx, item, recur, afp.fold_item),
         fold_stmt: |stmt,span,recur|
             expand_stmt(extsbox, cx, stmt, span, recur, afp.fold_stmt),
-        fold_block: |blk,span,recur|
-            expand_block(extsbox, cx, blk, span, recur, afp.fold_block),
+        fold_block: |blk,recur|
+            expand_block(extsbox, cx, blk, recur, afp.fold_block),
         new_span: |a| new_span(cx, a),
         .. *afp};
     let f = make_fold(f_pre);
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index c36b717ea00..059637ca736 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -51,7 +51,7 @@ pub struct AstFoldFns {
     fold_struct_field: @fn(@struct_field, @ast_fold) -> @struct_field,
     fold_item_underscore: @fn(&item_, @ast_fold) -> item_,
     fold_method: @fn(@method, @ast_fold) -> @method,
-    fold_block: @fn(&blk_, span, @ast_fold) -> (blk_, span),
+    fold_block: @fn(&blk, @ast_fold) -> blk,
     fold_stmt: @fn(&stmt_, span, @ast_fold) -> (Option<stmt_>, span),
     fold_arm: @fn(&arm, @ast_fold) -> arm,
     fold_pat: @fn(&pat_, span, @ast_fold) -> (pat_, span),
@@ -372,7 +372,7 @@ fn noop_fold_method(m: @method, fld: @ast_fold) -> @method {
 }
 
 
-pub fn noop_fold_block(b: &blk_, fld: @ast_fold) -> blk_ {
+pub fn noop_fold_block(b: &blk, fld: @ast_fold) -> blk {
     let view_items = b.view_items.map(|x| fld.fold_view_item(x));
     let mut stmts = ~[];
     for b.stmts.iter().advance |stmt| {
@@ -381,12 +381,13 @@ pub fn noop_fold_block(b: &blk_, fld: @ast_fold) -> blk_ {
             Some(stmt) => stmts.push(stmt)
         }
     }
-    ast::blk_ {
+    ast::blk {
         view_items: view_items,
         stmts: stmts,
         expr: b.expr.map(|x| fld.fold_expr(*x)),
         id: fld.new_id(b.id),
         rules: b.rules,
+        span: b.span,
     }
 }
 
@@ -794,7 +795,7 @@ pub fn default_ast_fold() -> ast_fold_fns {
         fold_struct_field: noop_fold_struct_field,
         fold_item_underscore: noop_fold_item_underscore,
         fold_method: noop_fold_method,
-        fold_block: wrap(noop_fold_block),
+        fold_block: noop_fold_block,
         fold_stmt: |x, s, fld| (noop_fold_stmt(x, fld), s),
         fold_arm: noop_fold_arm,
         fold_pat: wrap(noop_fold_pat),
@@ -851,8 +852,7 @@ impl ast_fold for AstFoldFns {
         (self.fold_method)(x, self as @ast_fold)
     }
     fn fold_block(@self, x: &blk) -> blk {
-        let (n, s) = (self.fold_block)(&x.node, x.span, self as @ast_fold);
-        spanned { node: n, span: (self.new_span)(s) }
+        (self.fold_block)(x, self as @ast_fold)
     }
     fn fold_stmt(@self, x: &stmt) -> Option<@stmt> {
         let (n_opt, s) = (self.fold_stmt)(&x.node, x.span, self as @ast_fold);
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index 62b36b12f26..44497f72003 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -13,7 +13,6 @@
  */
 
 use ast;
-use codemap;
 
 // does this expression require a semicolon to be treated
 // as a statement? The negation of this: 'can this expression
@@ -40,8 +39,7 @@ pub fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
 pub fn expr_is_simple_block(e: @ast::expr) -> bool {
     match e.node {
         ast::expr_block(
-            codemap::spanned {
-                node: ast::blk_ { rules: ast::default_blk, _ }, _ }
+            ast::blk { rules: ast::default_blk, _ }
         ) => true,
       _ => false
     }
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 75d1f35bf38..40f1964bc9c 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -557,27 +557,26 @@ mod test {
                                         lifetimes: opt_vec::Empty,
                                         ty_params: opt_vec::Empty,
                                     },
-                                    spanned{
+                                    ast::blk {
+                                        view_items: ~[],
+                                        stmts: ~[@spanned{
+                                            node: ast::stmt_semi(@ast::expr{
+                                                id: 6,
+                                                node: ast::expr_path(
+                                                      ast::Path{
+                                                        span:sp(17,18),
+                                                        global:false,
+                                                        idents:~[str_to_ident("b")],
+                                                        rp:None,
+                                                        types: ~[]}),
+                                                span: sp(17,18)},
+                                                                 7), // fixme
+                                            span: sp(17,18)}],
+                                        expr: None,
+                                        id: 8, // fixme
+                                        rules: ast::default_blk, // no idea
                                         span: sp(15,21),
-                                        node: ast::blk_{
-                                            view_items: ~[],
-                                            stmts: ~[@spanned{
-                                                node: ast::stmt_semi(@ast::expr{
-                                                    id: 6,
-                                                    node: ast::expr_path(
-                                                          ast::Path{
-                                                            span:sp(17,18),
-                                                            global:false,
-                                                            idents:~[str_to_ident("b")],
-                                                            rp:None,
-                                                            types: ~[]}),
-                                                    span: sp(17,18)},
-                                                                     7), // fixme
-                                                span: sp(17,18)}],
-                                            expr: None,
-                                            id: 8, // fixme
-                                            rules: ast::default_blk // no idea
-                                        }}),
+                                    }),
                             vis: ast::inherited,
                             span: sp(0,21)}));
     }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 05dda16214a..9e9071d6b8c 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2245,15 +2245,15 @@ impl Parser {
         let lo = self.last_span.lo;
         let decl = parse_decl();
         let body = parse_body();
-        let fakeblock = ast::blk_ {
+        let fakeblock = ast::blk {
             view_items: ~[],
             stmts: ~[],
             expr: Some(body),
             id: self.get_id(),
             rules: default_blk,
+            span: body.span,
         };
-        let fakeblock = spanned(body.span.lo, body.span.hi,
-                                fakeblock);
+
         return self.mk_expr(lo, body.span.hi,
                             expr_fn_block(decl, fakeblock));
     }
@@ -2402,14 +2402,12 @@ impl Parser {
                 self.eat(&token::COMMA);
             }
 
-            let blk = codemap::spanned {
-                node: ast::blk_ {
-                    view_items: ~[],
-                    stmts: ~[],
-                    expr: Some(expr),
-                    id: self.get_id(),
-                    rules: default_blk,
-                },
+            let blk = ast::blk {
+                view_items: ~[],
+                stmts: ~[],
+                expr: Some(expr),
+                id: self.get_id(),
+                rules: default_blk,
                 span: expr.span,
             };
 
@@ -3120,14 +3118,14 @@ impl Parser {
 
         let hi = self.span.hi;
         self.bump();
-        let bloc = ast::blk_ {
+        ast::blk {
             view_items: view_items,
             stmts: stmts,
             expr: expr,
             id: self.get_id(),
             rules: s,
-        };
-        spanned(lo, hi, bloc)
+            span: mk_sp(lo, hi),
+        }
     }
 
     fn parse_optional_purity(&self) -> ast::purity {
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index c3710853615..67d5f4aa845 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -932,7 +932,7 @@ pub fn print_possibly_embedded_block_(s: @ps,
                                       indented: uint,
                                       attrs: &[ast::attribute],
                                       close_box: bool) {
-    match blk.node.rules {
+    match blk.rules {
       ast::unsafe_blk => word_space(s, "unsafe"),
       ast::default_blk => ()
     }
@@ -946,11 +946,11 @@ pub fn print_possibly_embedded_block_(s: @ps,
 
     print_inner_attributes(s, attrs);
 
-    for blk.node.view_items.iter().advance |vi| { print_view_item(s, vi); }
-    for blk.node.stmts.iter().advance |st| {
+    for blk.view_items.iter().advance |vi| { print_view_item(s, vi); }
+    for blk.stmts.iter().advance |st| {
         print_stmt(s, *st);
     }
-    match blk.node.expr {
+    match blk.expr {
       Some(expr) => {
         space_if_not_bol(s);
         print_expr(s, expr);
@@ -1255,12 +1255,12 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
 
             // Extract the expression from the extra block the parser adds
             // in the case of foo => expr
-            if arm.body.node.view_items.is_empty() &&
-                arm.body.node.stmts.is_empty() &&
-                arm.body.node.rules == ast::default_blk &&
-                arm.body.node.expr.is_some()
+            if arm.body.view_items.is_empty() &&
+                arm.body.stmts.is_empty() &&
+                arm.body.rules == ast::default_blk &&
+                arm.body.expr.is_some()
             {
-                match arm.body.node.expr {
+                match arm.body.expr {
                     Some(expr) => {
                         match expr.node {
                             ast::expr_block(ref blk) => {
@@ -1297,16 +1297,16 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         print_fn_block_args(s, decl);
         space(s.s);
         // }
-        assert!(body.node.stmts.is_empty());
-        assert!(body.node.expr.is_some());
+        assert!(body.stmts.is_empty());
+        assert!(body.expr.is_some());
         // we extract the block, so as not to create another set of boxes
-        match body.node.expr.get().node {
+        match body.expr.get().node {
             ast::expr_block(ref blk) => {
                 print_block_unclosed(s, blk);
             }
             _ => {
                 // this is a bare expression
-                print_expr(s, body.node.expr.get());
+                print_expr(s, body.expr.get());
                 end(s); // need to close a box
             }
         }
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index b2d9d49f0ee..09daa2e648a 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -413,13 +413,13 @@ pub fn visit_struct_field<E: Copy>(sf: &struct_field, (e, v): (E, vt<E>)) {
 }
 
 pub fn visit_block<E: Copy>(b: &blk, (e, v): (E, vt<E>)) {
-    for b.node.view_items.iter().advance |vi| {
+    for b.view_items.iter().advance |vi| {
         (v.visit_view_item)(vi, (copy e, v));
     }
-    for b.node.stmts.iter().advance |s| {
+    for b.stmts.iter().advance |s| {
         (v.visit_stmt)(*s, (copy e, v));
     }
-    visit_expr_opt(b.node.expr, (e, v));
+    visit_expr_opt(b.expr, (e, v));
 }
 
 pub fn visit_stmt<E>(s: &stmt, (e, v): (E, vt<E>)) {