syntax: convert ast::spanned into a struct

31 files changed, 245 insertions, 210 deletions

diff --git a/src/libcargo/cargo.rc b/src/libcargo/cargo.rc
index 8d81f75e0da..f588f3643ce 100644
--- a/src/libcargo/cargo.rc
+++ b/src/libcargo/cargo.rc
@@ -294,7 +294,8 @@ fn load_link(mis: ~[@ast::meta_item]) -> (Option<~str>,
     let mut uuid = None;
     for mis.each |a| {
         match a.node {
-            ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
+            ast::meta_name_value(v, ast::spanned { node: ast::lit_str(s),
+                                                   _ }) => {
                 match v {
                     ~"name" => name = Some(*s),
                     ~"vers" => vers = Some(*s),
@@ -321,7 +322,8 @@ fn load_crate(filename: &Path) -> Option<Crate> {
 
     for c.node.attrs.each |a| {
         match a.node.value.node {
-            ast::meta_name_value(v, {node: ast::lit_str(_), span: _}) => {
+            ast::meta_name_value(v, ast::spanned { node: ast::lit_str(_),
+                                                   _ }) => {
                 match v {
                     ~"desc" => desc = Some(v),
                     ~"sigs" => sigs = Some(v),
diff --git a/src/libfuzzer/fuzzer.rc b/src/libfuzzer/fuzzer.rc
index cf242ddd8e2..de8ce8fc370 100644
--- a/src/libfuzzer/fuzzer.rc
+++ b/src/libfuzzer/fuzzer.rc
@@ -81,7 +81,7 @@ fn common_exprs() -> ~[ast::expr] {
     }
 
     fn dsl(l: ast::lit_) -> ast::lit {
-        { node: l, span: ast_util::dummy_sp() }
+        ast::spanned { node: l, span: ast_util::dummy_sp() }
     }
 
     ~[dse(ast::expr_break(option::None)),
diff --git a/src/librustc/front/core_inject.rs b/src/librustc/front/core_inject.rs
index 9bd7566e2e7..772bd39e07b 100644
--- a/src/librustc/front/core_inject.rs
+++ b/src/librustc/front/core_inject.rs
@@ -39,7 +39,7 @@ fn use_core(crate: @ast::crate) -> bool {
 fn inject_libcore_ref(sess: Session,
                       crate: @ast::crate) -> @ast::crate {
     fn spanned<T: Copy>(x: T) -> ast::spanned<T> {
-        return {node: x, span: dummy_sp()};
+        ast::spanned { node: x, span: dummy_sp() }
     }
 
     let precursor = @{
diff --git a/src/librustc/front/intrinsic_inject.rs b/src/librustc/front/intrinsic_inject.rs
index bad8ca88ad8..14d31e2f841 100644
--- a/src/librustc/front/intrinsic_inject.rs
+++ b/src/librustc/front/intrinsic_inject.rs
@@ -36,6 +36,9 @@ fn inject_intrinsic(sess: Session, crate: @ast::crate) -> @ast::crate {
 
     let items = vec::append(~[item], crate.node.module.items);
 
-    return @{node: {module: { items: items ,.. /*bad*/copy crate.node.module }
-                 ,.. /*bad*/copy crate.node} ,.. /*bad*/copy *crate }
+    @ast::spanned {
+        node: { module: { items: items ,.. /*bad*/copy crate.node.module },
+                .. /*bad*/copy crate.node},
+        .. /*bad*/copy *crate
+    }
 }
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
index 1e2063649b0..497a6878bc1 100644
--- a/src/librustc/front/test.rs
+++ b/src/librustc/front/test.rs
@@ -242,7 +242,7 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item {
 }
 
 fn nospan<T: Copy>(t: T) -> ast::spanned<T> {
-    return {node: t, span: dummy_sp()};
+    ast::spanned { node: t, span: dummy_sp() }
 }
 
 fn path_node(+ids: ~[ast::ident]) -> @ast::path {
@@ -489,7 +489,7 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
     let body_: ast::blk_ =
         default_block(~[], option::Some(test_main_call_expr),
                       cx.sess.next_node_id());
-    let body = {node: body_, span: dummy_sp()};
+    let body = ast::spanned { node: body_, span: dummy_sp() };
 
     let item_ = ast::item_fn(decl, ast::impure_fn, ~[], body);
     let item: ast::item =
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index dbc70f1318c..081a92f686b 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -1031,9 +1031,10 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
             assert (vec::len(meta_items) == 1u);
             let meta_item = meta_items[0];
             attrs.push(
-                {node: {style: ast::attr_outer, value: /*bad*/copy *meta_item,
-                        is_sugared_doc: false},
-                 span: ast_util::dummy_sp()});
+                ast::spanned { node: { style: ast::attr_outer,
+                                       value: /*bad*/copy *meta_item,
+                                       is_sugared_doc: false },
+                               span: ast_util::dummy_sp()});
         };
       }
       option::None => ()
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index c2f2d7711af..45e4b9f328f 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -259,8 +259,10 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
         let stmts_sans_items = do vec::filter(blk.stmts) |stmt| {
             match stmt.node {
               ast::stmt_expr(_, _) | ast::stmt_semi(_, _) |
-              ast::stmt_decl(@{node: ast::decl_local(_), span: _}, _) => true,
-              ast::stmt_decl(@{node: ast::decl_item(_), span: _}, _) => false,
+              ast::stmt_decl(@ast::spanned { node: ast::decl_local(_),
+                                             span: _}, _) => true,
+              ast::stmt_decl(@ast::spanned { node: ast::decl_item(_),
+                                             span: _}, _) => false,
               ast::stmt_mac(*) => fail ~"unexpanded macro in astencode"
             }
         };
@@ -286,9 +288,10 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
       }
       ast::ii_dtor(ref dtor, nm, ref tps, parent_id) => {
         let dtor_body = fld.fold_block((*dtor).node.body);
-        ast::ii_dtor({node: {body: dtor_body,
-                              .. /*bad*/copy (*dtor).node},
-            .. (/*bad*/copy *dtor)}, nm, /*bad*/copy *tps, parent_id)
+        ast::ii_dtor(ast::spanned { node: { body: dtor_body,
+                                            .. /*bad*/copy (*dtor).node },
+                                    .. (/*bad*/copy *dtor) },
+                     nm, /*bad*/copy *tps, parent_id)
       }
     }
 }
@@ -324,9 +327,11 @@ fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
         let dtor_id = fld.new_id((*dtor).node.id);
         let new_parent = xcx.tr_def_id(parent_id);
         let new_self = fld.new_id((*dtor).node.self_id);
-        ast::ii_dtor({node: {id: dtor_id, attrs: dtor_attrs,
-                self_id: new_self, body: dtor_body},
-                        .. (/*bad*/copy *dtor)},
+        ast::ii_dtor(ast::spanned { node: { id: dtor_id,
+                                            attrs: dtor_attrs,
+                                            self_id: new_self,
+                                            body: dtor_body },
+                                    .. (/*bad*/copy *dtor)},
           nm, new_params, new_parent)
       }
      }
diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs
index b8d222aecd7..0166c8da410 100644
--- a/src/librustc/middle/check_const.rs
+++ b/src/librustc/middle/check_const.rs
@@ -57,7 +57,8 @@ fn check_item(sess: Session, ast_map: ast_map::map,
 fn check_pat(p: @pat, &&_is_const: bool, v: visit::vt<bool>) {
     fn is_str(e: @expr) -> bool {
         match e.node {
-          expr_vstore(@{node: expr_lit(@{node: lit_str(_), _}), _},
+          expr_vstore(@{node: expr_lit(@spanned { node: lit_str(_),
+                                                  _}), _},
                       expr_vstore_uniq) => true,
           _ => false
         }
@@ -84,7 +85,7 @@ fn check_expr(sess: Session, def_map: resolve::DefMap,
                           ~"disallowed operator in constant expression");
             return;
           }
-          expr_lit(@{node: lit_str(_), _}) => { }
+          expr_lit(@spanned {node: lit_str(_), _}) => { }
           expr_binary(_, _, _) | expr_unary(_, _) => {
             if method_map.contains_key(e.id) {
                 sess.span_err(e.span, ~"user-defined operators are not \
@@ -170,7 +171,7 @@ fn check_expr(sess: Session, def_map: resolve::DefMap,
         }
     }
     match e.node {
-      expr_lit(@{node: lit_int(v, t), _}) => {
+      expr_lit(@spanned {node: lit_int(v, t), _}) => {
         if t != ty_char {
             if (v as u64) > ast_util::int_ty_max(
                 if t == ty_i { sess.targ_cfg.int_type } else { t }) {
@@ -178,7 +179,7 @@ fn check_expr(sess: Session, def_map: resolve::DefMap,
             }
         }
       }
-      expr_lit(@{node: lit_uint(v, t), _}) => {
+      expr_lit(@spanned {node: lit_uint(v, t), _}) => {
         if v > ast_util::uint_ty_max(
             if t == ty_u { sess.targ_cfg.uint_type } else { t }) {
             sess.span_err(e.span, ~"literal out of range for its type");
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index c70d17423cf..441e800f36f 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -692,7 +692,10 @@ fn is_refutable(cx: @MatchCheckCtxt, pat: &pat) -> bool {
         is_refutable(cx, sub)
       }
       pat_wild | pat_ident(_, _, None) => { false }
-      pat_lit(@{node: expr_lit(@{node: lit_nil, _}), _}) => { false } // "()"
+      pat_lit(@{node: expr_lit(@spanned { node: lit_nil, _}), _}) => {
+        // "()"
+        false
+      }
       pat_lit(_) | pat_range(_, _) => { true }
       pat_rec(fields, _) => {
         fields.any(|f| is_refutable(cx, f.pat))
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
index f2a7dd0648c..5e7002af2a5 100644
--- a/src/librustc/middle/kind.rs
+++ b/src/librustc/middle/kind.rs
@@ -409,7 +409,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
 
 fn check_stmt(stmt: @stmt, cx: ctx, v: visit::vt<ctx>) {
     match stmt.node {
-      stmt_decl(@{node: decl_local(ref locals), _}, _) => {
+      stmt_decl(@spanned {node: decl_local(ref locals), _}, _) => {
         for locals.each |local| {
             match local.node.init {
               Some(expr) =>
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index d5992d201bb..1db7e666ffb 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -467,7 +467,8 @@ fn check_item_while_true(cx: ty::ctxt, it: @ast::item) {
            match e.node {
              ast::expr_while(cond, _) => {
                 match cond.node {
-                    ast::expr_lit(@{node: ast::lit_bool(true),_}) => {
+                    ast::expr_lit(@ast::spanned { node: ast::lit_bool(true),
+                                                  _}) => {
                             cx.sess.span_lint(
                                 while_true, e.id, it.id,
                                 e.span,
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 78c70dd3cf1..668457a6a46 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -1938,7 +1938,8 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         } else {
             for vec::each((*body).node.stmts) |stmt| {
                 match stmt.node {
-                  ast::stmt_decl(@{node: ast::decl_item(i), _}, _) => {
+                  ast::stmt_decl(@ast::spanned { node: ast::decl_item(i),
+                                                 _ }, _) => {
                     trans_item(ccx, *i);
                   }
                   _ => ()
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 40face3655d..50267a5965e 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -545,7 +545,7 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr,
         ast::expr_tup(args) => {
             return trans_tup(bcx, args, dest);
         }
-        ast::expr_lit(@{node: ast::lit_str(s), _}) => {
+        ast::expr_lit(@ast::spanned {node: ast::lit_str(s), _}) => {
             return tvec::trans_lit_str(bcx, expr, s, dest);
         }
         ast::expr_vstore(contents, ast::expr_vstore_slice) |
diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs
index ee44c80943b..11990b5a8b6 100644
--- a/src/librustc/middle/trans/tvec.rs
+++ b/src/librustc/middle/trans/tvec.rs
@@ -197,7 +197,7 @@ fn trans_slice_vstore(bcx: block,
 
     // Handle the &"..." case:
     match content_expr.node {
-        ast::expr_lit(@{node: ast::lit_str(s), span: _}) => {
+        ast::expr_lit(@ast::spanned {node: ast::lit_str(s), span: _}) => {
             return trans_lit_str(bcx, content_expr, s, dest);
         }
         _ => {}
@@ -316,7 +316,7 @@ fn write_content(bcx: block,
     let _indenter = indenter();
 
     match /*bad*/copy content_expr.node {
-        ast::expr_lit(@{node: ast::lit_str(s), span: _}) => {
+        ast::expr_lit(@ast::spanned { node: ast::lit_str(s), _ }) => {
             match dest {
                 Ignore => {
                     return bcx;
@@ -422,7 +422,9 @@ fn elements_required(bcx: block, content_expr: @ast::expr) -> uint {
     //! Figure out the number of elements we need to store this content
 
     match /*bad*/copy content_expr.node {
-        ast::expr_lit(@{node: ast::lit_str(s), span: _}) => s.len() + 1,
+        ast::expr_lit(@ast::spanned { node: ast::lit_str(s), _ }) => {
+            s.len() + 1
+        },
         ast::expr_vec(es, _) => es.len(),
         ast::expr_repeat(_, count_expr, _) => {
             ty::eval_repeat_count(bcx.tcx(), count_expr, content_expr.span)
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index b894b9f50eb..65533571f9a 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -3157,7 +3157,7 @@ fn expr_kind(tcx: ctxt,
         ast::expr_copy(*) |
         ast::expr_unary_move(*) |
         ast::expr_repeat(*) |
-        ast::expr_lit(@{node: lit_str(_), _}) |
+        ast::expr_lit(@ast::spanned {node: lit_str(_), _}) |
         ast::expr_vstore(_, ast::expr_vstore_slice) |
         ast::expr_vstore(_, ast::expr_vstore_mut_slice) |
         ast::expr_vstore(_, ast::expr_vstore_fixed(_)) |
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index d0abd61697d..69b2724c054 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -552,11 +552,12 @@ fn check_struct(ccx: @crate_ctxt, struct_def: @ast::struct_def,
     let self_ty = ty::node_id_to_type(tcx, id);
 
     do struct_def.dtor.iter() |dtor| {
-        let class_t = {self_ty: self_ty,
-                       self_id: dtor.node.self_id,
-                       def_id: local_def(id),
-                       explicit_self: {node: ast::sty_by_ref,
-                                       span: ast_util::dummy_sp()}};
+        let class_t = { self_ty: self_ty,
+                        self_id: dtor.node.self_id,
+                        def_id: local_def(id),
+                        explicit_self:
+                            spanned { node: ast::sty_by_ref,
+                                      span: ast_util::dummy_sp() } };
         // typecheck the dtor
         check_bare_fn(ccx, ast_util::dtor_dec(),
                       dtor.node.body, dtor.node.id,
@@ -1911,7 +1912,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
     match /*bad*/copy expr.node {
       ast::expr_vstore(ev, vst) => {
         let typ = match /*bad*/copy ev.node {
-          ast::expr_lit(@{node: ast::lit_str(s), span:_}) => {
+          ast::expr_lit(@ast::spanned { node: ast::lit_str(s), _ }) => {
             let tt = ast_expr_vstore_to_vstore(fcx, ev, str::len(*s), vst);
             ty::mk_estr(tcx, tt)
           }
@@ -2600,7 +2601,8 @@ fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool {
         for blk.node.stmts.each |s| {
             if bot && !warned &&
                 match s.node {
-                  ast::stmt_decl(@{node: ast::decl_local(_), _}, _) |
+                  ast::stmt_decl(@ast::spanned { node: ast::decl_local(_),
+                                                 _}, _) |
                   ast::stmt_expr(_, _) | ast::stmt_semi(_, _) => {
                     true
                   }
diff --git a/src/librustc/middle/typeck/check/regionmanip.rs b/src/librustc/middle/typeck/check/regionmanip.rs
index 1de37f79f08..1e4082fc961 100644
--- a/src/librustc/middle/typeck/check/regionmanip.rs
+++ b/src/librustc/middle/typeck/check/regionmanip.rs
@@ -43,7 +43,8 @@ fn replace_bound_regions_in_fn_ty(
     let mut all_tys = ty::tys_in_fn_ty(fn_ty);
 
     match self_info {
-      Some({explicit_self: {node: ast::sty_region(m), _}, _}) => {
+      Some({explicit_self: ast::spanned { node: ast::sty_region(m),
+                                          _}, _}) => {
         let region = ty::re_bound(ty::br_self);
         let ty = ty::mk_rptr(tcx, region,
                              { ty: ty::mk_self(tcx), mutbl: m });
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 42e722f8d53..b71f62c6db2 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -23,8 +23,7 @@ use std::serialize::{Encodable, Decodable, Encoder, Decoder};
 
 #[auto_encode]
 #[auto_decode]
-type spanned<T> = {node: T, span: span};
-
+struct spanned<T> { node: T, span: span }
 
 /* can't import macros yet, so this is copied from token.rs. See its comment
  * there. */
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index f56f0c545bf..81c7bb2abc9 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -176,12 +176,15 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
         cx.local_id += 1u;
     }
     match fk {
-      visit::fk_dtor(tps, ref attrs, self_id, parent_id) => {
-          let dt = @{node: {id: id, attrs: (*attrs), self_id: self_id,
-                     body: /* FIXME (#2543) */ copy body}, span: sp};
-          cx.map.insert(id, node_dtor(/* FIXME (#2543) */ copy tps, dt,
-                                      parent_id,
-                                      @/* FIXME (#2543) */ copy cx.path));
+        visit::fk_dtor(tps, ref attrs, self_id, parent_id) => {
+            let dt = @spanned {
+                node: {id: id, attrs: (*attrs), self_id: self_id,
+                     body: /* FIXME (#2543) */ copy body},
+                span: sp,
+            };
+            cx.map.insert(id, node_dtor(/* FIXME (#2543) */ copy tps, dt,
+                                        parent_id,
+                                        @/* FIXME (#2543) */ copy cx.path));
       }
       _ => ()
     }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 3cab2151fde..91baaaaa1da 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -29,7 +29,7 @@ pure fn spanned<T>(+lo: BytePos, +hi: BytePos, +t: T) -> spanned<T> {
 }
 
 pure fn respan<T>(sp: span, +t: T) -> spanned<T> {
-    {node: move t, span: sp}
+    spanned {node: t, span: sp}
 }
 
 pure fn dummy_spanned<T>(+t: T) -> spanned<T> {
@@ -284,7 +284,7 @@ impl def_id : to_bytes::IterBytes {
 
 fn block_from_expr(e: @expr) -> blk {
     let blk_ = default_block(~[], option::Some::<@expr>(e), e.id);
-    return {node: blk_, span: e.span};
+    return spanned {node: blk_, span: e.span};
 }
 
 fn default_block(+stmts1: ~[@stmt], expr1: Option<@expr>, id1: node_id) ->
diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs
index 152c49461b8..a3f208a3f07 100644
--- a/src/libsyntax/ext/auto_encode.rs
+++ b/src/libsyntax/ext/auto_encode.rs
@@ -299,8 +299,8 @@ priv impl ext_ctxt {
     }
 
     fn stmt(expr: @ast::expr) -> @ast::stmt {
-        @{node: ast::stmt_semi(expr, self.next_id()),
-          span: expr.span}
+        @ast::spanned { node: ast::stmt_semi(expr, self.next_id()),
+                       span: expr.span }
     }
 
     fn lit_str(span: span, s: @~str) -> @ast::expr {
@@ -310,8 +310,8 @@ priv impl ext_ctxt {
                 self.expr(
                     span,
                     ast::expr_lit(
-                        @{node: ast::lit_str(s),
-                          span: span})),
+                        @ast::spanned { node: ast::lit_str(s),
+                                        span: span})),
                 ast::expr_vstore_uniq))
     }
 
@@ -319,8 +319,8 @@ priv impl ext_ctxt {
         self.expr(
             span,
             ast::expr_lit(
-                @{node: ast::lit_uint(i as u64, ast::ty_u),
-                  span: span}))
+                @ast::spanned { node: ast::lit_uint(i as u64, ast::ty_u),
+                                span: span}))
     }
 
     fn lambda(blk: ast::blk) -> @ast::expr {
@@ -330,21 +330,21 @@ priv impl ext_ctxt {
     }
 
     fn blk(span: span, stmts: ~[@ast::stmt]) -> ast::blk {
-        {node: {view_items: ~[],
-                stmts: stmts,
-                expr: None,
-                id: self.next_id(),
-                rules: ast::default_blk},
-         span: span}
+        ast::spanned { node: { view_items: ~[],
+                               stmts: stmts,
+                               expr: None,
+                               id: self.next_id(),
+                               rules: ast::default_blk},
+                       span: span }
     }
 
     fn expr_blk(expr: @ast::expr) -> ast::blk {
-        {node: {view_items: ~[],
-                stmts: ~[],
-                expr: Some(expr),
-                id: self.next_id(),
-                rules: ast::default_blk},
-         span: expr.span}
+        ast::spanned { node: { 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 {
@@ -570,7 +570,8 @@ fn mk_ser_method(
         ident: cx.ident_of(~"encode"),
         attrs: ~[],
         tps: ~[],
-        self_ty: { node: ast::sty_region(ast::m_imm), span: span },
+        self_ty: ast::spanned { node: ast::sty_region(ast::m_imm),
+                                span: span },
         purity: ast::impure_fn,
         decl: ser_decl,
         body: ser_body,
@@ -624,7 +625,8 @@ fn mk_deser_method(
         ident: cx.ident_of(~"decode"),
         attrs: ~[],
         tps: ~[],
-        self_ty: { node: ast::sty_static, span: span },
+        self_ty: ast::spanned { node: ast::sty_static,
+                                span: span },
         purity: ast::impure_fn,
         decl: deser_decl,
         body: deser_body,
@@ -862,7 +864,7 @@ fn mk_deser_fields(
             ]
         );
 
-        {
+        ast::spanned {
             node: { mutbl: field.mutbl, ident: field.ident, expr: expr },
             span: span,
         }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 4a3c8ee2259..288ef1b273e 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -26,7 +26,7 @@ fn mk_expr(cx: ext_ctxt, sp: codemap::span, expr: ast::expr_) ->
 }
 
 fn mk_lit(cx: ext_ctxt, sp: span, lit: ast::lit_) -> @ast::expr {
-    let sp_lit = @{node: lit, span: sp};
+    let sp_lit = @ast::spanned { node: lit, span: sp };
     mk_expr(cx, sp, ast::expr_lit(sp_lit))
 }
 fn mk_int(cx: ext_ctxt, sp: span, i: int) -> @ast::expr {
@@ -136,7 +136,8 @@ fn mk_uniq_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr {
 }
 fn mk_field(sp: span, f: &{ident: ast::ident, ex: @ast::expr})
     -> ast::field {
-    {node: {mutbl: ast::m_imm, ident: f.ident, expr: f.ex}, span: sp}
+    ast::spanned { node: {mutbl: ast::m_imm, ident: f.ident, expr: f.ex},
+                   span: sp }
 }
 fn mk_fields(sp: span, fields: ~[{ident: ast::ident, ex: @ast::expr}]) ->
     ~[ast::field] {
@@ -159,9 +160,10 @@ fn mk_struct_e(cx: ext_ctxt, sp: span,
 }
 fn mk_glob_use(cx: ext_ctxt, sp: span,
                path: ~[ast::ident]) -> @ast::view_item {
-    let glob = @{node: ast::view_path_glob(mk_raw_path(sp, path),
-                                          cx.next_id()),
-                span: sp};
+    let glob = @ast::spanned {
+        node: ast::view_path_glob(mk_raw_path(sp, path), cx.next_id()),
+        span: sp,
+    };
     @{node: ast::view_item_import(~[glob]),
       attrs: ~[],
       vis: ast::private,
@@ -176,29 +178,29 @@ fn mk_local(cx: ext_ctxt, sp: span, mutbl: bool,
                                                  None),
                            span: sp};
     let ty : @ast::Ty = @{ id: cx.next_id(), node: ast::ty_infer, span: sp };
-    let local : @ast::local = @{node: {is_mutbl: mutbl,
-                                       ty: ty,
-                                       pat: pat,
-                                       init: Some(ex),
-                                       id: cx.next_id()},
-                                span: sp};
-    let decl = {node: ast::decl_local(~[local]), span: sp};
-    @{ node: ast::stmt_decl(@decl, cx.next_id()), 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 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,
             view_items: ~[@ast::view_item],
             stmts: ~[@ast::stmt],
             expr: Option<@ast::expr>) -> @ast::expr {
-    let blk = {node: {view_items: view_items,
-                      stmts: stmts,
-                      expr: expr,
-                      id: cx.next_id(),
-                      rules: ast::default_blk },
-               span: sp };
+    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 {
-    {
+    ast::spanned {
         node: {
             view_items: ~[],
             stmts: move stmts,
@@ -217,7 +219,7 @@ fn mk_simple_block(cx: ext_ctxt, span: span, expr: @ast::expr) -> ast::blk {
         id: cx.next_id(),
         rules: ast::default_blk
     };
-    { node: move block, span: span }
+    ast::spanned { node: block, span: span }
 }
 fn mk_copy(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_copy(e))
@@ -250,12 +252,13 @@ fn mk_pat_struct(cx: ext_ctxt,
     mk_pat(cx, span, move pat)
 }
 fn mk_bool(cx: ext_ctxt, span: span, value: bool) -> @ast::expr {
-    let lit_expr = ast::expr_lit(@{ node: ast::lit_bool(value), span: span });
+    let lit_expr = ast::expr_lit(@ast::spanned { node: ast::lit_bool(value),
+                                                 span: span });
     build::mk_expr(cx, span, move lit_expr)
 }
 fn mk_stmt(cx: ext_ctxt, span: span, expr: @ast::expr) -> @ast::stmt {
     let stmt_ = ast::stmt_semi(expr, cx.next_id());
-    @{ node: move stmt_, span: span }
+    @ast::spanned { node: move stmt_, span: span }
 }
 fn mk_ty_path(cx: ext_ctxt,
               span: span,
diff --git a/src/libsyntax/ext/deriving.rs b/src/libsyntax/ext/deriving.rs
index 41804b1022a..8e36dc01e2a 100644
--- a/src/libsyntax/ext/deriving.rs
+++ b/src/libsyntax/ext/deriving.rs
@@ -16,10 +16,10 @@ use core::prelude::*;
 use ast::{Ty, and, bind_by_ref, binop, deref, enum_def, enum_variant_kind};
 use ast::{expr, expr_match, ident, item, item_, item_struct, item_enum};
 use ast::{item_impl, m_imm, meta_item, method, named_field, or, pat};
-use ast::{pat_ident, pat_wild, public, pure_fn, re_anon, stmt, struct_def};
-use ast::{struct_variant_kind, sty_by_ref, sty_region, tuple_variant_kind};
-use ast::{ty_nil, ty_param, ty_param_bound, ty_path, ty_rptr, unnamed_field};
-use ast::{variant};
+use ast::{pat_ident, pat_wild, public, pure_fn, re_anon, spanned, stmt};
+use ast::{struct_def, struct_variant_kind, sty_by_ref, sty_region};
+use ast::{tuple_variant_kind, ty_nil, ty_param, ty_param_bound, ty_path};
+use ast::{ty_rptr, unnamed_field, variant};
 use ext::base::ext_ctxt;
 use ext::build;
 use codemap::span;
@@ -159,7 +159,7 @@ fn create_eq_method(cx: ext_ctxt,
     let body_block = build::mk_simple_block(cx, span, body);
 
     // Create the method.
-    let self_ty = { node: sty_region(m_imm), span: span };
+    let self_ty = spanned { node: sty_region(m_imm), span: span };
     return @{
         ident: method_ident,
         attrs: ~[],
@@ -309,7 +309,7 @@ fn create_iter_bytes_method(cx: ext_ctxt,
     let body_block = build::mk_block_(cx, span, move statements);
 
     // Create the method.
-    let self_ty = { node: sty_region(m_imm), span: span };
+    let self_ty = spanned { node: sty_region(m_imm), span: span };
     let method_ident = cx.ident_of(~"iter_bytes");
     return @{
         ident: method_ident,
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 8faeb167191..82dae3e26b3 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -156,7 +156,9 @@ fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
                    fld: ast_fold) -> Option<@ast::item> {
 
     let (pth, tts) = match it.node {
-        item_mac({node: mac_invoc_tt(pth, ref tts), _}) => (pth, (*tts)),
+        item_mac(ast::spanned { node: mac_invoc_tt(pth, ref tts), _}) => {
+            (pth, (*tts))
+        }
         _ => cx.span_bug(it.span, ~"invalid item macro invocation")
     };
 
@@ -234,7 +236,8 @@ fn expand_stmt(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
                 {call_site: sp, callie: {name: *extname, span: exp_sp}}));
             let expanded = match exp(cx, mac.span, tts) {
                 mr_expr(e) =>
-                    @{node: stmt_expr(e, cx.next_id()), span: e.span},
+                    @ast::spanned { node: stmt_expr(e, cx.next_id()),
+                                    span: e.span},
                 mr_any(_,_,stmt_mkr) => stmt_mkr(),
                 _ => cx.span_fatal(
                     pth.span,
diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs
index 56ace4aac1b..3e265de04a3 100644
--- a/src/libsyntax/ext/pipes/ast_builder.rs
+++ b/src/libsyntax/ext/pipes/ast_builder.rs
@@ -136,8 +136,8 @@ impl ext_ctxt: ext_ctxt_ast_builder {
     }
 
     fn stmt_expr(e: @ast::expr) -> @ast::stmt {
-        @{node: ast::stmt_expr(e, self.next_id()),
-          span: dummy_sp()}
+        @spanned { node: ast::stmt_expr(e, self.next_id()),
+                   span: dummy_sp()}
     }
 
     fn stmt_let(ident: ident, e: @ast::expr) -> @ast::stmt {
@@ -146,8 +146,8 @@ impl ext_ctxt: ext_ctxt_ast_builder {
     }
 
     fn field_imm(name: ident, e: @ast::expr) -> ast::field {
-        {node: {mutbl: ast::m_imm, ident: name, expr: e},
-         span: dummy_sp()}
+        spanned { node: { mutbl: ast::m_imm, ident: name, expr: e },
+                  span: dummy_sp()}
     }
 
     fn rec(+fields: ~[ast::field]) -> @ast::expr {
@@ -158,8 +158,8 @@ impl ext_ctxt: ext_ctxt_ast_builder {
     }
 
     fn ty_field_imm(name: ident, ty: @ast::Ty) -> ast::ty_field {
-        {node: {ident: name, mt: { ty: ty, mutbl: ast::m_imm } },
-          span: dummy_sp()}
+        spanned { node: { ident: name, mt: { ty: ty, mutbl: ast::m_imm } },
+                  span: dummy_sp() }
     }
 
     fn ty_rec(+fields: ~[ast::ty_field]) -> @ast::Ty {
@@ -199,8 +199,7 @@ impl ext_ctxt: ext_ctxt_ast_builder {
                    id: self.next_id(),
                    rules: ast::default_blk};
 
-        {node: blk,
-         span: dummy_sp()}
+        spanned { node: blk, span: dummy_sp() }
     }
 
     fn expr_block(e: @ast::expr) -> ast::blk {
@@ -275,13 +274,13 @@ impl ext_ctxt: ext_ctxt_ast_builder {
                +tys: ~[@ast::Ty]) -> ast::variant {
         let args = tys.map(|ty| {ty: *ty, id: self.next_id()});
 
-        {node: {name: name,
-                attrs: ~[],
-                kind: ast::tuple_variant_kind(args),
-                id: self.next_id(),
-                disr_expr: None,
-                vis: ast::public},
-         span: span}
+        spanned { node: { name: name,
+                          attrs: ~[],
+                          kind: ast::tuple_variant_kind(args),
+                          id: self.next_id(),
+                          disr_expr: None,
+                          vis: ast::public},
+                  span: span}
     }
 
     fn item_mod(name: ident,
@@ -290,7 +289,7 @@ impl ext_ctxt: ext_ctxt_ast_builder {
         // XXX: Total hack: import `core::kinds::Owned` to work around a
         // parser bug whereby `fn f<T: ::kinds::Owned>` doesn't parse.
         let vi = ast::view_item_import(~[
-            @{
+            @ast::spanned {
                 node: ast::view_path_simple(
                     self.ident_of(~"Owned"),
                     path(
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 724e2fc9dba..2449db17c0f 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -189,13 +189,13 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
     fn n_rec(p_s: parse_sess, m: matcher, res: ~[@named_match],
              ret_val: HashMap<ident, @named_match>) {
         match m {
-          {node: match_tok(_), span: _} => (),
-          {node: match_seq(ref more_ms, _, _, _, _), span: _} => {
+          spanned {node: match_tok(_), _} => (),
+          spanned {node: match_seq(ref more_ms, _, _, _, _), _} => {
             for (*more_ms).each() |next_m| {
                 n_rec(p_s, *next_m, res, ret_val)
             };
           }
-          {node: match_nonterminal(bind_name, _, idx), span: sp} => {
+          spanned {node: match_nonterminal(bind_name, _, idx), span: sp} => {
             if ret_val.contains_key(bind_name) {
                 p_s.span_diagnostic.span_fatal(sp, ~"Duplicated bind name: "+
                                                *p_s.interner.get(bind_name))
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 1f1efdfe165..069eb1e0d82 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -33,7 +33,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
                      arg: ~[ast::token_tree]) -> base::mac_result {
     // these spans won't matter, anyways
     fn ms(m: matcher_) -> matcher {
-        {node: m, span: dummy_sp()}
+        ast::spanned { node: m, span: dummy_sp() }
     }
 
     let lhs_nm =  cx.parse_sess().interner.gensym(@~"lhs");
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 7de4e3f1d5f..2c4efa82499 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -93,27 +93,27 @@ type ast_fold_precursor = @{
 
 //used in noop_fold_item and noop_fold_crate and noop_fold_crate_directive
 fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
-    return @{node:
-              match mi.node {
+    @spanned {
+        node:
+            match mi.node {
                 meta_word(ref id) => meta_word((*id)),
                 meta_list(ref id, mis) => {
-                  let fold_meta_item = |x|fold_meta_item_(x, fld);
-                  meta_list(/* FIXME: (#2543) */ copy (*id),
-                            vec::map(mis, |e| fold_meta_item(*e)))
+                    let fold_meta_item = |x|fold_meta_item_(x, fld);
+                    meta_list(/* FIXME: (#2543) */ copy (*id),
+                        vec::map(mis, |e| fold_meta_item(*e)))
                 }
                 meta_name_value(ref id, s) => {
-                  meta_name_value((*id), /* FIXME (#2543) */ copy s)
+                    meta_name_value((*id), /* FIXME (#2543) */ copy s)
                 }
-              },
-          span: fld.new_span(mi.span)};
+            },
+        span: fld.new_span(mi.span) }
 }
 //used in noop_fold_item and noop_fold_crate
-fn fold_attribute_(at: attribute, fld: ast_fold) ->
-   attribute {
-    return {node: {style: at.node.style,
-                value: *fold_meta_item_(@at.node.value, fld),
-                is_sugared_doc: at.node.is_sugared_doc },
-         span: fld.new_span(at.span)};
+fn fold_attribute_(at: attribute, fld: ast_fold) -> attribute {
+    spanned { node: { style: at.node.style,
+                      value: *fold_meta_item_(@at.node.value, fld),
+                      is_sugared_doc: at.node.is_sugared_doc },
+              span: fld.new_span(at.span) }
 }
 //used in noop_fold_foreign_item and noop_fold_fn_decl
 fn fold_arg_(a: arg, fld: ast_fold) -> arg {
@@ -124,11 +124,10 @@ fn fold_arg_(a: arg, fld: ast_fold) -> arg {
 }
 //used in noop_fold_expr, and possibly elsewhere in the future
 fn fold_mac_(m: mac, fld: ast_fold) -> mac {
-    return {node:
-             match m.node {
-               mac_invoc_tt(*) => m.node,
-             },
-         span: fld.new_span(m.span)};
+    spanned { node: match m.node {
+                        mac_invoc_tt(*) => m.node,
+                    },
+              span: fld.new_span(m.span) }
 }
 
 fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
@@ -206,10 +205,10 @@ fn noop_fold_item(&&i: @item, fld: ast_fold) -> Option<@item> {
 
 fn noop_fold_struct_field(&&sf: @struct_field, fld: ast_fold)
                        -> @struct_field {
-    @{node: {kind: copy sf.node.kind,
-             id: sf.node.id,
-             ty: fld.fold_ty(sf.node.ty)},
-      span: sf.span}
+    @spanned { node: { kind: copy sf.node.kind,
+                       id: sf.node.id,
+                       ty: fld.fold_ty(sf.node.ty) },
+               span: sf.span }
 }
 
 fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
@@ -266,9 +265,10 @@ fn fold_struct_def(struct_def: @ast::struct_def, fld: ast_fold)
     let dtor = do option::map(&struct_def.dtor) |dtor| {
         let dtor_body = fld.fold_block(dtor.node.body);
         let dtor_id   = fld.new_id(dtor.node.id);
-        {node: {body: dtor_body,
-                id: dtor_id,.. dtor.node},
-            .. *dtor}};
+        spanned { node: { body: dtor_body,
+                          id: dtor_id, .. dtor.node},
+                  span: dtor.span }
+    };
     return @{
         fields: vec::map(struct_def.fields, |f| fold_struct_field(*f, fld)),
         dtor: dtor,
@@ -281,10 +281,10 @@ fn fold_trait_ref(&&p: @trait_ref, fld: ast_fold) -> @trait_ref {
 }
 
 fn fold_struct_field(&&f: @struct_field, fld: ast_fold) -> @struct_field {
-    @{node: {kind: copy f.node.kind,
-             id: fld.new_id(f.node.id),
-             ty: fld.fold_ty(f.node.ty)},
-      span: fld.new_span(f.span)}
+    @spanned { node: { kind: copy f.node.kind,
+                       id: fld.new_id(f.node.id),
+                       ty: fld.fold_ty(f.node.ty) },
+               span: fld.new_span(f.span) }
 }
 
 fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
@@ -390,11 +390,10 @@ fn wrap<T>(f: fn@(T, ast_fold) -> T)
 
 fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
     fn fold_field_(field: field, fld: ast_fold) -> field {
-        return {node:
-                 {mutbl: field.node.mutbl,
-                  ident: fld.fold_ident(field.node.ident),
-                  expr: fld.fold_expr(field.node.expr)},
-             span: fld.new_span(field.span)};
+        spanned { node: { mutbl: field.node.mutbl,
+                          ident: fld.fold_ident(field.node.ident),
+                          expr: fld.fold_expr(field.node.expr)},
+                  span: fld.new_span(field.span) }
     }
     let fold_field = |x| fold_field_(x, fld);
 
@@ -508,9 +507,9 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
         {ty: fld.fold_ty(mt.ty), mutbl: mt.mutbl}
     }
     fn fold_field(f: ty_field, fld: ast_fold) -> ty_field {
-        {node: {ident: fld.fold_ident(f.node.ident),
-                mt: fold_mt(f.node.mt, fld)},
-         span: fld.new_span(f.span)}
+        spanned { node: { ident: fld.fold_ident(f.node.ident),
+                          mt: fold_mt(f.node.mt, fld) },
+                  span: fld.new_span(f.span) }
     }
     match t {
       ty_nil | ty_bot | ty_infer => copy t,
@@ -566,9 +565,10 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
             let dtor = do option::map(&struct_def.dtor) |dtor| {
                 let dtor_body = fld.fold_block(dtor.node.body);
                 let dtor_id   = fld.new_id(dtor.node.id);
-                {node: {body: dtor_body,
-                        id: dtor_id,.. dtor.node},
-                    .. *dtor}};
+                spanned { node: { body: dtor_body,
+                                  id: dtor_id, .. dtor.node},
+                          .. *dtor }
+            };
             kind = struct_variant_kind(@{
                 fields: vec::map(struct_def.fields,
                                  |f| fld.fold_struct_field(*f)),
@@ -661,7 +661,7 @@ impl ast_fold_precursor: ast_fold {
     /* naturally, a macro to write these would be nice */
     fn fold_crate(c: crate) -> crate {
         let (n, s) = (self.fold_crate)(c.node, c.span, self as ast_fold);
-        return {node: n, span: (self.new_span)(s)};
+        spanned { node: n, span: (self.new_span)(s) }
     }
     fn fold_view_item(&&x: @view_item) ->
        @view_item {
@@ -679,10 +679,10 @@ impl ast_fold_precursor: ast_fold {
         return (self.fold_item)(i, self as ast_fold);
     }
     fn fold_struct_field(&&sf: @struct_field) -> @struct_field {
-        @{node: {kind: copy sf.node.kind,
-                 id: sf.node.id,
-                 ty: (self as ast_fold).fold_ty(sf.node.ty)},
-          span: (self.new_span)(sf.span)}
+        @spanned { node: { kind: copy sf.node.kind,
+                           id: sf.node.id,
+                           ty: (self as ast_fold).fold_ty(sf.node.ty) },
+                   span: (self.new_span)(sf.span) }
     }
     fn fold_item_underscore(i: item_) ->
        item_ {
@@ -694,11 +694,11 @@ impl ast_fold_precursor: ast_fold {
     }
     fn fold_block(x: blk) -> blk {
         let (n, s) = (self.fold_block)(x.node, x.span, self as ast_fold);
-        return {node: n, span: (self.new_span)(s)};
+        spanned { node: n, span: (self.new_span)(s) }
     }
     fn fold_stmt(&&x: @stmt) -> @stmt {
         let (n, s) = (self.fold_stmt)(x.node, x.span, self as ast_fold);
-        return @{node: n, span: (self.new_span)(s)};
+        @spanned { node: n, span: (self.new_span)(s) }
     }
     fn fold_arm(x: arm) -> arm {
         return (self.fold_arm)(x, self as ast_fold);
@@ -711,7 +711,7 @@ impl ast_fold_precursor: ast_fold {
     }
     fn fold_decl(&&x: @decl) -> @decl {
         let (n, s) = (self.fold_decl)(x.node, x.span, self as ast_fold);
-        return @{node: n, span: (self.new_span)(s)};
+        @spanned { node: n, span: (self.new_span)(s) }
     }
     fn fold_expr(&&x: @expr) -> @expr {
         let (n, s) = (self.fold_expr)(x.node, x.span, self as ast_fold);
@@ -734,7 +734,7 @@ impl ast_fold_precursor: ast_fold {
     fn fold_variant(x: variant) ->
        variant {
         let (n, s) = (self.fold_variant)(x.node, x.span, self as ast_fold);
-        return {node: n, span: (self.new_span)(s)};
+        spanned { node: n, span: (self.new_span)(s) }
     }
     fn fold_ident(&&x: ident) -> ident {
         return (self.fold_ident)(x, self as ast_fold);
@@ -744,7 +744,7 @@ impl ast_fold_precursor: ast_fold {
     }
     fn fold_local(&&x: @local) -> @local {
         let (n, s) = (self.fold_local)(x.node, x.span, self as ast_fold);
-        return @{node: n, span: (self.new_span)(s)};
+        @spanned { node: n, span: (self.new_span)(s) }
     }
     fn map_exprs(f: fn@(&&v: @expr) -> @expr, e: ~[@expr]) -> ~[@expr] {
         (self.map_exprs)(f, e)
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index 7f57c777833..04316e05b64 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -30,7 +30,8 @@ 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({node: {rules: ast::default_blk, _}, _}) => true,
+      ast::expr_block(ast::spanned {node: {rules: ast::default_blk, _}, _}) =>
+        true,
       _ => false
     }
 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 80fd04f0e10..1a549fc93d5 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -772,7 +772,7 @@ impl Parser {
             self.bump();
             self.lit_from_token(tok)
         };
-        return {node: lit, span: mk_sp(lo, self.last_span.hi)};
+        spanned { node: lit, span: mk_sp(lo, self.last_span.hi) }
     }
 
     fn parse_path_without_tps() -> @path {
@@ -844,7 +844,7 @@ impl Parser {
                 self.parse_seq_lt_gt(Some(token::COMMA),
                                      |p| p.parse_ty(false))
             } else {
-                {node: ~[], span: path.span}
+                spanned {node: ~[], span: path.span}
             }
         };
 
@@ -880,14 +880,14 @@ impl Parser {
     fn mk_mac_expr(+lo: BytePos, +hi: BytePos, m: mac_) -> @expr {
         return @{id: self.get_id(),
               callee_id: self.get_id(),
-              node: expr_mac({node: m, span: mk_sp(lo, hi)}),
+              node: expr_mac(spanned {node: m, span: mk_sp(lo, hi)}),
               span: mk_sp(lo, hi)};
     }
 
     fn mk_lit_u32(i: u32) -> @expr {
         let span = self.span;
-        let lv_lit = @{node: lit_uint(i as u64, ty_u32),
-                       span: span};
+        let lv_lit = @spanned { node: lit_uint(i as u64, ty_u32),
+                                span: span };
 
         return @{id: self.get_id(), callee_id: self.get_id(),
               node: expr_lit(lv_lit), span: span};
@@ -1363,7 +1363,7 @@ impl Parser {
                 hi = e.span.hi;
                 // HACK: turn &[...] into a &-evec
                 ex = match e.node {
-                  expr_vec(*) | expr_lit(@{node: lit_str(_), span: _})
+                  expr_vec(*) | expr_lit(@spanned {node: lit_str(_), span: _})
                   if m == m_imm => {
                     expr_vstore(e, expr_vstore_slice)
                   }
@@ -1386,7 +1386,7 @@ impl Parser {
               expr_vec(*) if m == m_mutbl =>
                 expr_vstore(e, expr_vstore_mut_box),
               expr_vec(*) if m == m_imm => expr_vstore(e, expr_vstore_box),
-              expr_lit(@{node: lit_str(_), span: _}) if m == m_imm =>
+              expr_lit(@spanned {node: lit_str(_), span: _}) if m == m_imm =>
                 expr_vstore(e, expr_vstore_box),
               _ => expr_unary(box(m), e)
             };
@@ -1398,7 +1398,7 @@ impl Parser {
             hi = e.span.hi;
             // HACK: turn ~[...] into a ~-evec
             ex = match e.node {
-              expr_vec(*) | expr_lit(@{node: lit_str(_), span: _})
+              expr_vec(*) | expr_lit(@spanned {node: lit_str(_), span: _})
               if m == m_imm => expr_vstore(e, expr_vstore_uniq),
               _ => expr_unary(uniq(m), e)
             };
@@ -1748,12 +1748,12 @@ impl Parser {
                 self.eat(token::COMMA);
             }
 
-            let blk = {node: {view_items: ~[],
-                              stmts: ~[],
-                              expr: Some(expr),
-                              id: self.get_id(),
-                              rules: default_blk},
-                       span: expr.span};
+            let blk = spanned { node: { view_items: ~[],
+                                        stmts: ~[],
+                                        expr: Some(expr),
+                                        id: self.get_id(),
+                                        rules: default_blk},
+                                span: expr.span };
 
             arms.push({pats: pats, guard: guard, body: blk});
         }
@@ -1893,7 +1893,7 @@ impl Parser {
             // HACK: parse @"..." as a literal of a vstore @str
             pat = match sub.node {
               pat_lit(e@@{
-                node: expr_lit(@{node: lit_str(_), span: _}), _
+                node: expr_lit(@spanned {node: lit_str(_), span: _}), _
               }) => {
                 let vst = @{id: self.get_id(), callee_id: self.get_id(),
                             node: expr_vstore(e, expr_vstore_box),
@@ -1910,7 +1910,7 @@ impl Parser {
             // HACK: parse ~"..." as a literal of a vstore ~str
             pat = match sub.node {
               pat_lit(e@@{
-                node: expr_lit(@{node: lit_str(_), span: _}), _
+                node: expr_lit(@spanned {node: lit_str(_), span: _}), _
               }) => {
                 let vst = @{id: self.get_id(), callee_id: self.get_id(),
                             node: expr_vstore(e, expr_vstore_uniq),
@@ -1929,7 +1929,7 @@ impl Parser {
               // HACK: parse &"..." as a literal of a borrowed str
               pat = match sub.node {
                   pat_lit(e@@{
-                      node: expr_lit(@{node: lit_str(_), span: _}), _
+                      node: expr_lit(@spanned {node: lit_str(_), span: _}), _
                   }) => {
                       let vst = @{
                           id: self.get_id(),
@@ -1954,7 +1954,7 @@ impl Parser {
             if self.token == token::RPAREN {
                 hi = self.span.hi;
                 self.bump();
-                let lit = @{node: lit_nil, span: mk_sp(lo, hi)};
+                let lit = @spanned {node: lit_nil, span: mk_sp(lo, hi)};
                 let expr = self.mk_expr(lo, hi, expr_lit(lit));
                 pat = pat_lit(expr);
             } else {
@@ -2319,8 +2319,9 @@ impl Parser {
                             match self.token {
                                 token::SEMI => {
                                     self.bump();
-                                    stmts.push(@{node: stmt_semi(e, stmt_id),
-                                                 ..*stmt});
+                                    stmts.push(@spanned {
+                                        node: stmt_semi(e, stmt_id),
+                                        .. *stmt});
                                 }
                                 token::RBRACE => {
                                     expr = Some(e);
@@ -2343,8 +2344,9 @@ impl Parser {
                             match self.token {
                                 token::SEMI => {
                                     self.bump();
-                                    stmts.push(@{node: stmt_mac((*m), true),
-                                                 ..*stmt});
+                                    stmts.push(@spanned {
+                                        node: stmt_mac((*m), true),
+                                        .. *stmt});
                                 }
                                 token::RBRACE => {
                                     // if a block ends in `m!(arg)` without
@@ -2811,11 +2813,11 @@ impl Parser {
 
         let actual_dtor = do the_dtor.map |dtor| {
             let (d_body, d_attrs, d_s) = *dtor;
-            {node: {id: self.get_id(),
-                    attrs: d_attrs,
-                    self_id: self.get_id(),
-                    body: d_body},
-             span: d_s}};
+            spanned { node: { id: self.get_id(),
+                              attrs: d_attrs,
+                              self_id: self.get_id(),
+                              body: d_body},
+                       span: d_s}};
         let _ = self.get_id();  // XXX: Workaround for crazy bug.
         let new_id = self.get_id();
         (class_name,
@@ -3308,11 +3310,11 @@ impl Parser {
         self.bump();
         let mut actual_dtor = do the_dtor.map |dtor| {
             let (d_body, d_attrs, d_s) = *dtor;
-            {node: {id: self.get_id(),
-                    attrs: d_attrs,
-                    self_id: self.get_id(),
-                    body: d_body},
-             span: d_s}
+            spanned { node: { id: self.get_id(),
+                              attrs: d_attrs,
+                              self_id: self.get_id(),
+                              body: d_body },
+                      span: d_s }
         };
 
         return @{
@@ -3592,9 +3594,9 @@ impl Parser {
               _ => self.fatal(~"expected open delimiter")
             };
             let m = ast::mac_invoc_tt(pth, tts);
-            let m: ast::mac = {node: m,
-                               span: mk_sp(self.span.lo,
-                                           self.span.hi)};
+            let m: ast::mac = spanned { node: m,
+                                        span: mk_sp(self.span.lo,
+                                                    self.span.hi) };
             let item_ = item_mac(m);
             return iovi_item(self.mk_item(lo, self.last_span.hi, id, item_,
                                           visibility, attrs));
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index c121bc30b96..dda83aa2d0e 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -599,7 +599,8 @@ fn print_item(s: ps, &&item: @ast::item) {
         }
         bclose(s, item.span);
       }
-      ast::item_mac({node: ast::mac_invoc_tt(pth, ref tts), _}) => {
+      ast::item_mac(ast::spanned { node: ast::mac_invoc_tt(pth, ref tts),
+                                   _}) => {
         print_visibility(s, item.vis);
         print_path(s, pth, false);
         word(s.s, ~"! ");