Finish resolving and calling of crate-external impls

Issue #1227

Author: marijnh

src/comp/driver/rustc.rs

@@ -497,7 +497,7 @@ fn build_session(sopts: @session::options) -> session::session {
         sopts.target_triple,
         sopts.addl_lib_search_paths);
     ret session::session(target_cfg, sopts, cstore,
-                         @{cm: codemap::new_codemap(), mutable next_id: 0},
+                         @{cm: codemap::new_codemap(), mutable next_id: 1},
                          none, 0u, filesearch, false);
 }
 

src/comp/metadata/csearch.rs

@@ -2,13 +2,15 @@
 
 import syntax::ast;
 import middle::ty;
-import option;
+import option::{some, none};
 import driver::session;
 
 export get_symbol;
 export get_type_param_count;
 export lookup_defs;
 export get_tag_variants;
+export get_impls_for_mod;
+export get_impl_methods;
 export get_type;
 
 fn get_symbol(cstore: cstore::cstore, def: ast::def_id) -> str {
@@ -56,15 +58,38 @@ fn get_tag_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] {
     let cstore = tcx.sess.get_cstore();
     let cnum = def.crate;
     let cdata = cstore::get_crate_data(cstore, cnum).data;
-    let resolver = bind translate_def_id(tcx.sess, cnum, _);
+    let resolver = bind translate_def_id(cstore, cnum, _);
     ret decoder::get_tag_variants(cdata, def, tcx, resolver)
 }
 
+fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
+                     name: option::t<ast::ident>)
+    -> [@middle::resolve::_impl] {
+    let cdata = cstore::get_crate_data(cstore, def.crate).data;
+    let result = [];
+    for did in decoder::get_impls_for_mod(cdata, def.node, def.crate) {
+        let nm = decoder::lookup_item_name(cdata, did.node);
+        if alt name { some(n) { n == nm } none. { true } } {
+            result += [@{did: did,
+                         ident: nm,
+                         methods: decoder::lookup_impl_methods(
+                             cdata, did.node, did.crate)}];
+        }
+    }
+    result
+}
+
+fn get_impl_methods(cstore: cstore::cstore, def: ast::def_id)
+    -> [@middle::resolve::method_info] {
+    let cdata = cstore::get_crate_data(cstore, def.crate).data;
+    decoder::lookup_impl_methods(cdata, def.node, def.crate)
+}
+
 fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_kinds_and_ty {
     let cstore = tcx.sess.get_cstore();
     let cnum = def.crate;
     let cdata = cstore::get_crate_data(cstore, cnum).data;
-    let resolver = bind translate_def_id(tcx.sess, cnum, _);
+    let resolver = bind translate_def_id(cstore, cnum, _);
     decoder::get_type(cdata, def, tcx, resolver)
 }
 
@@ -73,7 +98,7 @@ fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_kinds_and_ty {
 // external crates - if those types further refer to types in other crates
 // then we must translate the crate number from that encoded in the external
 // crate to the correct local crate number.
-fn translate_def_id(sess: session::session, searched_crate: ast::crate_num,
+fn translate_def_id(cstore: cstore::cstore, searched_crate: ast::crate_num,
                     def_id: ast::def_id) -> ast::def_id {
 
     let ext_cnum = def_id.crate;
@@ -82,13 +107,12 @@ fn translate_def_id(sess: session::session, searched_crate: ast::crate_num,
     assert (searched_crate != ast::local_crate);
     assert (ext_cnum != ast::local_crate);
 
-    let cstore = sess.get_cstore();
     let cmeta = cstore::get_crate_data(cstore, searched_crate);
 
     let local_cnum =
         alt cmeta.cnum_map.find(ext_cnum) {
           option::some(n) { n }
-          option::none. { sess.bug("didn't find a crate in the cnum_map") }
+          option::none. { fail "didn't find a crate in the cnum_map"; }
         };
 
     ret {crate: local_cnum, node: node_id};

src/comp/metadata/decoder.rs

@@ -16,14 +16,16 @@ export get_type;
 export get_type_param_count;
 export get_type_param_kinds;
 export lookup_def;
+export lookup_item_name;
 export resolve_path;
 export get_crate_attributes;
 export list_crate_metadata;
 export crate_dep;
 export get_crate_deps;
 export get_crate_hash;
 export external_resolver;
-
+export get_impls_for_mod;
+export lookup_impl_methods;
 // A function that takes a def_id relative to the crate being searched and
 // returns a def_id relative to the compilation environment, i.e. if we hit a
 // def_id for an item defined in another crate, somebody needs to figure out
@@ -130,6 +132,15 @@ fn item_ty_param_kinds(item: ebml::doc) -> [ast::kind] {
     ret ks;
 }
 
+fn item_ty_param_count(item: ebml::doc) -> uint {
+    let n = 0u;
+    let tp = tag_items_data_item_ty_param_kinds;
+    ebml::tagged_docs(item, tp) {|p|
+        n += ebml::vint_at(ebml::doc_data(p), 0u).val;
+    }
+    n
+}
+
 fn tag_variant_ids(item: ebml::doc, this_cnum: ast::crate_num) ->
    [ast::def_id] {
     let ids: [ast::def_id] = [];
@@ -159,6 +170,15 @@ fn resolve_path(path: [ast::ident], data: @[u8]) -> [ast::def_id] {
     ret result;
 }
 
+fn item_name(item: ebml::doc) -> ast::ident {
+    let name = ebml::get_doc(item, tag_paths_data_name);
+    str::unsafe_from_bytes(ebml::doc_data(name))
+}
+
+fn lookup_item_name(data: @[u8], id: ast::node_id) -> ast::ident {
+    item_name(lookup_item(id, data))
+}
+
 // FIXME doesn't yet handle renamed re-exported externals
 fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) ->
    ast::def {
@@ -205,7 +225,7 @@ fn get_type(data: @[u8], def: ast::def_id, tcx: ty::ctxt,
 }
 
 fn get_type_param_count(data: @[u8], id: ast::node_id) -> uint {
-    ret vec::len(get_type_param_kinds(data, id));
+    item_ty_param_count(lookup_item(id, data))
 }
 
 fn get_type_param_kinds(data: @[u8], id: ast::node_id) -> [ast::kind] {
@@ -243,6 +263,31 @@ fn get_tag_variants(_data: @[u8], def: ast::def_id, tcx: ty::ctxt,
     ret infos;
 }
 
+fn get_impls_for_mod(data: @[u8], node: ast::node_id, cnum: ast::crate_num)
+    -> [ast::def_id] {
+    let mod_item = lookup_item(node, data), result = [];
+    ebml::tagged_docs(mod_item, tag_mod_impl) {|doc|
+        let did = parse_def_id(ebml::doc_data(doc));
+        result += [{crate: cnum with did}];
+    }
+    result
+}
+
+fn lookup_impl_methods(data: @[u8], node: ast::node_id, cnum: ast::crate_num)
+    -> [@middle::resolve::method_info] {
+    let impl_item = lookup_item(node, data), rslt = [];
+    let base_tps = item_ty_param_count(impl_item);
+    ebml::tagged_docs(impl_item, tag_impl_method) {|doc|
+        let m_did = parse_def_id(ebml::doc_data(doc));
+        let mth_item = lookup_item(m_did.node, data);
+        rslt += [@{did: {crate: cnum, node: m_did.node},
+                   n_tps: item_ty_param_count(mth_item) - base_tps,
+                   ident: item_name(mth_item)}];
+    }
+    rslt
+}
+
+
 fn family_has_type_params(fam_ch: u8) -> bool {
     ret alt fam_ch as char {
           'c' { false }
@@ -258,6 +303,7 @@ fn family_has_type_params(fam_ch: u8) -> bool {
           'm' { false }
           'n' { false }
           'v' { true }
+          'i' { true }
         };
 }
 

src/comp/metadata/encoder.rs

@@ -249,6 +249,26 @@ fn encode_tag_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
     }
 }
 
+fn encode_info_for_mod(ebml_w: ebml::writer, md: _mod,
+                       id: node_id) {
+    ebml::start_tag(ebml_w, tag_items_data_item);
+    encode_def_id(ebml_w, local_def(id));
+    encode_family(ebml_w, 'm' as u8);
+    for i in md.items {
+        alt i.node {
+          item_impl(_, _, _) {
+            if ast_util::is_exported(i.ident, md) {
+                ebml::start_tag(ebml_w, tag_mod_impl);
+                ebml_w.writer.write(str::bytes(def_to_str(local_def(i.id))));
+                ebml::end_tag(ebml_w);
+            }
+          }
+          _ {}
+        }
+    }
+    ebml::end_tag(ebml_w);
+}
+
 fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
                         &index: [entry<int>]) {
     alt item.node {
@@ -280,20 +300,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         ebml::end_tag(ebml_w);
       }
       item_mod(m) {
-        ebml::start_tag(ebml_w, tag_items_data_item);
-        encode_def_id(ebml_w, local_def(item.id));
-        encode_family(ebml_w, 'm' as u8);
-        for i in m.items {
-            alt i.node {
-              item_impl(_, _, _) {
-                ebml::start_tag(ebml_w, tag_mod_impl);
-                ebml_w.writer.write(str::bytes(def_to_str(local_def(i.id))));
-                ebml::end_tag(ebml_w);
-              }
-              _ {}
-            }
-        }
-        ebml::end_tag(ebml_w);
+        encode_info_for_mod(ebml_w, m, item.id);
       }
       item_native_mod(_) {
         ebml::start_tag(ebml_w, tag_items_data_item);
@@ -363,9 +370,10 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
       item_impl(tps, _, methods) {
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
-        encode_family(ebml_w, 'I' as u8);
+        encode_family(ebml_w, 'i' as u8);
         encode_type_param_kinds(ebml_w, tps);
         encode_type(ecx, ebml_w, node_id_to_monotype(ecx.ccx.tcx, item.id));
+        encode_name(ebml_w, item.ident);
         for m in methods {
             ebml::start_tag(ebml_w, tag_impl_method);
             ebml_w.writer.write(str::bytes(def_to_str(local_def(m.node.id))));
@@ -377,10 +385,12 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             index += [{val: m.node.id, pos: ebml_w.writer.tell()}];
             ebml::start_tag(ebml_w, tag_items_data_item);
             encode_def_id(ebml_w, local_def(m.node.id));
-            encode_family(ebml_w, 'i' as u8);
+            encode_family(ebml_w, 'f' as u8);
+            encode_inlineness(ebml_w, 'n' as u8);
             encode_type_param_kinds(ebml_w, tps + m.node.tps);
             encode_type(ecx, ebml_w,
                         node_id_to_monotype(ecx.ccx.tcx, m.node.id));
+            encode_name(ebml_w, m.node.ident);
             encode_symbol(ecx, ebml_w, m.node.id);
             ebml::end_tag(ebml_w);
         }
@@ -415,10 +425,12 @@ fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
     ebml::end_tag(ebml_w);
 }
 
-fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer) ->
-   [entry<int>] {
+fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
+                         crate_mod: _mod) -> [entry<int>] {
     let index: [entry<int>] = [];
     ebml::start_tag(ebml_w, tag_items_data);
+    index += [{val: crate_node_id, pos: ebml_w.writer.tell()}];
+    encode_info_for_mod(ebml_w, crate_mod, crate_node_id);
     ecx.ccx.ast_map.items {|key, val|
         alt val {
           middle::ast_map::node_item(i) {
@@ -658,7 +670,7 @@ fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> str {
     // Encode and index the items.
 
     ebml::start_tag(ebml_w, tag_items);
-    let items_index = encode_info_for_items(ecx, ebml_w);
+    let items_index = encode_info_for_items(ecx, ebml_w, crate.node.module);
     let items_buckets = create_index(items_index, hash_node_id);
     encode_index(ebml_w, items_buckets, write_int);
     ebml::end_tag(ebml_w);

src/comp/middle/ast_map.rs

@@ -8,6 +8,7 @@ tag ast_node {
     node_item(@item);
     node_obj_ctor(@item);
     node_native_item(@native_item);
+    node_method(@method);
     node_expr(@expr);
     // Locals are numbered, because the alias analysis needs to know in which
     // order they are introduced.
@@ -63,6 +64,9 @@ fn map_item(cx: ctx, i: @item) {
     cx.map.insert(i.id, node_item(i));
     alt i.node {
       item_obj(_, _, ctor_id) { cx.map.insert(ctor_id, node_obj_ctor(i)); }
+      item_impl(_, _, ms) {
+        for m in ms { cx.map.insert(m.node.id, node_method(m)); }
+      }
       _ { }
     }
 }