---

yaml
---
r: 31712
b: refs/heads/dist-snap
c: deaef48
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 1a6dadad5bc7a0bb85f67ddaa9d38d9d4f741057
+refs/heads/dist-snap: deaef48675c34f3a63ded090058dfe6cbe60c3c6
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libsyntax/ast.rs

@@ -710,6 +710,17 @@ type trait_ref = {path: @path, ref_id: node_id, impl_id: node_id};
 #[auto_serialize]
 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_,
@@ -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 */

branches/dist-snap/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

branches/dist-snap/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),

branches/dist-snap/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)
           }
         }

branches/dist-snap/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

branches/dist-snap/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)
           };

branches/dist-snap/src/rustc/metadata/encoder.rs

@@ -196,7 +196,7 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
               encode_name_and_def_id(ebml_w, it.ident, it.id);
             }
           }
-          item_class(_, _, items, m_ctor, m_dtor) => {
+          item_class(struct_def, _) => {
             do ebml_w.wr_tag(tag_paths_data_item) {
                 encode_name_and_def_id(ebml_w, it.ident, it.id);
             }
@@ -205,7 +205,7 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
                 // class and for its ctor
                 add_to_index(ebml_w, path, index, it.ident);
 
-                match m_ctor {
+                match struct_def.ctor {
                     none => {
                         // Nothing to do.
                     }
@@ -215,7 +215,8 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
                     }
                 }
 
-                encode_class_item_paths(ebml_w, items,
+                encode_class_item_paths(ebml_w,
+                                        struct_def.members,
                                         vec::append_one(path, it.ident),
                                         index);
             }
@@ -700,15 +701,15 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_enum_variant_info(ecx, ebml_w, item.id, variants,
                                  path, index, tps);
       }
-      item_class(tps, traits, items, ctor, m_dtor) => {
+      item_class(struct_def, tps) => {
         /* First, encode the fields and methods
            These come first because we need to write them to make
            the index, and the index needs to be in the item for the
            class itself */
         let idx = encode_info_for_class(ecx, ebml_w, item.id, path, tps,
-                                          items, index);
+                                        struct_def.members, index);
         /* Encode the dtor */
-        do option::iter(m_dtor) |dtor| {
+        do option::iter(struct_def.dtor) |dtor| {
             vec::push(*index, {val: dtor.node.id, pos: ebml_w.writer.tell()});
           encode_info_for_fn(ecx, ebml_w, dtor.node.id, @(*item.ident
                              + ~"_dtor"), path, if tps.len() > 0u {
@@ -723,7 +724,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
 
-        match ctor {
+        match struct_def.ctor {
             none => encode_family(ebml_w, 'S'),
             some(_) => encode_family(ebml_w, 'C')
         }
@@ -733,12 +734,12 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_name(ebml_w, item.ident);
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
         encode_region_param(ecx, ebml_w, item);
-        for traits.each |t| {
+        for struct_def.traits.each |t| {
            encode_trait_ref(ebml_w, ecx, t);
         }
         /* Encode the dtor */
         /* Encode id for dtor */
-        do option::iter(m_dtor) |dtor| {
+        do option::iter(struct_def.dtor) |dtor| {
             do ebml_w.wr_tag(tag_item_dtor) {
                 encode_def_id(ebml_w, local_def(dtor.node.id));
             }
@@ -747,7 +748,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         /* Encode def_ids for each field and method
          for methods, write all the stuff get_trait_method
         needs to know*/
-        let (fs,ms) = ast_util::split_class_items(items);
+        let (fs,ms) = ast_util::split_class_items(struct_def.members);
         for fs.each |f| {
            ebml_w.start_tag(tag_item_field);
            encode_visibility(ebml_w, f.vis);
@@ -783,7 +784,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml_w.end_tag();
 
         /* Encode the constructor */
-        for ctor.each |ctor| {
+        for struct_def.ctor.each |ctor| {
             debug!{"encoding info for ctor %s %d", *item.ident,
                    ctor.node.id};
             vec::push(*index, {

branches/dist-snap/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);
             }
 

branches/dist-snap/src/rustc/middle/trans/base.rs

@@ -4899,25 +4899,25 @@ 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));
           };
         }
         // 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 */ }

branches/dist-snap/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)
           }
         }