Remove un-needed code for obsolete classes

and rename "class" to "struct" everywhere possible (except local
vars, I was too lazy for that) -- that is why this commit is so
big.

No review, just dead code removal and renaming.

Closes #3515

Author: catamorphism

src/librustc/metadata/common.rs

@@ -84,7 +84,7 @@ const tag_path_len: uint = 0x41u;
 const tag_path_elt_mod: uint = 0x42u;
 const tag_path_elt_name: uint = 0x43u;
 const tag_item_field: uint = 0x44u;
-const tag_class_mut: uint = 0x45u;
+const tag_struct_mut: uint = 0x45u;
 
 const tag_region_param: uint = 0x46u;
 const tag_mod_impl_trait: uint = 0x47u;

src/librustc/metadata/csearch.rs

@@ -24,10 +24,9 @@ use common::*;
 use std::map::HashMap;
 use dvec::DVec;
 
-export class_dtor;
+export struct_dtor;
 export get_symbol;
-export get_class_fields;
-export get_class_method;
+export get_struct_fields;
 export get_field_type;
 export get_type_param_count;
 export get_region_param;
@@ -170,10 +169,10 @@ fn get_item_attrs(cstore: cstore::CStore,
     decoder::get_item_attrs(cdata, def_id.node, f)
 }
 
-fn get_class_fields(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::field_ty] {
+fn get_struct_fields(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::field_ty] {
     let cstore = tcx.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_class_fields(cstore.intr, cdata, def.node)
+    decoder::get_struct_fields(cstore.intr, cdata, def.node)
 }
 
 fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
@@ -226,22 +225,11 @@ fn get_impl_method(cstore: cstore::CStore,
     decoder::get_impl_method(cstore.intr, cdata, def.node, mname)
 }
 
-/* Because classes use the trait format rather than the impl format
-   for their methods (so that get_trait_methods can be reused to get
-   class methods), classes require a slightly different version of
-   get_impl_method. Sigh. */
-fn get_class_method(cstore: cstore::CStore,
-                    def: ast::def_id, mname: ast::ident)
-    -> ast::def_id {
-    let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_class_method(cstore.intr, cdata, def.node, mname)
-}
-
 /* If def names a class with a dtor, return it. Otherwise, return none. */
-fn class_dtor(cstore: cstore::CStore, def: ast::def_id)
+fn struct_dtor(cstore: cstore::CStore, def: ast::def_id)
     -> Option<ast::def_id> {
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::class_dtor(cdata, def.node)
+    decoder::struct_dtor(cdata, def.node)
 }
 // Local Variables:
 // mode: rust

src/librustc/metadata/decoder.rs

@@ -32,15 +32,14 @@ use syntax::parse::token::ident_interner;
 use hash::{Hash, HashUtil};
 use csearch::{ProvidedTraitMethodInfo, StaticMethodInfo};
 
-export class_dtor;
-export get_class_fields;
+export struct_dtor;
+export get_struct_fields;
 export get_symbol;
 export get_enum_variants;
 export get_type;
 export get_region_param;
 export get_type_param_count;
 export get_impl_traits;
-export get_class_method;
 export get_impl_method;
 export get_static_methods_if_impl;
 export lookup_def;
@@ -228,15 +227,15 @@ fn each_reexport(d: ebml::Doc, f: fn(ebml::Doc) -> bool) {
     }
 }
 
-fn field_mutability(d: ebml::Doc) -> ast::class_mutability {
+fn field_mutability(d: ebml::Doc) -> ast::struct_mutability {
     // Use maybe_get_doc in case it's a method
     option::map_default(
-        &reader::maybe_get_doc(d, tag_class_mut),
-        ast::class_immutable,
+        &reader::maybe_get_doc(d, tag_struct_mut),
+        ast::struct_immutable,
         |d| {
             match reader::doc_as_u8(*d) as char {
-              'm' => ast::class_mutable,
-              _   => ast::class_immutable
+              'm' => ast::struct_mutable,
+              _   => ast::struct_immutable
             }
         })
 }
@@ -338,7 +337,7 @@ fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::crate_num)
     let fam = item_family(item);
     match fam {
         Const     => dl_def(ast::def_const(did)),
-        Struct    => dl_def(ast::def_class(did)),
+        Struct    => dl_def(ast::def_struct(did)),
         UnsafeFn  => dl_def(ast::def_fn(did, ast::unsafe_fn)),
         Fn        => dl_def(ast::def_fn(did, ast::impure_fn)),
         PureFn    => dl_def(ast::def_fn(did, ast::pure_fn)),
@@ -419,34 +418,12 @@ fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     found.get()
 }
 
-fn get_class_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
-                    name: ast::ident) -> ast::def_id {
-    let items = reader::get_doc(reader::Doc(cdata.data), tag_items);
-    let mut found = None;
-    let cls_items = match maybe_find_item(id, items) {
-      Some(it) => it,
-      None => fail (fmt!("get_class_method: class id not found \
-                              when looking up method %s", *intr.get(name)))
-    };
-    for reader::tagged_docs(cls_items, tag_item_trait_method) |mid| {
-        let m_did = item_def_id(mid, cdata);
-        if item_name(intr, mid) == name {
-            found = Some(m_did);
-        }
-    }
-    match found {
-      Some(found) => found,
-      None => fail (fmt!("get_class_method: no method named %s",
-                         *intr.get(name)))
-    }
-}
-
-fn class_dtor(cdata: cmd, id: ast::node_id) -> Option<ast::def_id> {
+fn struct_dtor(cdata: cmd, id: ast::node_id) -> Option<ast::def_id> {
     let items = reader::get_doc(reader::Doc(cdata.data), tag_items);
     let mut found = None;
     let cls_items = match maybe_find_item(id, items) {
             Some(it) => it,
-            None     => fail (fmt!("class_dtor: class id not found \
+            None     => fail (fmt!("struct_dtor: class id not found \
               when looking up dtor for %d", id))
     };
     for reader::tagged_docs(cls_items, tag_item_dtor) |doc| {
@@ -905,15 +882,23 @@ fn get_item_attrs(cdata: cmd,
     }
 }
 
-// Helper function that gets either fields or methods
-fn get_class_members(intr: @ident_interner, cdata: cmd, id: ast::node_id,
-                     p: fn(Family) -> bool) -> ~[ty::field_ty] {
+pure fn family_to_visibility(family: Family) -> ast::visibility {
+    match family {
+      PublicField => ast::public,
+      PrivateField => ast::private,
+      InheritedField => ast::inherited,
+      _ => fail
+    }
+}
+
+fn get_struct_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id)
+    -> ~[ty::field_ty] {
     let data = cdata.data;
     let item = lookup_item(id, data);
     let mut result = ~[];
     for reader::tagged_docs(item, tag_item_field) |an_item| {
        let f = item_family(an_item);
-       if p(f) {
+       if f == PublicField || f == PrivateField || f == InheritedField {
           let name = item_name(intr, an_item);
           let did = item_def_id(an_item, cdata);
           let mt = field_mutability(an_item);
@@ -924,21 +909,6 @@ fn get_class_members(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     result
 }
 
-pure fn family_to_visibility(family: Family) -> ast::visibility {
-    match family {
-      PublicField => ast::public,
-      PrivateField => ast::private,
-      InheritedField => ast::inherited,
-      _ => fail
-    }
-}
-
-fn get_class_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id)
-    -> ~[ty::field_ty] {
-    get_class_members(intr, cdata, id, |f| f == PublicField
-                      || f == PrivateField || f == InheritedField)
-}
-
 fn family_has_type_params(fam: Family) -> bool {
     match fam {
       Const | ForeignType | Mod | ForeignMod | PublicField | PrivateField

src/librustc/metadata/encoder.rs

@@ -120,11 +120,11 @@ fn encode_region_param(ecx: @encode_ctxt, ebml_w: writer::Serializer,
     }
 }
 
-fn encode_mutability(ebml_w: writer::Serializer, mt: class_mutability) {
-    do ebml_w.wr_tag(tag_class_mut) {
+fn encode_mutability(ebml_w: writer::Serializer, mt: struct_mutability) {
+    do ebml_w.wr_tag(tag_struct_mut) {
         let val = match mt {
-          class_immutable => 'a',
-          class_mutable => 'm'
+          struct_immutable => 'a',
+          struct_mutable => 'm'
         };
         ebml_w.writer.write(&[val as u8]);
     }
@@ -318,7 +318,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: writer::Serializer,
     // Encode info about all the module children.
     for md.items.each |item| {
         match item.node {
-            item_impl(*) | item_class(*) => {
+            item_impl(*) | item_struct(*) => {
                 let (ident, did) = (item.ident, item.id);
                 debug!("(encoding info for module) ... encoding impl %s \
                         (%?/%?), exported? %?",
@@ -412,11 +412,9 @@ fn encode_method_sort(ebml_w: writer::Serializer, sort: char) {
 }
 
 /* Returns an index of items in this class */
-fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: writer::Serializer,
-                         id: node_id, path: ast_map::path,
-                         class_tps: ~[ty_param],
+fn encode_info_for_struct(ecx: @encode_ctxt, ebml_w: writer::Serializer,
+                         path: ast_map::path,
                          fields: ~[@struct_field],
-                         methods: ~[@method],
                          global_index: @mut~[entry<int>]) -> ~[entry<int>] {
     /* Each class has its own index, since different classes
        may have fields with the same name */
@@ -432,7 +430,7 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: writer::Serializer,
                 global_index.push({val: id,
                                     pos: ebml_w.writer.tell()});
                 ebml_w.start_tag(tag_items_data_item);
-                debug!("encode_info_for_class: doing %s %d",
+                debug!("encode_info_for_struct: doing %s %d",
                        tcx.sess.str_of(nm), id);
                 encode_visibility(ebml_w, vis);
                 encode_name(ecx, ebml_w, nm);
@@ -445,25 +443,6 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: writer::Serializer,
             unnamed_field => {}
         }
     }
-
-    for methods.each |m| {
-        match m.vis {
-            public | inherited => {
-                index.push({val: m.id, pos: ebml_w.writer.tell()});
-                global_index.push(
-                    {val: m.id, pos: ebml_w.writer.tell()});
-                let impl_path = vec::append_one(path,
-                                                ast_map::path_name(m.ident));
-                debug!("encode_info_for_class: doing %s %d",
-                       ecx.tcx.sess.str_of(m.ident), m.id);
-                encode_info_for_method(ecx, ebml_w, impl_path,
-                                       should_inline(m.attrs), id, *m,
-                                       vec::append(class_tps, m.tps));
-            }
-            _ => { /* don't encode private methods */ }
-        }
-    }
-
     *index
 }
 
@@ -556,7 +535,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Serializer,
     let must_write =
         match item.node {
           item_enum(_, _) | item_impl(*)
-          | item_trait(*) | item_class(*) => true,
+          | item_trait(*) | item_struct(*) => true,
           _ => false
         };
     if !must_write && !reachable(ecx, item.id) { return; }
@@ -645,14 +624,13 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Serializer,
                                  index,
                                  tps);
       }
-      item_class(struct_def, tps) => {
-        /* First, encode the fields and methods
+      item_struct(struct_def, tps) => {
+        /* First, encode the fields
            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,
-                                        struct_def.fields, struct_def.methods,
-                                        index);
+        let idx = encode_info_for_struct(ecx, ebml_w, path,
+                                        struct_def.fields, index);
         /* Encode the dtor */
         do struct_def.dtor.iter |dtor| {
             index.push({val: dtor.node.id, pos: ebml_w.writer.tell()});
@@ -677,9 +655,6 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Serializer,
         encode_name(ecx, ebml_w, item.ident);
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
         encode_region_param(ecx, ebml_w, item);
-        for struct_def.traits.each |t| {
-           encode_trait_ref(ebml_w, ecx, *t);
-        }
         /* Encode the dtor */
         /* Encode id for dtor */
         do struct_def.dtor.iter |dtor| {
@@ -704,28 +679,6 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Serializer,
             }
         }
 
-        for struct_def.methods.each |m| {
-           match m.vis {
-              private => { /* do nothing */ }
-              public | inherited => {
-                /* Write the info that's needed when viewing this class
-                   as a trait */
-                ebml_w.start_tag(tag_item_trait_method);
-                encode_family(ebml_w, purity_fn_family(m.purity));
-                encode_name(ecx, ebml_w, m.ident);
-                encode_type_param_bounds(ebml_w, ecx, m.tps);
-                encode_type(ecx, ebml_w, node_id_to_type(tcx, m.id));
-                encode_def_id(ebml_w, local_def(m.id));
-                encode_self_type(ebml_w, m.self_ty.node);
-                ebml_w.end_tag();
-                /* Write the info that's needed when viewing this class
-                   as an impl (just the method def_id and self type) */
-                ebml_w.start_tag(tag_item_impl_method);
-                ebml_w.writer.write(to_bytes(def_to_str(local_def(m.id))));
-                ebml_w.end_tag();
-              }
-           }
-        }
         /* Each class has its own index -- encode it */
         let bkts = create_index(idx);
         encode_index(ebml_w, bkts, write_int);

src/librustc/metadata/tydecode.rs

@@ -337,7 +337,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
           debug!("parsed a def_id %?", did);
           let substs = parse_substs(st, conv);
           assert (next(st) == ']');
-          return ty::mk_class(st.tcx, did, substs);
+          return ty::mk_struct(st.tcx, did, substs);
       }
       c => { error!("unexpected char in type string: %c", c); fail;}
     }

src/librustc/metadata/tyencode.rs

@@ -316,7 +316,7 @@ fn enc_sty(w: io::Writer, cx: @ctxt, st: ty::sty) {
           enc_proto(w, p);
       }
       ty::ty_opaque_box => w.write_char('B'),
-      ty::ty_class(def, ref substs) => {
+      ty::ty_struct(def, ref substs) => {
           debug!("~~~~ %s", ~"a[");
           w.write_str(&"a[");
           let s = (cx.ds)(def);

src/librustc/middle/astencode.rs

@@ -372,8 +372,8 @@ impl ast::def: tr {
                            xcx.tr_id(nid2),
                            xcx.tr_id(nid3))
           }
-          ast::def_class(did) => {
-            ast::def_class(did.tr(xcx))
+          ast::def_struct(did) => {
+            ast::def_struct(did.tr(xcx))
           }
           ast::def_region(nid) => ast::def_region(xcx.tr_id(nid)),
           ast::def_typaram_binder(nid) => {