rustc: Add node IDs to AST types so we can associate them with region environments

Author: pcwalton

src/rustc/front/test.rs

@@ -254,11 +254,15 @@ fn mk_test_desc_vec_ty(cx: test_ctxt) -> @ast::ty {
                  types: []});
 
     let test_desc_ty: ast::ty =
-        nospan(ast::ty_path(test_desc_ty_path, cx.sess.next_node_id()));
+        {id: cx.sess.next_node_id(),
+         node: ast::ty_path(test_desc_ty_path, cx.sess.next_node_id()),
+         span: dummy_sp()};
 
     let vec_mt: ast::mt = {ty: @test_desc_ty, mutbl: ast::m_imm};
 
-    ret @nospan(ast::ty_vec(vec_mt));
+    ret @{id: cx.sess.next_node_id(),
+          node: ast::ty_vec(vec_mt),
+          span: dummy_sp()};
 }
 
 fn mk_test_desc_vec(cx: test_ctxt) -> @ast::expr {
@@ -346,7 +350,7 @@ fn mk_test_wrapper(cx: test_ctxt,
 
     let wrapper_decl: ast::fn_decl = {
         inputs: [],
-        output: @nospan(ast::ty_nil),
+        output: @{id: cx.sess.next_node_id(), node: ast::ty_nil, span: span},
         purity: ast::impure_fn,
         cf: ast::return_val,
         constraints: []
@@ -377,17 +381,23 @@ fn mk_test_wrapper(cx: test_ctxt,
 
 fn mk_main(cx: test_ctxt) -> @ast::item {
     let str_pt = @nospan({global: false, idents: ["str"], types: []});
-    let str_ty = @nospan(ast::ty_path(str_pt, cx.sess.next_node_id()));
+    let str_ty = @{id: cx.sess.next_node_id(),
+                   node: ast::ty_path(str_pt, cx.sess.next_node_id()),
+                   span: dummy_sp()};
     let args_mt: ast::mt = {ty: str_ty, mutbl: ast::m_imm};
-    let args_ty: ast::ty = nospan(ast::ty_vec(args_mt));
+    let args_ty: ast::ty = {id: cx.sess.next_node_id(),
+                            node: ast::ty_vec(args_mt),
+                            span: dummy_sp()};
 
     let args_arg: ast::arg =
         {mode: ast::expl(ast::by_val),
          ty: @args_ty,
          ident: "args",
          id: cx.sess.next_node_id()};
 
-    let ret_ty = nospan(ast::ty_nil);
+    let ret_ty = {id: cx.sess.next_node_id(),
+                  node: ast::ty_nil,
+                  span: dummy_sp()};
 
     let decl: ast::fn_decl =
         {inputs: [args_arg],

src/rustc/metadata/astencode_gen.rs

@@ -3463,12 +3463,15 @@ fn serialize_31<S: std::serialization::serializer>(s: S,
 /*syntax::ast::ty*/
 fn serialize_30<S: std::serialization::serializer>(s: S, v: syntax::ast::ty) {
 
-    s.emit_rec(/*syntax::ast::ty_*//*syntax::codemap::span*/
+    s.emit_rec(/*syntax::ast::node_id*//*syntax::ast::ty_*/
+               /*syntax::codemap::span*/
                {||
                    {
-                       s.emit_rec_field("node", 0u,
+                       s.emit_rec_field("id", 0u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("node", 1u,
                                         {|| serialize_31(s, v.node) });
-                       s.emit_rec_field("span", 1u,
+                       s.emit_rec_field("span", 2u,
                                         {|| serialize_19(s, v.span) })
                    }
                });
@@ -7325,15 +7328,18 @@ fn deserialize_30<S: std::serialization::deserializer>(s: S) ->
     s.read_rec(
 
 
+               /*syntax::ast::node_id*/
+
                /*syntax::ast::ty_*/
 
                /*syntax::codemap::span*/
 
                {||
-                   {node:
-                        s.read_rec_field("node", 0u, {|| deserialize_31(s) }),
+                   {id: s.read_rec_field("id", 0u, {|| deserialize_27(s) }),
+                    node:
+                        s.read_rec_field("node", 1u, {|| deserialize_31(s) }),
                     span:
-                        s.read_rec_field("span", 1u,
+                        s.read_rec_field("span", 2u,
                                          {|| deserialize_19(s) }),}
                })
 

src/rustc/middle/trans/base.rs

@@ -4419,7 +4419,8 @@ fn trans_item(ccx: crate_ctxt, item: ast::item) {
               node: ast::pat_ident(rslt_path, none),
               span: ctor.node.body.span};
         // Set up obj's type
-        let rslt_ast_ty : @ast::ty = @{node: ast::ty_infer,
+        let rslt_ast_ty : @ast::ty = @{id: ccx.sess.next_node_id(),
+                                       node: ast::ty_infer,
                                        span: ctor.node.body.span};
         // kludgy
         let ty_args = [], i = 0u;

src/rustc/syntax/ast.rs

@@ -334,7 +334,7 @@ enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
 
 enum float_ty { ty_f, ty_f32, ty_f64, }
 
-type ty = spanned<ty_>;
+type ty = {id: node_id, node: ty_, span: span};
 
 // Not represented directly in the AST, referred to by name through a ty_path.
 enum prim_ty {

src/rustc/syntax/fold.rs

@@ -699,7 +699,7 @@ fn make_fold(afp: ast_fold_precursor) -> ast_fold {
     }
     fn f_ty(afp: ast_fold_precursor, f: ast_fold, &&x: @ty) -> @ty {
         let (n, s) = afp.fold_ty(x.node, x.span, f);
-        ret @{node: n, span: afp.new_span(s)};
+        ret @{id: x.id, node: n, span: afp.new_span(s)};
     }
     fn f_constr(afp: ast_fold_precursor, f: ast_fold, &&x: @ast::constr) ->
        @ast::constr {

src/rustc/syntax/parse/parser.rs

@@ -385,19 +385,24 @@ fn parse_ty_postfix(orig_t: ast::ty_, p: parser, colons_before_params: bool,
         expect(p, token::LT);
     } else if !colons_before_params && p.token == token::LT {
         p.bump();
-    } else { ret @spanned(lo, p.last_span.hi, orig_t); }
+    } else {
+        ret @{id: p.get_id(),
+              node: orig_t,
+              span: ast_util::mk_sp(lo, p.last_span.hi)};
+    }
 
     // If we're here, we have explicit type parameter instantiation.
     let seq = parse_seq_to_gt(some(token::COMMA), {|p| parse_ty(p, false)},
                               p);
 
     alt orig_t {
       ast::ty_path(pth, ann) {
-        ret @spanned(lo, p.last_span.hi,
-                     ast::ty_path(@spanned(lo, p.last_span.hi,
-                                           {global: pth.node.global,
-                                            idents: pth.node.idents,
-                                            types: seq}), ann));
+        ret @{id: p.get_id(),
+              node: ast::ty_path(@spanned(lo, p.last_span.hi,
+                                          {global: pth.node.global,
+                                           idents: pth.node.idents,
+                                           types: seq}), ann),
+              span: ast_util::mk_sp(lo, p.last_span.hi)};
       }
       _ { p.fatal("type parameter instantiation only allowed for paths"); }
     }
@@ -407,11 +412,17 @@ fn parse_ret_ty(p: parser) -> (ast::ret_style, @ast::ty) {
     ret if eat(p, token::RARROW) {
         let lo = p.span.lo;
         if eat(p, token::NOT) {
-            (ast::noreturn, @spanned(lo, p.last_span.hi, ast::ty_bot))
-        } else { (ast::return_val, parse_ty(p, false)) }
+            (ast::noreturn, @{id: p.get_id(),
+                              node: ast::ty_bot,
+                              span: ast_util::mk_sp(lo, p.last_span.hi)})
+        } else {
+            (ast::return_val, parse_ty(p, false))
+        }
     } else {
         let pos = p.span.lo;
-        (ast::return_val, @spanned(pos, pos, ast::ty_nil))
+        (ast::return_val, @{id: p.get_id(),
+                            node: ast::ty_nil,
+                            span: ast_util::mk_sp(pos, pos)})
     }
 }
 
@@ -435,8 +446,11 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
     let lo = p.span.lo;
 
     alt have_dollar(p) {
-      some(e) {ret @spanned(lo, p.span.hi,
-                            ast::ty_mac(spanned(lo, p.span.hi, e)))}
+      some(e) {
+        ret @{id: p.get_id(),
+              node: ast::ty_mac(spanned(lo, p.span.hi, e)),
+              span: ast_util::mk_sp(lo, p.span.hi)};
+      }
       none {}
     }
 
@@ -475,7 +489,10 @@ fn parse_ty(p: parser, colons_before_params: bool) -> @ast::ty {
         let t = ast::ty_rec(elems.node);
         if p.token == token::COLON {
             p.bump();
-            ast::ty_constr(@spanned(lo, hi, t), parse_type_constraints(p))
+            ast::ty_constr(@{id: p.get_id(),
+                             node: t,
+                             span: ast_util::mk_sp(lo, hi)},
+                           parse_type_constraints(p))
         } else { t }
     } else if p.token == token::LBRACKET {
         expect(p, token::LBRACKET);
@@ -534,7 +551,9 @@ fn parse_fn_block_arg(p: parser) -> ast::arg {
     let t = if eat(p, token::COLON) {
                 parse_ty(p, false)
             } else {
-                @spanned(p.span.lo, p.span.hi, ast::ty_infer)
+                @{id: p.get_id(),
+                  node: ast::ty_infer,
+                  span: ast_util::mk_sp(p.span.lo, p.span.hi)}
             };
     ret {mode: m, ty: t, ident: i, id: p.get_id()};
 }
@@ -1606,7 +1625,9 @@ fn parse_local(p: parser, is_mutbl: bool,
                allow_init: bool) -> @ast::local {
     let lo = p.span.lo;
     let pat = parse_pat(p);
-    let ty = @spanned(lo, lo, ast::ty_infer);
+    let ty = @{id: p.get_id(),
+               node: ast::ty_infer,
+               span: ast_util::mk_sp(lo, lo)};
     if eat(p, token::COLON) { ty = parse_ty(p, false); }
     let init = if allow_init { parse_initializer(p) } else { none };
     ret @spanned(lo, p.last_span.hi,
@@ -1882,7 +1903,7 @@ fn parse_fn_block_decl(p: parser) -> ast::fn_decl {
     let output = if eat(p, token::RARROW) {
                      parse_ty(p, false)
                  } else {
-                     @spanned(p.span.lo, p.span.hi, ast::ty_infer)
+                     @{id: p.get_id(), node: ast::ty_infer, span: p.span}
                  };
     ret {inputs: inputs,
          output: output,
@@ -1957,7 +1978,7 @@ fn parse_item_iface(p: parser, attrs: [ast::attribute]) -> @ast::item {
 fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let lo = p.last_span.lo;
     fn wrap_path(p: parser, pt: @ast::path) -> @ast::ty {
-        @{node: ast::ty_path(pt, p.get_id()), span: pt.span}
+        @{id: p.get_id(), node: ast::ty_path(pt, p.get_id()), span: pt.span}
     }
     let (ident, tps) = if !is_word(p, "of") {
         if p.token == token::LT { (none, parse_ty_params(p)) }
@@ -1996,7 +2017,9 @@ fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
         {inputs:
              [{mode: ast::expl(ast::by_ref), ty: t,
                ident: arg_ident, id: p.get_id()}],
-         output: @spanned(lo, lo, ast::ty_nil),
+         output: @{id: p.get_id(),
+                   node: ast::ty_nil,
+                   span: ast_util::mk_sp(lo, lo)},
          purity: ast::impure_fn,
          cf: ast::return_val,
          constraints: []};
@@ -2066,8 +2089,9 @@ enum class_contents { ctor_decl(ast::fn_decl, ast::blk, codemap::span),
         // Can ctors have attrs?
             // result type is always the type of the class
         let decl_ = parse_fn_decl(p, ast::impure_fn);
-        let decl = {output: @{node: ast::ty_path(class_name, p.get_id()),
-                                  span: decl_.output.span}
+        let decl = {output: @{id: p.get_id(),
+                              node: ast::ty_path(class_name, p.get_id()),
+                              span: decl_.output.span}
                     with decl_};
         let body = parse_block(p);
         ret ctor_decl(decl, body, ast_util::mk_sp(lo, p.last_span.hi));