Simplify representation of ast::path

src/librustsyntax/ast.rs

@@ -37,10 +37,7 @@ type ident = str;
 type fn_ident = option<ident>;
 
 #[auto_serialize]
-type path_ = {global: bool, idents: [ident], types: [@ty]};
-
-#[auto_serialize]
-type path = spanned<path_>;
+type path = {span: span, global: bool, idents: [ident], types: [@ty]};
 
 #[auto_serialize]
 type crate_num = int;

src/librustsyntax/ast_util.rs

@@ -21,7 +21,7 @@ fn mk_sp(lo: uint, hi: uint) -> span {
 // make this a const, once the compiler supports it
 fn dummy_sp() -> span { ret mk_sp(0u, 0u); }
 
-fn path_name(p: @path) -> str { path_name_i(p.node.idents) }
+fn path_name(p: @path) -> str { path_name_i(p.idents) }
 
 fn path_name_i(idents: [ident]) -> str { str::connect(idents, "::") }
 
@@ -183,8 +183,8 @@ fn is_exported(i: ident, m: _mod) -> bool {
                   }
 
                   ast::view_path_list(path, ids, _) {
-                    if vec::len(path.node.idents) == 1u {
-                        if i == path.node.idents[0] { ret true; }
+                    if vec::len(path.idents) == 1u {
+                        if i == path.idents[0] { ret true; }
                         for ids.each {|id|
                             if id.node.name == i { ret true; }
                         }
@@ -249,7 +249,7 @@ fn default_block(stmts1: [@stmt], expr1: option<@expr>, id1: node_id) ->
 }
 
 fn ident_to_path(s: span, i: ident) -> @path {
-    @respan(s, {global: false, idents: [i], types: []})
+    @{span: s, global: false, idents: [i], types: []}
 }
 
 pure fn is_unguarded(&&a: arm) -> bool {

src/librustsyntax/ext/auto_serialize.rs

@@ -124,19 +124,17 @@ fn expand(cx: ext_ctxt,
 impl helpers for ext_ctxt {
     fn helper_path(base_path: @ast::path,
                    helper_name: str) -> @ast::path {
-        let head = vec::init(base_path.node.idents);
-        let tail = vec::last(base_path.node.idents);
+        let head = vec::init(base_path.idents);
+        let tail = vec::last(base_path.idents);
         self.path(base_path.span, head + [helper_name + "_" + tail])
     }
 
     fn path(span: span, strs: [str]) -> @ast::path {
-        @{node: {global: false, idents: strs, types: []},
-          span: span}
+        @{span: span, global: false, idents: strs, types: []}
     }
 
     fn path_tps(span: span, strs: [str], tps: [@ast::ty]) -> @ast::path {
-        @{node: {global: false, idents: strs, types: tps},
-          span: span}
+        @{span: span, global: false, idents: strs, types: tps}
     }
 
     fn ty_path(span: span, strs: [str], tps: [@ast::ty]) -> @ast::ty {
@@ -195,10 +193,7 @@ impl helpers for ext_ctxt {
     }
 
     fn binder_pat(span: span, nm: str) -> @ast::pat {
-        let path = @{node: {global: false,
-                            idents: [nm],
-                            types: []},
-                     span: span};
+        let path = @{span: span, global: false, idents: [nm], types: []};
         @{id: self.next_id(),
           node: ast::pat_ident(path, none),
           span: span}
@@ -292,7 +287,7 @@ fn ser_path(cx: ext_ctxt, tps: ser_tps_map, path: @ast::path,
             ast::expr_path(
                 cx.helper_path(path, "serialize")));
 
-    let ty_args = vec::map(path.node.types) {|ty|
+    let ty_args = vec::map(path.types) {|ty|
         let sv_stmts = ser_ty(cx, tps, ty, cx.clone(s), #ast{ __v });
         let sv = cx.expr(path.span,
                          ast::expr_block(cx.blk(path.span, sv_stmts)));
@@ -428,9 +423,9 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
       }
 
       ast::ty_path(path, _) {
-        if vec::len(path.node.idents) == 1u &&
-            vec::is_empty(path.node.types) {
-            let ident = path.node.idents[0];
+        if vec::len(path.idents) == 1u &&
+            vec::is_empty(path.types) {
+            let ident = path.idents[0];
 
             alt tps.find(ident) {
               some(f) { f(v) }
@@ -566,7 +561,7 @@ fn deser_path(cx: ext_ctxt, tps: deser_tps_map, path: @ast::path,
             ast::expr_path(
                 cx.helper_path(path, "deserialize")));
 
-    let ty_args = vec::map(path.node.types) {|ty|
+    let ty_args = vec::map(path.types) {|ty|
         let dv_expr = deser_ty(cx, tps, ty, cx.clone(d));
         cx.lambda(cx.expr_blk(dv_expr))
     };
@@ -650,9 +645,9 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
       }
 
       ast::ty_path(path, _) {
-        if vec::len(path.node.idents) == 1u &&
-            vec::is_empty(path.node.types) {
-            let ident = path.node.idents[0];
+        if vec::len(path.idents) == 1u &&
+            vec::is_empty(path.types) {
+            let ident = path.idents[0];
 
             alt tps.find(ident) {
               some(f) { f() }

src/librustsyntax/ext/base.rs

@@ -137,9 +137,9 @@ fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: str) -> str {
 fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: str) -> ast::ident {
     alt expr.node {
       ast::expr_path(p) {
-        if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
+        if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
             cx.span_fatal(expr.span, error);
-        } else { ret p.node.idents[0]; }
+        } else { ret p.idents[0]; }
       }
       _ { cx.span_fatal(expr.span, error); }
     }

src/librustsyntax/ext/build.rs

@@ -30,9 +30,8 @@ fn mk_unary(cx: ext_ctxt, sp: span, op: ast::unop, e: @ast::expr)
 }
 fn mk_path(cx: ext_ctxt, sp: span, idents: [ast::ident]) ->
     @ast::expr {
-    let path = {global: false, idents: idents, types: []};
-    let sp_path = @{node: path, span: sp};
-    let pathexpr = ast::expr_path(sp_path);
+    let path = @{span: sp, global: false, idents: idents, types: []};
+    let pathexpr = ast::expr_path(path);
     ret @{id: cx.next_id(), node: pathexpr, span: sp};
 }
 fn mk_access_(cx: ext_ctxt, sp: span, p: @ast::expr, m: ast::ident)

src/librustsyntax/ext/concat_idents.rs

@@ -16,8 +16,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
     }
 
     ret @{id: cx.next_id(),
-          node: ast::expr_path(@{node: {global: false, idents: [res],
-                                        types: []},
-                                 span: sp}),
+          node: ast::expr_path(@{span: sp, global: false, idents: [res],
+                                 types: []}),
           span: sp};
 }

src/librustsyntax/ext/expand.rs

@@ -19,8 +19,8 @@ fn expand_expr(exts: hashmap<str, syntax_extension>, cx: ext_ctxt,
           expr_mac(mac) {
             alt mac.node {
               mac_invoc(pth, args, body) {
-                assert (vec::len(pth.node.idents) > 0u);
-                let extname = pth.node.idents[0];
+                assert (vec::len(pth.idents) > 0u);
+                let extname = pth.idents[0];
                 alt exts.find(extname) {
                   none {
                     cx.span_fatal(pth.span,

src/librustsyntax/ext/qquote.rs

@@ -142,7 +142,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
             ecx.span_fatal(_sp, "#ast requires exactly one arg");
         }
         alt (args[0].node) {
-          ast::expr_path(@{node: {idents: id, _},_}) if vec::len(id) == 1u
+          ast::expr_path(@{idents: id, _}) if vec::len(id) == 1u
               {what = id[0]}
           _ {ecx.span_fatal(args[0].span, "expected an identifier");}
         }

src/librustsyntax/ext/simplext.rs

@@ -5,14 +5,14 @@ import base::*;
 
 import fold::*;
 import ast_util::respan;
-import ast::{ident, path, ty, blk_, expr, path_, expr_path,
+import ast::{ident, path, ty, blk_, expr, expr_path,
              expr_vec, expr_mac, mac_invoc, node_id};
 
 export add_new_extension;
 
 fn path_to_ident(pth: @path) -> option<ident> {
-    if vec::len(pth.node.idents) == 1u && vec::len(pth.node.types) == 0u {
-        ret some(pth.node.idents[0u]);
+    if vec::len(pth.idents) == 1u && vec::len(pth.types) == 0u {
+        ret some(pth.idents[0u]);
     }
     ret none;
 }
@@ -190,7 +190,7 @@ fn transcribe(cx: ext_ctxt, b: bindings, body: @expr) -> @expr {
     let afp = default_ast_fold();
     let f_pre =
         {fold_ident: bind transcribe_ident(cx, b, idx_path, _, _),
-         fold_path: bind transcribe_path(cx, b, idx_path, _, _, _),
+         fold_path: bind transcribe_path(cx, b, idx_path, _, _),
          fold_expr:
              bind transcribe_expr(cx, b, idx_path, _, _, _, afp.fold_expr),
          fold_ty: bind transcribe_type(cx, b, idx_path, _, _, _, afp.fold_ty),
@@ -329,17 +329,17 @@ fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
 
 
 fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
-                   p: path_, s:span, _fld: ast_fold) -> (path_, span) {
+                   p: path, _fld: ast_fold) -> path {
     // Don't substitute into qualified names.
-    if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret (p, s); }
-    ret alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
-          some(match_ident(id)) {
-            ({global: false, idents: [id.node], types: []}, id.span)
-          }
-          some(match_path(a_pth)) { (a_pth.node, a_pth.span) }
-          some(m) { match_error(cx, m, "a path") }
-          none { (p, s) }
-        }
+    if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { ret p; }
+    alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
+      some(match_ident(id)) {
+        {span: id.span, global: false, idents: [id.node], types: []}
+      }
+      some(match_path(a_pth)) { *a_pth }
+      some(m) { match_error(cx, m, "a path") }
+      none { p }
+    }
 }
 
 
@@ -351,15 +351,15 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut [uint],
     ret alt e {
           expr_path(p) {
             // Don't substitute into qualified names.
-            if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {
+            if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
                 (e, s);
             }
-            alt follow_for_trans(cx, b.find(p.node.idents[0]), idx_path) {
+            alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
               some(match_ident(id)) {
-                (expr_path(@respan(id.span,
-                                   {global: false,
-                                    idents: [id.node],
-                                    types: []})), id.span)
+                (expr_path(@{span: id.span,
+                             global: false,
+                             idents: [id.node],
+                             types: []}), id.span)
               }
               some(match_path(a_pth)) { (expr_path(a_pth), s) }
               some(match_expr(a_exp)) { (a_exp.node, a_exp.span) }

src/librustsyntax/fold.rs

@@ -46,7 +46,7 @@ type ast_fold_precursor =
      fold_native_mod: fn@(native_mod, ast_fold) -> native_mod,
      fold_variant: fn@(variant_, span, ast_fold) -> (variant_, span),
      fold_ident: fn@(&&ident, ast_fold) -> ident,
-     fold_path: fn@(path_, span, ast_fold) -> (path_, span),
+     fold_path: fn@(path, ast_fold) -> path,
      fold_local: fn@(local_, span, ast_fold) -> (local_, span),
      map_exprs: fn@(fn@(&&@expr) -> @expr, [@expr]) -> [@expr],
      new_id: fn@(node_id) -> node_id,
@@ -559,8 +559,8 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
 
 fn noop_fold_ident(&&i: ident, _fld: ast_fold) -> ident { ret i; }
 
-fn noop_fold_path(&&p: path_, fld: ast_fold) -> path_ {
-    ret {global: p.global,
+fn noop_fold_path(&&p: path, fld: ast_fold) -> path {
+    ret {span: fld.new_span(p.span), global: p.global,
          idents: vec::map(p.idents, fld.fold_ident),
          types: vec::map(p.types, fld.fold_ty)};
 }
@@ -613,7 +613,7 @@ fn default_ast_fold() -> @ast_fold_precursor {
           fold_native_mod: noop_fold_native_mod,
           fold_variant: wrap(noop_fold_variant),
           fold_ident: noop_fold_ident,
-          fold_path: wrap(noop_fold_path),
+          fold_path: noop_fold_path,
           fold_local: wrap(noop_fold_local),
           map_exprs: noop_map_exprs,
           new_id: noop_id,
@@ -754,8 +754,7 @@ fn make_fold(afp: ast_fold_precursor) -> ast_fold {
         ret afp.fold_ident(x, f);
     }
     fn f_path(afp: ast_fold_precursor, f: ast_fold, &&x: @path) -> @path {
-        let (n, s) = afp.fold_path(x.node, x.span, f);
-        ret @{node: n, span: afp.new_span(s)};
+        @afp.fold_path(*x, f)
     }
     fn f_local(afp: ast_fold_precursor, f: ast_fold, &&x: @local) -> @local {
         let (n, s) = afp.fold_local(x.node, x.span, f);