Refactor ast::item representation

Most of the fields in an AST item were present in all variants. Things
could be simplified considerably by putting them in the rec rather
than in the variant tags.

Author: marijnh

src/comp/front/ast.rs

@@ -459,28 +459,21 @@ tag attr_style { attr_outer; attr_inner; }
 
 type attribute_ = rec(attr_style style, meta_item value);
 
-type item = spanned[item_];
+type item = rec(ident ident,
+                vec[attribute] attrs,
+                def_id id, // For objs, this is the type def_id
+                ann ann,
+                item_ node,
+                span span);
 
 tag item_ {
-    item_const(ident, @ty, @expr, vec[attribute], def_id, ann);
-    item_fn(ident, _fn, vec[ty_param], vec[attribute], def_id, ann);
-    item_mod(ident, _mod, vec[attribute], def_id);
-    item_native_mod(ident, native_mod, vec[attribute], def_id);
-    item_ty(ident, @ty, vec[ty_param], vec[attribute], def_id, ann);
-    item_tag(ident, vec[variant], vec[ty_param], vec[attribute], def_id, ann);
-    item_obj(ident, _obj, vec[ty_param], vec[attribute], obj_def_ids, ann);
-}
-
-fn item_ident(@item it) -> ident {
-    ret alt (it.node) {
-            case (item_const(?ident, _, _, _, _, _)) { ident }
-            case (item_fn(?ident, _, _, _, _, _)) { ident }
-            case (item_mod(?ident, _, _, _)) { ident }
-            case (item_native_mod(?ident, _, _, _)) { ident }
-            case (item_ty(?ident, _, _, _, _, _)) { ident }
-            case (item_tag(?ident, _, _, _, _, _)) { ident }
-            case (item_obj(?ident, _, _, _, _, _)) { ident }
-        }
+    item_const(@ty, @expr);
+    item_fn(_fn, vec[ty_param]);
+    item_mod(_mod);
+    item_native_mod(native_mod);
+    item_ty(@ty, vec[ty_param]);
+    item_tag(vec[variant], vec[ty_param]);
+    item_obj(_obj, vec[ty_param], def_id /* constructor id */);
 }
 
 type native_item = spanned[native_item_];
@@ -498,15 +491,16 @@ tag native_item_ {
 fn is_exported(ident i, _mod m) -> bool {
     auto nonlocal = true;
     for (@ast::item it in m.items) {
-        if (item_ident(it) == i) { nonlocal = false; }
+        if (it.ident == i) { nonlocal = false; }
         alt (it.node) {
-            case (item_tag(_, ?variants, _, _, _, _)) {
+            case (item_tag(?variants, _)) {
                 for (variant v in variants) {
                     if (v.node.name == i) { nonlocal = false; }
                 }
             }
             case (_) { }
         }
+        if (!nonlocal) { break; }
     }
     auto count = 0u;
     for (@ast::view_item vi in m.view_items) {
@@ -525,7 +519,7 @@ fn is_exported(ident i, _mod m) -> bool {
 
     // If there are no declared exports then 
     // everything not imported is exported
-    if (count == 0u && !nonlocal) { ret true; } else { ret false; }
+    ret count == 0u && !nonlocal;
 }
 
 fn is_call_expr(@expr e) -> bool {

src/comp/front/eval.rs

@@ -294,17 +294,17 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
             cx.p.set_def(next_id._1);
             cx.chpos = p0.get_chpos();
             cx.next_ann = p0.next_ann_num();
-            auto im = ast::item_mod(id, m0, [], next_id);
-            auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
+            auto i = front::parser::mk_item(cx.p, cdir.span.lo, cdir.span.hi,
+                                            id, ast::item_mod(m0), []);
             vec::push[@ast::item](items, i);
         }
         case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
             auto path = id;
             alt (dir_opt) { case (some(?d)) { path = d; } case (none) { } }
             auto full_path = prefix + std::fs::path_sep() + path;
             auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
-            auto im = ast::item_mod(id, m0, [], cx.p.next_def_id());
-            auto i = @spanned(cdir.span.lo, cdir.span.hi, im);
+            auto i = front::parser::mk_item
+                (cx.p, cdir.span.lo, cdir.span.hi, id, ast::item_mod(m0), []);
             vec::push[@ast::item](items, i);
         }
         case (ast::cdir_view_item(?vi)) {

src/comp/front/parser.rs

@@ -1662,14 +1662,22 @@ fn parse_fn_header(&parser p) -> tup(ast::ident, vec[ast::ty_param]) {
     ret tup(id, ty_params);
 }
 
+fn mk_item(&parser p, uint lo, uint hi, &ast::ident ident, &ast::item_ node,
+           &vec[ast::attribute] attrs) -> @ast::item {
+    ret @rec(ident=ident,
+             attrs=attrs,
+             id=p.next_def_id(),
+             ann=p.get_ann(),
+             node=node,
+             span=rec(lo=lo, hi=hi));
+}
+
 fn parse_item_fn_or_iter(&parser p, ast::purity purity, ast::proto proto,
                          vec[ast::attribute] attrs) -> @ast::item {
     auto lo = p.get_last_lo_pos();
     auto t = parse_fn_header(p);
     auto f = parse_fn(p, proto, purity);
-    auto item =
-        ast::item_fn(t._0, f, t._1, attrs, p.next_def_id(), p.get_ann());
-    ret @spanned(lo, f.body.span.hi, item);
+    ret mk_item(p, lo, f.body.span.hi, t._0, ast::item_fn(f, t._1), attrs);
 }
 
 fn parse_obj_field(&parser p) -> ast::obj_field {
@@ -1727,9 +1735,8 @@ fn parse_item_obj(&parser p, ast::layer lyr, vec[ast::attribute] attrs) ->
     auto hi = p.get_hi_pos();
     expect(p, token::RBRACE);
     let ast::_obj ob = rec(fields=fields.node, methods=meths, dtor=dtor);
-    auto odid = rec(ty=p.next_def_id(), ctor=p.next_def_id());
-    auto item = ast::item_obj(ident, ob, ty_params, attrs, odid, p.get_ann());
-    ret @spanned(lo, hi, item);
+    ret mk_item(p, lo, hi, ident, ast::item_obj(ob, ty_params,
+                                                p.next_def_id()), attrs);
 }
 
 fn parse_mod_items(&parser p, token::token term) -> ast::_mod {
@@ -1756,9 +1763,7 @@ fn parse_item_const(&parser p, vec[ast::attribute] attrs) -> @ast::item {
     auto e = parse_expr(p);
     auto hi = p.get_hi_pos();
     expect(p, token::SEMI);
-    auto item =
-        ast::item_const(id, ty, e, attrs, p.next_def_id(), p.get_ann());
-    ret @spanned(lo, hi, item);
+    ret mk_item(p, lo, hi, id, ast::item_const(ty, e), attrs);
 }
 
 fn parse_item_mod(&parser p, vec[ast::attribute] attrs) -> @ast::item {
@@ -1768,8 +1773,7 @@ fn parse_item_mod(&parser p, vec[ast::attribute] attrs) -> @ast::item {
     auto m = parse_mod_items(p, token::RBRACE);
     auto hi = p.get_hi_pos();
     expect(p, token::RBRACE);
-    auto item = ast::item_mod(id, m, attrs, p.next_def_id());
-    ret @spanned(lo, hi, item);
+    ret mk_item(p, lo, hi, id, ast::item_mod(m), attrs);
 }
 
 fn parse_item_native_type(&parser p) -> @ast::native_item {
@@ -1856,8 +1860,7 @@ fn parse_item_native_mod(&parser p, vec[ast::attribute] attrs) -> @ast::item {
     auto m = parse_native_mod_items(p, native_name, abi);
     auto hi = p.get_hi_pos();
     expect(p, token::RBRACE);
-    auto item = ast::item_native_mod(id, m, attrs, p.next_def_id());
-    ret @spanned(lo, hi, item);
+    ret mk_item(p, lo, hi, id, ast::item_native_mod(m), attrs);
 }
 
 fn parse_type_decl(&parser p) -> tup(uint, ast::ident) {
@@ -1873,9 +1876,7 @@ fn parse_item_type(&parser p, vec[ast::attribute] attrs) -> @ast::item {
     auto ty = parse_ty(p);
     auto hi = p.get_hi_pos();
     expect(p, token::SEMI);
-    auto item =
-        ast::item_ty(t._1, ty, tps, attrs, p.next_def_id(), p.get_ann());
-    ret @spanned(t._0, hi, item);
+    ret mk_item(p, t._0, hi, t._1, ast::item_ty(ty, tps), attrs);
 }
 
 fn parse_item_tag(&parser p, vec[ast::attribute] attrs) -> @ast::item {
@@ -1922,10 +1923,7 @@ fn parse_item_tag(&parser p, vec[ast::attribute] attrs) -> @ast::item {
     }
     auto hi = p.get_hi_pos();
     p.bump();
-    auto item =
-        ast::item_tag(id, variants, ty_params, attrs, p.next_def_id(),
-                      p.get_ann());
-    ret @spanned(lo, hi, item);
+    ret mk_item(p, lo, hi, id, ast::item_tag(variants, ty_params), attrs);
 }
 
 fn parse_layer(&parser p) -> ast::layer {

src/comp/middle/alias.rs

@@ -63,7 +63,7 @@ fn visit_fn(@ctx cx, &ast::_fn f, &vec[ast::ty_param] tp, &span sp,
 
 fn visit_item(@ctx cx, &@ast::item i, &scope sc, &vt[scope] v) {
     alt (i.node) {
-        case (ast::item_obj(_, ?o, _, _, _, _)) {
+        case (ast::item_obj(?o, _, _)) {
             for (ast::obj_field f in o.fields) {
                 cx.local_map.insert(f.id._1, objfield(f.mut));
             }

src/comp/middle/metadata.rs

@@ -361,64 +361,65 @@ fn encode_module_item_paths(&ebml::writer ebml_w, &ast::_mod module,
                             &vec[str] path,
                             &mutable vec[tup(str, uint)] index) {
     for (@ast::item it in module.items) {
-        if (!ast::is_exported(ast::item_ident(it), module)) { cont; }
+        if (!ast::is_exported(it.ident, module)) { cont; }
         alt (it.node) {
-            case (ast::item_const(?id, _, ?tps, _, ?did, ?ann)) {
-                add_to_index(ebml_w, path, index, id);
+            case (ast::item_const(_, _)) {
+                add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_item);
-                encode_name(ebml_w, id);
-                encode_def_id(ebml_w, did);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, it.id);
                 ebml::end_tag(ebml_w);
             }
-            case (ast::item_fn(?id, _, ?tps, _, ?did, ?ann)) {
-                add_to_index(ebml_w, path, index, id);
+            case (ast::item_fn(_, ?tps)) {
+                add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_item);
-                encode_name(ebml_w, id);
-                encode_def_id(ebml_w, did);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, it.id);
                 ebml::end_tag(ebml_w);
             }
-            case (ast::item_mod(?id, ?_mod, _, ?did)) {
-                add_to_index(ebml_w, path, index, id);
+            case (ast::item_mod(?_mod)) {
+                add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_mod);
-                encode_name(ebml_w, id);
-                encode_def_id(ebml_w, did);
-                encode_module_item_paths(ebml_w, _mod, path + [id], index);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, it.id);
+                encode_module_item_paths(ebml_w, _mod, path + [it.ident],
+                                         index);
                 ebml::end_tag(ebml_w);
             }
-            case (ast::item_native_mod(?id, ?nmod, _, ?did)) {
-                add_to_index(ebml_w, path, index, id);
+            case (ast::item_native_mod(?nmod)) {
+                add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_mod);
-                encode_name(ebml_w, id);
-                encode_def_id(ebml_w, did);
-                encode_native_module_item_paths(ebml_w, nmod, path + [id],
-                                                index);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, it.id);
+                encode_native_module_item_paths(ebml_w, nmod,
+                                                path + [it.ident], index);
                 ebml::end_tag(ebml_w);
             }
-            case (ast::item_ty(?id, _, ?tps, _, ?did, ?ann)) {
-                add_to_index(ebml_w, path, index, id);
+            case (ast::item_ty(_, ?tps)) {
+                add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_item);
-                encode_name(ebml_w, id);
-                encode_def_id(ebml_w, did);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, it.id);
                 ebml::end_tag(ebml_w);
             }
-            case (ast::item_tag(?id, ?variants, ?tps, _, ?did, _)) {
-                add_to_index(ebml_w, path, index, id);
+            case (ast::item_tag(?variants, ?tps)) {
+                add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_item);
-                encode_name(ebml_w, id);
-                encode_def_id(ebml_w, did);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, it.id);
                 ebml::end_tag(ebml_w);
                 encode_tag_variant_paths(ebml_w, variants, path, index);
             }
-            case (ast::item_obj(?id, _, ?tps, _, ?odid, ?ann)) {
-                add_to_index(ebml_w, path, index, id);
+            case (ast::item_obj(_, ?tps, ?ctor_id)) {
+                add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_item);
-                encode_name(ebml_w, id);
-                encode_def_id(ebml_w, odid.ctor);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, ctor_id);
                 ebml::end_tag(ebml_w);
-                add_to_index(ebml_w, path, index, id);
+                add_to_index(ebml_w, path, index, it.ident);
                 ebml::start_tag(ebml_w, tag_paths_data_item);
-                encode_name(ebml_w, id);
-                encode_def_id(ebml_w, odid.ty);
+                encode_name(ebml_w, it.ident);
+                encode_def_id(ebml_w, it.id);
                 ebml::end_tag(ebml_w);
             }
         }
@@ -509,67 +510,68 @@ fn encode_tag_variant_info(&@trans::crate_ctxt cx, &ebml::writer ebml_w,
 fn encode_info_for_item(@trans::crate_ctxt cx, &ebml::writer ebml_w,
                         @ast::item item, &mutable vec[tup(int, uint)] index) {
     alt (item.node) {
-        case (ast::item_const(_, _, _, _, ?did, ?ann)) {
+        case (ast::item_const(_, _)) {
             ebml::start_tag(ebml_w, tag_items_data_item);
-            encode_def_id(ebml_w, did);
+            encode_def_id(ebml_w, item.id);
             encode_kind(ebml_w, 'c' as u8);
-            encode_type(cx, ebml_w, trans::node_ann_type(cx, ann));
-            encode_symbol(cx, ebml_w, did);
+            encode_type(cx, ebml_w, trans::node_ann_type(cx, item.ann));
+            encode_symbol(cx, ebml_w, item.id);
             ebml::end_tag(ebml_w);
         }
-        case (ast::item_fn(_, _, ?tps, _, ?did, ?ann)) {
+        case (ast::item_fn(_, ?tps)) {
             ebml::start_tag(ebml_w, tag_items_data_item);
-            encode_def_id(ebml_w, did);
+            encode_def_id(ebml_w, item.id);
             encode_kind(ebml_w, 'f' as u8);
             encode_type_param_count(ebml_w, tps);
-            encode_type(cx, ebml_w, trans::node_ann_type(cx, ann));
-            encode_symbol(cx, ebml_w, did);
+            encode_type(cx, ebml_w, trans::node_ann_type(cx, item.ann));
+            encode_symbol(cx, ebml_w, item.id);
             ebml::end_tag(ebml_w);
         }
-        case (ast::item_mod(_, _, _, ?did)) {
+        case (ast::item_mod(_)) {
             ebml::start_tag(ebml_w, tag_items_data_item);
-            encode_def_id(ebml_w, did);
+            encode_def_id(ebml_w, item.id);
             encode_kind(ebml_w, 'm' as u8);
             ebml::end_tag(ebml_w);
         }
-        case (ast::item_native_mod(?id, _, _, ?did)) {
+        case (ast::item_native_mod(_)) {
             ebml::start_tag(ebml_w, tag_items_data_item);
-            encode_def_id(ebml_w, did);
+            encode_def_id(ebml_w, item.id);
             encode_kind(ebml_w, 'n' as u8);
             ebml::end_tag(ebml_w);
         }
-        case (ast::item_ty(?id, _, ?tps, _, ?did, ?ann)) {
+        case (ast::item_ty(_, ?tps)) {
             ebml::start_tag(ebml_w, tag_items_data_item);
-            encode_def_id(ebml_w, did);
+            encode_def_id(ebml_w, item.id);
             encode_kind(ebml_w, 'y' as u8);
             encode_type_param_count(ebml_w, tps);
-            encode_type(cx, ebml_w, trans::node_ann_type(cx, ann));
+            encode_type(cx, ebml_w, trans::node_ann_type(cx, item.ann));
             ebml::end_tag(ebml_w);
         }
-        case (ast::item_tag(?id, ?variants, ?tps, _, ?did, ?ann)) {
+        case (ast::item_tag(?variants, ?tps)) {
             ebml::start_tag(ebml_w, tag_items_data_item);
-            encode_def_id(ebml_w, did);
+            encode_def_id(ebml_w, item.id);
             encode_kind(ebml_w, 't' as u8);
             encode_type_param_count(ebml_w, tps);
-            encode_type(cx, ebml_w, trans::node_ann_type(cx, ann));
+            encode_type(cx, ebml_w, trans::node_ann_type(cx, item.ann));
             for (ast::variant v in variants) {
                 encode_variant_id(ebml_w, v.node.id);
             }
             ebml::end_tag(ebml_w);
-            encode_tag_variant_info(cx, ebml_w, did, variants, index, tps);
+            encode_tag_variant_info(cx, ebml_w, item.id, variants,
+                                    index, tps);
         }
-        case (ast::item_obj(?id, _, ?tps, _, ?odid, ?ann)) {
+        case (ast::item_obj(_, ?tps, ?ctor_id)) {
             ebml::start_tag(ebml_w, tag_items_data_item);
-            encode_def_id(ebml_w, odid.ctor);
+            encode_def_id(ebml_w, ctor_id);
             encode_kind(ebml_w, 'o' as u8);
             encode_type_param_count(ebml_w, tps);
-            auto fn_ty = trans::node_ann_type(cx, ann);
+            auto fn_ty = trans::node_ann_type(cx, item.ann);
             encode_type(cx, ebml_w, fn_ty);
-            encode_symbol(cx, ebml_w, odid.ctor);
+            encode_symbol(cx, ebml_w, ctor_id);
             ebml::end_tag(ebml_w);
-            index += [tup(odid.ty._1, ebml_w.writer.tell())];
+            index += [tup(item.id._1, ebml_w.writer.tell())];
             ebml::start_tag(ebml_w, tag_items_data_item);
-            encode_def_id(ebml_w, odid.ty);
+            encode_def_id(ebml_w, item.id);
             encode_kind(ebml_w, 'y' as u8);
             encode_type_param_count(ebml_w, tps);
             encode_type(cx, ebml_w, ty::ty_fn_ret(cx.tcx, fn_ty));