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

6 files changed, 50 insertions, 35 deletions

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 87fe7fe67a9..78b1fa0a469 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -711,6 +711,17 @@ type trait_ref = {path: @path, ref_id: node_id, impl_id: node_id};
 enum visibility { public, private, inherited }
 
 #[auto_serialize]
+type struct_def = {
+    traits: ~[@trait_ref],   /* traits this class implements */
+    members: ~[@class_member], /* methods, etc. */
+    /* (not including ctor or dtor) */
+    /* ctor is optional, and will soon go away */
+    ctor: option<class_ctor>,
+    /* dtor is optional */
+    dtor: option<class_dtor>
+};
+
+#[auto_serialize]
 type item = {ident: ident, attrs: ~[attribute],
              id: node_id, node: item_,
              vis: visibility, span: span};
@@ -723,15 +734,7 @@ enum item_ {
     item_foreign_mod(foreign_mod),
     item_ty(@ty, ~[ty_param]),
     item_enum(~[variant], ~[ty_param]),
-    item_class(~[ty_param], /* ty params for class */
-               ~[@trait_ref],   /* traits this class implements */
-               ~[@class_member], /* methods, etc. */
-                               /* (not including ctor or dtor) */
-               /* ctor is optional, and will soon go away */
-               option<class_ctor>,
-               /* dtor is optional */
-               option<class_dtor>
-               ),
+    item_class(struct_def, ~[ty_param]),
     item_trait(~[ty_param], ~[@trait_ref], ~[trait_method]),
     item_impl(~[ty_param],
               ~[@trait_ref], /* traits this impl implements */
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index acd62b6a536..0c3e99a3794 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -216,11 +216,11 @@ fn map_item(i: @item, cx: ctx, v: vt) {
                                            extend(cx, i.ident)));
         }
       }
-      item_class(tps, traits, items, ctor, dtor) => {
-          let (_, ms) = ast_util::split_class_items(items);
+      item_class(struct_def, _) => {
+          let (_, ms) = ast_util::split_class_items(struct_def.members);
           // Map trait refs to their parent classes. This is
           // so we can find the self_ty
-          for traits.each |p| {
+          for struct_def.traits.each |p| {
               cx.map.insert(p.ref_id, node_item(i, item_path));
               // This is so we can look up the right things when
               // encoding/decoding
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 0ceee7f7d97..05f74a9c899 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -242,9 +242,9 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
             item_enum(vec::map(variants, |x| fld.fold_variant(x)),
                       fold_ty_params(typms, fld))
           }
-          item_class(typms, traits, items, m_ctor, m_dtor) => {
+          item_class(struct_def, typms) => {
             let resulting_optional_constructor;
-            match m_ctor {
+            match struct_def.ctor {
                 none => {
                     resulting_optional_constructor = none;
                 }
@@ -260,18 +260,20 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                     });
                 }
             }
-            let dtor = do option::map(m_dtor) |dtor| {
+            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 with dtor.node}
                     with dtor}};
-              item_class(
-                  /* FIXME (#2543) */ copy typms,
-                  vec::map(traits, |p| fold_trait_ref(p, fld)),
-                  vec::map(items, |x| fld.fold_class_item(x)),
-                  resulting_optional_constructor,
-                  dtor)
+              item_class({
+                  traits: vec::map(struct_def.traits,
+                                   |p| fold_trait_ref(p, fld)),
+                  members: vec::map(struct_def.members,
+                                    |x| fld.fold_class_item(x)),
+                  ctor: resulting_optional_constructor,
+                  dtor: dtor},
+                  /* FIXME (#2543) */ copy typms)
           }
           item_impl(tps, ifce, ty, methods) => {
               item_impl(fold_ty_params(tps, fld),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 5feb753657d..52a93a60361 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2581,18 +2581,28 @@ class parser {
         match the_ctor {
           some((ct_d, ct_attrs, ct_b, ct_s)) => {
             (class_name,
-             item_class(ty_params, traits, ms, some({
+             item_class({
+                traits: traits,
+                members: ms,
+                ctor: some({
                  node: {id: ctor_id,
                         attrs: ct_attrs,
                         self_id: self.get_id(),
                         dec: ct_d,
                         body: ct_b},
-                 span: ct_s}), actual_dtor),
+                 span: ct_s}),
+                dtor: actual_dtor
+             }, ty_params),
              none)
           }
           none => {
             (class_name,
-             item_class(ty_params, traits, ms, none, actual_dtor),
+             item_class({
+                    traits: traits,
+                    members: ms,
+                    ctor: none,
+                    dtor: actual_dtor
+             }, ty_params),
              none)
           }
         }
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index d3eef85f062..c4bb680c220 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -530,18 +530,18 @@ fn print_item(s: ps, &&item: @ast::item) {
             bclose(s, item.span);
         }
       }
-      ast::item_class(tps, traits, items, m_ctor, m_dtor) => {
+      ast::item_class(struct_def, tps) => {
           head(s, ~"class");
           word_nbsp(s, *item.ident);
           print_type_params(s, tps);
-          if vec::len(traits) != 0u {
+          if vec::len(struct_def.traits) != 0u {
               word_space(s, ~":");
-              commasep(s, inconsistent, traits, |s, p|
+              commasep(s, inconsistent, struct_def.traits, |s, p|
                   print_path(s, p.path, false));
           }
           bopen(s);
           hardbreak_if_not_bol(s);
-          do option::iter(m_ctor) |ctor| {
+          do option::iter(struct_def.ctor) |ctor| {
             maybe_print_comment(s, ctor.span.lo);
             print_outer_attributes(s, ctor.node.attrs);
             // Doesn't call head because there shouldn't be a space after new.
@@ -553,14 +553,14 @@ fn print_item(s: ps, &&item: @ast::item) {
             space(s.s);
             print_block(s, ctor.node.body);
           }
-          do option::iter(m_dtor) |dtor| {
+          do option::iter(struct_def.dtor) |dtor| {
             hardbreak_if_not_bol(s);
             maybe_print_comment(s, dtor.span.lo);
             print_outer_attributes(s, dtor.node.attrs);
             head(s, ~"drop");
             print_block(s, dtor.node.body);
           }
-          for items.each |ci| {
+          for struct_def.members.each |ci| {
                   /*
                      FIXME (#1893): collect all private items and print
                      them in a single "priv" section
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 3bf820dd5cf..282f9abe6dc 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -152,17 +152,17 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
             visit_method_helper(m, e, v)
         }
       }
-      item_class(tps, traits, members, m_ctor, m_dtor) => {
+      item_class(struct_def, tps) => {
           v.visit_ty_params(tps, e, v);
-          for members.each |m| {
+          for struct_def.members.each |m| {
              v.visit_class_item(m, e, v);
           }
-          for traits.each |p| { visit_path(p.path, e, v); }
-          do option::iter(m_ctor) |ctor| {
+          for struct_def.traits.each |p| { visit_path(p.path, e, v); }
+          do option::iter(struct_def.ctor) |ctor| {
             visit_class_ctor_helper(ctor, i.ident, tps,
                                     ast_util::local_def(i.id), e, v);
           };
-          do option::iter(m_dtor) |dtor| {
+          do option::iter(struct_def.dtor) |dtor| {
             visit_class_dtor_helper(dtor, tps,
                                     ast_util::local_def(i.id), e, v)
           };