rustc: Split out struct bodies into a separate "struct_def" type in the AST

8 files changed, 53 insertions, 50 deletions

diff --git a/src/rustc/middle/resolve3.rs b/src/rustc/middle/resolve3.rs
index 15ebe1c14d0..a2bd1280021 100644
--- a/src/rustc/middle/resolve3.rs
+++ b/src/rustc/middle/resolve3.rs
@@ -984,13 +984,13 @@ class Resolver {
                                                          visitor);
                 }
             }
-            item_class(_, _, class_members, optional_ctor, _) => {
+            item_class(struct_definition, _) => {
               let (name_bindings, new_parent) = self.add_child(atom, parent,
                                               ~[ValueNS, TypeNS], sp);
 
                 (*name_bindings).define_type(def_ty(local_def(item.id)), sp);
 
-                match optional_ctor {
+                match struct_definition.ctor {
                     none => {
                         // Nothing to do.
                     }
@@ -1008,7 +1008,7 @@ class Resolver {
                 // bindings.
 
                 let mut method_infos = ~[];
-                for class_members.each |class_member| {
+                for struct_definition.members.each |class_member| {
                     match class_member.node {
                         class_method(method) => {
                             // XXX: Combine with impl method code below.
@@ -1037,7 +1037,7 @@ class Resolver {
 
                 // Record the def ID of this struct.
                 self.structs.insert(local_def(item.id),
-                                    is_some(optional_ctor));
+                                    is_some(struct_definition.ctor));
 
                 visit_item(item, new_parent, visitor);
             }
@@ -3249,15 +3249,13 @@ class Resolver {
                 (*self.type_ribs).pop();
             }
 
-            item_class(ty_params, traits, class_members,
-                       optional_constructor, optional_destructor) => {
-
+            item_class(struct_def, ty_params) => {
                 self.resolve_class(item.id,
                                    @copy ty_params,
-                                   traits,
-                                   class_members,
-                                   optional_constructor,
-                                   optional_destructor,
+                                   struct_def.traits,
+                                   struct_def.members,
+                                   struct_def.ctor,
+                                   struct_def.dtor,
                                    visitor);
             }
 
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index eb23008f185..e5a3a8e4e13 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -4899,17 +4899,17 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         };
         foreign::trans_foreign_mod(ccx, foreign_mod, abi);
       }
-      ast::item_class(tps, _traits, items, m_ctor, m_dtor) => {
+      ast::item_class(struct_def, tps) => {
         if tps.len() == 0u {
           let psubsts = {tys: ty::ty_params_to_tys(ccx.tcx, tps),
                          vtables: none,
                          bounds: @~[]};
-          do option::iter(m_ctor) |ctor| {
+          do option::iter(struct_def.ctor) |ctor| {
             trans_class_ctor(ccx, *path, ctor.node.dec, ctor.node.body,
                              get_item_val(ccx, ctor.node.id), psubsts,
                              ctor.node.id, local_def(item.id), ctor.span);
           }
-          do option::iter(m_dtor) |dtor| {
+          do option::iter(struct_def.dtor) |dtor| {
              trans_class_dtor(ccx, *path, dtor.node.body,
                dtor.node.id, none, none, local_def(item.id));
           };
@@ -4917,7 +4917,7 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         // If there are ty params, the ctor will get monomorphized
 
         // Translate methods
-        let (_, ms) = ast_util::split_class_items(items);
+        let (_, ms) = ast_util::split_class_items(struct_def.members);
         impl::trans_impl(ccx, *path, item.ident, ms, tps);
       }
       _ => {/* fall through */ }
diff --git a/src/rustc/middle/trans/impl.rs b/src/rustc/middle/trans/impl.rs
index 066c1bedba2..7bac09e3706 100644
--- a/src/rustc/middle/trans/impl.rs
+++ b/src/rustc/middle/trans/impl.rs
@@ -94,8 +94,8 @@ fn method_with_name(ccx: @crate_ctxt, impl_id: ast::def_id,
             method_from_methods(ms, name)
           }
           ast_map::node_item(@{node:
-              ast::item_class(_, _, items, _, _), _}, _) => {
-            let (_,ms) = split_class_items(items);
+              ast::item_class(struct_def, _), _}, _) => {
+            let (_,ms) = split_class_items(struct_def.members);
             method_from_methods(ms, name)
           }
         }
diff --git a/src/rustc/middle/trans/reachable.rs b/src/rustc/middle/trans/reachable.rs
index 9637b5b7ce5..8cf4bde575d 100644
--- a/src/rustc/middle/trans/reachable.rs
+++ b/src/rustc/middle/trans/reachable.rs
@@ -111,22 +111,22 @@ fn traverse_public_item(cx: ctx, item: @item) {
             }
         }
       }
-      item_class(tps, _traits, items, m_ctor, m_dtor) => {
-        do option::iter(m_ctor) |ctor| {
+      item_class(struct_def, tps) => {
+        do option::iter(struct_def.ctor) |ctor| {
             cx.rmap.insert(ctor.node.id, ());
             if tps.len() > 0u || attr::find_inline_attr(ctor.node.attrs)
                      != attr::ia_none {
                 traverse_inline_body(cx, ctor.node.body);
             }
         }
-        do option::iter(m_dtor) |dtor| {
+        do option::iter(struct_def.dtor) |dtor| {
             cx.rmap.insert(dtor.node.id, ());
             if tps.len() > 0u || attr::find_inline_attr(dtor.node.attrs)
                      != attr::ia_none {
                 traverse_inline_body(cx, dtor.node.body);
             }
         }
-        for vec::each(items) |item| {
+        for vec::each(struct_def.members) |item| {
             match item.node {
               class_method(m) => {
                 cx.rmap.insert(m.id, ());
@@ -214,7 +214,7 @@ fn traverse_all_resources_and_impls(cx: ctx, crate_mod: _mod) {
         visit_item: |i, cx, v| {
             visit::visit_item(i, cx, v);
             match i.node {
-              item_class(_, _, _, _, some(_)) => {
+              item_class(struct_def, _) if struct_def.dtor.is_some() => {
                 traverse_public_item(cx, i);
               }
               item_impl(*) => {
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index db8d2b3ae3e..285e0068f66 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -2741,10 +2741,13 @@ fn item_path_str(cx: ctxt, id: ast::def_id) -> ~str {
 fn ty_dtor(cx: ctxt, class_id: def_id) -> option<def_id> {
     if is_local(class_id) {
        match cx.items.find(class_id.node) {
-         some(ast_map::node_item(@{node: ast::item_class(_, _, _, _,
-                                     some(dtor)), _}, _))
-             => some(local_def(dtor.node.id)),
-         _  => none
+           some(ast_map::node_item(@{
+               node: ast::item_class({ dtor: some(dtor), _ }, _),
+               _
+           }, _)) =>
+               some(local_def(dtor.node.id)),
+           _ =>
+               none
        }
     }
     else {
@@ -2936,8 +2939,8 @@ fn lookup_class_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] {
     match cx.items.find(did.node) {
        some(ast_map::node_item(i,_)) => {
          match i.node {
-                 ast::item_class(_, _, items, _, _) => {
-               class_field_tys(items)
+                 ast::item_class(struct_def, _) => {
+               class_field_tys(struct_def.members)
            }
            _ => cx.sess.bug(~"class ID bound to non-class")
          }
@@ -2990,9 +2993,9 @@ fn lookup_class_method_by_name(cx:ctxt, did: ast::def_id, name: ident,
         assert is_local(did);
         match cx.items.find(did.node) {
           some(ast_map::node_item(@{
-            node: item_class(_,_,items,_,_), _
+            node: item_class(struct_def, _), _
           }, _)) => {
-            let (_,ms) = split_class_items(items);
+            let (_,ms) = split_class_items(struct_def.members);
             vec::map(ms, |m| {name: m.ident, id: m.id,
                               vis: m.vis})
           }
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index 5b0f663114d..9dac176c564 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -432,12 +432,12 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
             }
         }
       }
-      ast::item_class(tps, _, members, m_ctor, m_dtor) => {
+      ast::item_class(struct_def, _) => {
         let tcx = ccx.tcx;
         let class_t = {self_ty: ty::node_id_to_type(tcx, it.id),
                        node_id: it.id};
 
-        do option::iter(m_ctor) |ctor| {
+        do option::iter(struct_def.ctor) |ctor| {
             // typecheck the ctor
             check_bare_fn(ccx, ctor.node.dec,
                           ctor.node.body, ctor.node.id,
@@ -446,7 +446,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
             write_ty_to_tcx(tcx, ctor.node.self_id, class_t.self_ty);
         }
 
-        do option::iter(m_dtor) |dtor| {
+        do option::iter(struct_def.dtor) |dtor| {
             // typecheck the dtor
             check_bare_fn(ccx, ast_util::dtor_dec(),
                           dtor.node.body, dtor.node.id,
@@ -456,9 +456,11 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
         };
 
         // typecheck the members
-        for members.each |m| { check_class_member(ccx, class_t, m); }
+        for struct_def.members.each |m| {
+            check_class_member(ccx, class_t, m);
+        }
         // Check that there's at least one field
-        let (fields,_) = split_class_items(members);
+        let (fields,_) = split_class_items(struct_def.members);
         if fields.len() < 1u {
             ccx.tcx.sess.span_err(
                 it.span,
@@ -747,8 +749,8 @@ fn impl_self_ty(fcx: @fn_ctxt, did: ast::def_id) -> ty_param_substs_and_ty {
              rp: rp,
              raw_ty: fcx.ccx.to_ty(rscope::type_rscope(rp), st)}
           }
-          some(ast_map::node_item(@{node: ast::item_class(ts,
-                                 _,_,_,_), id: class_id, _},_)) => {
+          some(ast_map::node_item(@{node: ast::item_class(_, ts),
+                                    id: class_id, _},_)) => {
               /* If the impl is a class, the self ty is just the class ty
                  (doing a no-op subst for the ty params; in the next step,
                  we substitute in fresh vars for them)
@@ -1720,7 +1722,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
                 tcx.region_paramd_items.contains_key(class_id.node);
             match tcx.items.find(class_id.node) {
                 some(ast_map::node_item(@{
-                        node: ast::item_class(type_parameters, _, _, _, _),
+                        node: ast::item_class(_, type_parameters),
                         _
                     }, _)) => {
 
diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs
index 037a93fdf3d..798c3a2af17 100644
--- a/src/rustc/middle/typeck/coherence.rs
+++ b/src/rustc/middle/typeck/coherence.rs
@@ -163,8 +163,8 @@ class CoherenceChecker {
                     item_impl(_, associated_traits, _, _) => {
                         self.check_implementation(item, associated_traits);
                     }
-                    item_class(_, associated_traits, _, _, _) => {
-                        self.check_implementation(item, associated_traits);
+                    item_class(struct_def, _) => {
+                        self.check_implementation(item, struct_def.traits);
                     }
                     _ => {
                         // Nothing to do.
@@ -505,9 +505,9 @@ class CoherenceChecker {
                     methods: methods
                 };
             }
-            item_class(ty_params, _, class_members, _, _) => {
+            item_class(struct_def, ty_params) => {
                 let mut methods = ~[];
-                for class_members.each |class_member| {
+                for struct_def.members.each |class_member| {
                     match class_member.node {
                         instance_var(*) => {
                             // Nothing to do.
diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs
index 3f68cc40f1d..c9da4db0531 100644
--- a/src/rustc/middle/typeck/collect.rs
+++ b/src/rustc/middle/typeck/collect.rs
@@ -162,8 +162,8 @@ fn ensure_trait_methods(ccx: @crate_ctxt, id: ast::node_id) {
             }
         });
       }
-      ast_map::node_item(@{node: ast::item_class(_,_,its,_,_), _}, _) => {
-        let (_,ms) = split_class_items(its);
+      ast_map::node_item(@{node: ast::item_class(struct_def, _), _}, _) => {
+        let (_,ms) = split_class_items(struct_def.members);
         // All methods need to be stored, since lookup_method
         // relies on the same method cache for self-calls
         store_methods::<@ast::method>(ccx, id, ms, |m| {
@@ -382,13 +382,13 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
         // check_methods_against_trait(ccx, tps, rp, selfty, t, cms);
         // }
       }
-      ast::item_class(tps, trait_refs, members, m_ctor, m_dtor) => {
+      ast::item_class(struct_def, tps) => {
         // Write the class type
         let tpt = ty_of_item(ccx, it);
         write_ty_to_tcx(tcx, it.id, tpt.ty);
         tcx.tcache.insert(local_def(it.id), tpt);
 
-        do option::iter(m_ctor) |ctor| {
+        do option::iter(struct_def.ctor) |ctor| {
             // Write the ctor type
             let t_args = ctor.node.dec.inputs.map(
                 |a| ty_of_arg(ccx, type_rscope(rp), a, none) );
@@ -411,7 +411,7 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
                                ty: t_ctor});
         }
 
-        do option::iter(m_dtor) |dtor| {
+        do option::iter(struct_def.dtor) |dtor| {
             // Write the dtor type
             let t_dtor = ty::mk_fn(
                 tcx,
@@ -426,14 +426,14 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
         ensure_trait_methods(ccx, it.id);
 
         // Write the type of each of the members
-        let (fields, methods) = split_class_items(members);
+        let (fields, methods) = split_class_items(struct_def.members);
         for fields.each |f| {
            convert_field(ccx, rp, tpt.bounds, f);
         }
         let {bounds, substs} = mk_substs(ccx, tps, rp);
         let selfty = ty::mk_class(tcx, local_def(it.id), substs);
         let cms = convert_methods(ccx, methods, rp, bounds, selfty);
-        for trait_refs.each |trait_ref| {
+        for struct_def.traits.each |trait_ref| {
             check_methods_against_trait(ccx, tps, rp, selfty, trait_ref, cms);
             // trait_ref.impl_id represents (class, trait) pair
             write_ty_to_tcx(tcx, trait_ref.impl_id, tpt.ty);
@@ -583,7 +583,7 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item)
         tcx.tcache.insert(local_def(it.id), tpt);
         return tpt;
       }
-      ast::item_class(tps, _, _, _, _) => {
+      ast::item_class(_, tps) => {
           let {bounds,substs} = mk_substs(ccx, tps, rp);
           let t = ty::mk_class(tcx, local_def(it.id), substs);
           let tpt = {bounds: bounds, rp: rp, ty: t};