Class methods WIP

In particular, use the ast::method type to represent a class method,
and try to reuse as much iface code as possible. (This makes sense now
since I'll be allowing polymorphic class methods.)

Author: catamorphism

src/rustc/driver/session.rs

@@ -110,6 +110,14 @@ impl session for session {
     }
 }
 
+// Seems out of place, but it uses session, so I'm putting it here
+fn expect<T: copy>(sess: session, opt: option<T>, msg: fn() -> str) -> T {
+    alt opt {
+       some(t) { t }
+       none { sess.bug(msg()); }
+    }
+}
+
 fn building_library(req_crate_type: crate_type, crate: @ast::crate,
                     testing: bool) -> bool {
     alt req_crate_type {

src/rustc/metadata/csearch.rs

@@ -1,15 +1,19 @@
 // Searching for information from the cstore
 
+import std::{ebml};
 import syntax::ast;
 import syntax::ast_util;
 import middle::{ty, ast_map};
 import option::{some, none};
 import driver::session;
+import driver::session::expect;
 import middle::trans::common::maps;
+import common::*;
 import std::map::hashmap;
 
 export get_symbol;
-export get_class_items;
+export get_class_fields;
+export get_field_type;
 export get_type_param_count;
 export lookup_defs;
 export lookup_method_purity;
@@ -120,10 +124,10 @@ fn get_iface_methods(tcx: ty::ctxt, def: ast::def_id) -> @[ty::method] {
     decoder::get_iface_methods(cdata, def.node, tcx)
 }
 
-fn get_class_items(tcx: ty::ctxt, def: ast::def_id) -> [@ty::class_item_ty] {
+fn get_class_fields(tcx: ty::ctxt, def: ast::def_id) -> [ty::field_ty] {
     let cstore = tcx.sess.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_class_items(cdata, def.node, tcx)
+    decoder::get_class_fields(tcx, cdata, def.node)
 }
 
 fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
@@ -132,6 +136,27 @@ fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
     decoder::get_type(cdata, def.node, tcx)
 }
 
+/* FIXME: Refactor */
+fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
+                  def: ast::def_id) -> ty::ty_param_bounds_and_ty {
+    let cstore = tcx.sess.cstore;
+    let cdata = cstore::get_crate_data(cstore, class_id.crate);
+    let all_items = ebml::get_doc(ebml::doc(cdata.data), tag_items);
+    #debug("Looking up %?", class_id);
+    let class_doc = expect(tcx.sess,
+                           decoder::maybe_find_item(class_id.node, all_items),
+                           {|| #fmt("get_field_type: class ID %? not found",
+                     class_id)});
+    #debug("looking up %? : %?", def, class_doc);
+    let the_field = expect(tcx.sess,
+        decoder::maybe_find_item(def.node, class_doc),
+        {|| #fmt("get_field_type: in class %?, field ID %? not found",
+                 class_id, def)});
+    #debug("got field data %?", the_field);
+    let ty = decoder::item_type(def, the_field, tcx, cdata);
+    ret {bounds: @[], ty: ty};
+}
+
 fn get_impl_iface(tcx: ty::ctxt, def: ast::def_id)
     -> option<ty::t> {
     let cstore = tcx.sess.cstore;

src/rustc/metadata/decoder.rs

@@ -14,8 +14,9 @@ import tydecode::{parse_ty_data, parse_def_id, parse_bounds_data,
 import syntax::print::pprust;
 import cmd=cstore::crate_metadata;
 import middle::trans::common::maps;
+import util::ppaux::ty_to_str;
 
-export get_class_items;
+export get_class_fields;
 export get_symbol;
 export get_enum_variants;
 export get_type;
@@ -35,6 +36,8 @@ export get_impls_for_mod;
 export get_iface_methods;
 export get_crate_module_paths;
 export get_item_path;
+export maybe_find_item; // sketchy
+export item_type; // sketchy
 export maybe_get_item_ast;
 export item_is_intrinsic;
 
@@ -110,9 +113,9 @@ fn item_parent_item(d: ebml::doc) -> option<ast::def_id> {
     found
 }
 
-fn class_field_id(d: ebml::doc) -> ast::def_id {
+fn class_field_id(d: ebml::doc, cdata: cmd) -> ast::def_id {
     let tagdoc = ebml::get_doc(d, tag_def_id);
-    ret parse_def_id(ebml::doc_data(tagdoc));
+    ret translate_def_id(cdata, parse_def_id(ebml::doc_data(tagdoc)));
 }
 
 fn variant_disr_val(d: ebml::doc) -> option<int> {
@@ -406,37 +409,26 @@ fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
 }
 
 /* Take a node ID for a class, return a vector of the class's
- member types */
-fn get_class_items(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-    -> [@ty::class_item_ty] {
+   field names/IDs */
+fn get_class_fields(tcx: ty::ctxt,
+               cdata: cmd, id: ast::node_id) -> [ty::field_ty] {
     let data = cdata.data;
     let item = lookup_item(id, data), result = [];
-    #debug("get_class_items: %s", item_name(item));
-    #debug("item: %?", item);
-    // right tag?
-    ebml::tagged_docs(item, tag_items_class_member) {|an_item|
+    ebml::tagged_docs(item, tag_items_data_item) {|an_item|
         let fam = item_family(an_item);
-        let decl = alt check fam {
-                'g' {
-                    let name = item_name(an_item);
-                    #debug("why hello there! %s", name);
-                    let ty = doc_type(an_item, tcx, cdata);
-                    let did = class_field_id(an_item);
-                    {ident: name,
-                     id: did.node,
-                     contents: ty::var_ty(ty)}
-                }
-                _ {
-                    fail; // FIXME
-                }
-        };
-        result += [@decl];
+        alt fam {
+         'g' {
+             let name = item_name(an_item);
+             let _ty = doc_type(an_item, tcx, cdata);
+             let did = class_field_id(an_item, cdata);
+             result += [{ident: name, id: did}];
+         }
+        _ { /* this only handles fields */}
+       }
     }
     result
 }
 
-
-
 fn family_has_type_params(fam_ch: char) -> bool {
     alt check fam_ch {
       'c' | 'T' | 'm' | 'n' | 'g' | 'h' { false }

src/rustc/metadata/encoder.rs

@@ -82,8 +82,8 @@ fn encode_class_item_paths(ebml_w: ebml::writer,
           priv { cont; }
           pub {
               let (id, ident) = alt it.node.decl {
-                      instance_var(v, _, _, vid) { (vid, v) }
-                      class_method(it) { (it.id, it.ident) }
+                 instance_var(v, _, _, vid) { (vid, v) }
+                 class_method(it) { (it.id, it.ident) }
               };
               add_to_index(ebml_w, path, index, ident);
               encode_named_def_id(ebml_w, ident, local_def(id));
@@ -145,18 +145,18 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
             ebml_w.end_tag();
           }
           item_class(tps,items,ctor) {
-              add_to_index(ebml_w, path, index, it.ident);
-              ebml_w.start_tag(tag_paths_data_item);
-              encode_name(ebml_w, it.ident);
-              encode_def_id(ebml_w, local_def(it.id));
-              ebml_w.end_tag();
-              ebml_w.start_tag(tag_paths);
-              add_to_index(ebml_w, path, index, it.ident);
-              #debug("ctor id: %d", ctor.node.id);
-              encode_named_def_id(ebml_w, it.ident, local_def(ctor.node.id));
-              encode_class_item_paths(ebml_w, items, path + [it.ident],
+            add_to_index(ebml_w, path, index, it.ident);
+            ebml_w.start_tag(tag_paths_data_item);
+            encode_name(ebml_w, it.ident);
+            encode_def_id(ebml_w, local_def(it.id));
+            ebml_w.end_tag();
+            ebml_w.start_tag(tag_paths);
+            add_to_index(ebml_w, path, index, it.ident);
+            #debug("ctor id: %d", ctor.node.id);
+            encode_named_def_id(ebml_w, it.ident, local_def(ctor.node.id));
+            encode_class_item_paths(ebml_w, items, path + [it.ident],
                                       index);
-              ebml_w.end_tag();
+            ebml_w.end_tag();
           }
           item_enum(variants, tps) {
             add_to_index(ebml_w, path, index, it.ident);
@@ -252,7 +252,12 @@ fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
 
 fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) {
     ebml_w.start_tag(tag_items_data_item_symbol);
-    ebml_w.writer.write(str::bytes(ecx.ccx.item_symbols.get(id)));
+    let sym = alt ecx.ccx.item_symbols.find(id) {
+      some(x) { x }
+      none { ecx.ccx.tcx.sess.bug(#fmt("encode_symbol: \
+                    id not found %d", id)); }
+    };
+    ebml_w.writer.write(str::bytes(sym));
     ebml_w.end_tag();
 }
 
@@ -346,43 +351,53 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
     ebml_w.end_tag();
 }
 
+/* Returns an index of items in this class */
 fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
                          id: node_id, path: ast_map::path, name: ident,
-                         tps: [ty_param], items: [@class_item]) {
+                         tps: [ty_param], items: [@class_item])
+ -> [entry<int>] {
+    let index = @mutable [];
+
     let tcx = ecx.ccx.tcx;
     encode_def_id(ebml_w, local_def(id));
     encode_family(ebml_w, 'C');
     encode_type_param_bounds(ebml_w, ecx, tps);
     encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
     encode_name(ebml_w, name);
+    encode_path(ebml_w, path, ast_map::path_name(name));
 
     for ci in items {
-            /* We encode both private and public fields -- need to include
-             private fields to get the offsets right */
-            ebml_w.start_tag(tag_items_class_member);
-            alt ci.node.decl {
-               instance_var(nm, _, _, id) {
-                   #debug("encode_info_for_class: doing %s %d", nm, id);
-                   encode_family(ebml_w, 'g');
-                   encode_name(ebml_w, nm);
-                   encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
-                   /* TODO: mutability */
-                   encode_def_id(ebml_w, local_def(id));
-               }
-               class_method(it) {
-                   encode_family(ebml_w, 'h');
-                   encode_name(ebml_w, it.ident);
-                   alt it.node {
-                      item_fn(fdecl, tps, _) {
-                          encode_info_for_fn(ecx, ebml_w, it.id, it.ident,
-                                             path, none, tps, fdecl);
-                      }
-                      _ { fail; /* TODO */ }
-                   }
-               }
-            }
-            ebml_w.end_tag();
+     /* We encode both private and public fields -- need to include
+        private fields to get the offsets right */
+      alt ci.node.decl {
+        instance_var(nm, _, _, id) {
+          *index += [{val: id, pos: ebml_w.writer.tell()}];
+          ebml_w.start_tag(tag_items_data_item);
+          #debug("encode_info_for_class: doing %s %d", nm, id);
+          encode_family(ebml_w, 'g');
+          encode_name(ebml_w, nm);
+          encode_path(ebml_w, path, ast_map::path_name(nm));
+          encode_type(ecx, ebml_w, node_id_to_type(tcx, id));
+          /* TODO: mutability */
+          encode_def_id(ebml_w, local_def(id));
+        }
+        class_method(m) {
+          *index += [{val: m.id, pos: ebml_w.writer.tell()}];
+          ebml_w.start_tag(tag_items_data_item);
+          encode_family(ebml_w, 'h');
+          encode_name(ebml_w, m.ident);
+          let impl_path = path + [ast_map::path_name(m.ident)];
+          /*
+            Recall methods are (currently) monomorphic, and we don't
+            repeat the class's ty params in the method decl
+          */
+          encode_info_for_method(ecx, ebml_w, impl_path,
+                                 should_inline(m.attrs), id, m, []);
+        }
+      }
+      ebml_w.end_tag();
     }
+    *index
 }
 
 fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer,
@@ -408,6 +423,28 @@ fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer,
         ebml_w.end_tag();
 }
 
+fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::writer,
+                          impl_path: ast_map::path, should_inline: bool,
+                          parent_id: node_id,
+                          m: @method, all_tps: [ty_param]) {
+    #debug("encode_info_for_method: %d %s", m.id, m.ident);
+    ebml_w.start_tag(tag_items_data_item);
+    encode_def_id(ebml_w, local_def(m.id));
+    encode_family(ebml_w, purity_fn_family(m.decl.purity));
+    encode_type_param_bounds(ebml_w, ecx, all_tps);
+    encode_type(ecx, ebml_w, node_id_to_type(ecx.ccx.tcx, m.id));
+    encode_name(ebml_w, m.ident);
+    encode_path(ebml_w, impl_path, ast_map::path_name(m.ident));
+    if all_tps.len() > 0u || should_inline {
+        astencode::encode_inlined_item(
+           ecx, ebml_w, impl_path,
+           ii_method(local_def(parent_id), m));
+    } else {
+        encode_symbol(ecx, ebml_w, m.id);
+    }
+    ebml_w.end_tag();
+}
+
 fn purity_fn_family(p: purity) -> char {
     alt p {
       unsafe_fn { 'u' }
@@ -417,15 +454,17 @@ fn purity_fn_family(p: purity) -> char {
     }
 }
 
-fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
-                        index: @mutable [entry<int>], path: ast_map::path) {
 
-    fn should_inline(attrs: [attribute]) -> bool {
-        alt attr::find_inline_attr(attrs) {
-          attr::ia_none { false }
-          attr::ia_hint | attr::ia_always { true }
-        }
+fn should_inline(attrs: [attribute]) -> bool {
+    alt attr::find_inline_attr(attrs) {
+        attr::ia_none { false }
+        attr::ia_hint | attr::ia_always { true }
     }
+}
+
+
+fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
+                        index: @mutable [entry<int>], path: ast_map::path) {
 
     let tcx = ecx.ccx.tcx;
     let must_write = alt item.node { item_enum(_, _) { true } _ { false } };
@@ -494,11 +533,12 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
                                  path, index, tps);
       }
       item_class(tps,items,ctor) {
-          /* We're not forgetting about the ctor here! It gets
-             encoded elsewhere */
         ebml_w.start_tag(tag_items_data_item);
-        encode_info_for_class(ecx, ebml_w, item.id, path, item.ident,
-                               tps, items);
+        let idx = encode_info_for_class(ecx, ebml_w, item.id, path,
+                 item.ident, tps, items);
+        /* each class must have its own index */
+        let bkts = create_index(idx, hash_node_id);
+        encode_index(ebml_w, bkts, write_int);
         ebml_w.end_tag();
       }
       item_res(_, tps, _, _, ctor_id) {
@@ -553,21 +593,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         let impl_path = path + [ast_map::path_name(item.ident)];
         for m in methods {
             *index += [{val: m.id, pos: ebml_w.writer.tell()}];
-            ebml_w.start_tag(tag_items_data_item);
-            encode_def_id(ebml_w, local_def(m.id));
-            encode_family(ebml_w, purity_fn_family(m.decl.purity));
-            encode_type_param_bounds(ebml_w, ecx, tps + m.tps);
-            encode_type(ecx, ebml_w, node_id_to_type(tcx, m.id));
-            encode_name(ebml_w, m.ident);
-            encode_path(ebml_w, impl_path, ast_map::path_name(m.ident));
-            if tps.len() > 0u || m.tps.len() > 0u || should_inline(m.attrs) {
-                astencode::encode_inlined_item(
-                    ecx, ebml_w, impl_path,
-                    ii_method(local_def(item.id), m));
-            } else {
-                encode_symbol(ecx, ebml_w, m.id);
-            }
-            ebml_w.end_tag();
+            encode_info_for_method(ecx, ebml_w, impl_path,
+                   should_inline(m.attrs), item.id, m, tps + m.tps);
         }
       }
       item_iface(tps, ms) {