Write the iface type of an impl in the crate data

Also, move checking of ifaces into the collect phase of typeck
to give further passes some guarantees.

Issue #1227

Author: marijnh

src/comp/metadata/common.rs

@@ -67,6 +67,7 @@ const tag_crate_hash: uint = 0x28u;
 const tag_mod_impl: uint = 0x30u;
 
 const tag_impl_method: uint = 0x31u;
+const tag_impl_iface: uint = 0x32u;
 
 // djb's cdb hashes.
 fn hash_node_id(&&node_id: int) -> uint { ret 177573u ^ (node_id as uint); }

src/comp/metadata/csearch.rs

@@ -13,6 +13,7 @@ export get_impls_for_mod;
 export get_impl_methods;
 export get_type;
 export get_item_name;
+export get_impl_iface;
 
 fn get_symbol(cstore: cstore::cstore, def: ast::def_id) -> str {
     let cdata = cstore::get_crate_data(cstore, def.crate).data;
@@ -100,6 +101,14 @@ fn get_item_name(cstore: cstore::cstore, cnum: int, id: int) -> ast::ident {
     ret decoder::lookup_item_name(cdata, id);
 }
 
+fn get_impl_iface(tcx: ty::ctxt, def: ast::def_id)
+    -> option::t<ty::t> {
+    let cstore = tcx.sess.get_cstore();
+    let cdata = cstore::get_crate_data(cstore, def.crate).data;
+    let resolver = bind translate_def_id(cstore, def.crate, _);
+    decoder::get_impl_iface(cdata, def, tcx, resolver)
+}
+
 // Translates a def_id from an external crate to a def_id for the current
 // compilation environment. We use this when trying to load types from
 // external crates - if those types further refer to types in other crates

src/comp/metadata/decoder.rs

@@ -14,8 +14,10 @@ export get_symbol;
 export get_tag_variants;
 export get_type;
 export get_type_param_count;
+export get_impl_iface;
 export lookup_def;
 export lookup_item_name;
+export get_impl_iface;
 export resolve_path;
 export get_crate_attributes;
 export list_crate_metadata;
@@ -115,6 +117,18 @@ fn item_type(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
     t
 }
 
+fn item_impl_iface(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
+                   extres: external_resolver) -> option::t<ty::t> {
+    let result = none;
+    ebml::tagged_docs(item, tag_impl_iface) {|ity|
+        let def_parser = bind parse_external_def_id(this_cnum, extres, _);
+        let t = parse_ty_data(ity.data, this_cnum, ity.start,
+                              ity.end - ity.start, def_parser, tcx);
+        result = some(t);
+    }
+    result
+}
+
 fn item_ty_param_bounds(item: ebml::doc, this_cnum: ast::crate_num,
                         tcx: ty::ctxt, extres: external_resolver)
     -> @[ty::param_bounds] {
@@ -217,6 +231,11 @@ fn get_type_param_count(data: @[u8], id: ast::node_id) -> uint {
     item_ty_param_count(lookup_item(id, data))
 }
 
+fn get_impl_iface(data: @[u8], def: ast::def_id, tcx: ty::ctxt,
+                  extres: external_resolver) -> option::t<ty::t> {
+    item_impl_iface(lookup_item(def.node, data), def.crate, tcx, extres)
+}
+
 fn get_symbol(data: @[u8], id: ast::node_id) -> str {
     ret item_symbol(lookup_item(id, data));
 }
@@ -269,7 +288,6 @@ fn lookup_impl_methods(data: @[u8], node: ast::node_id, cnum: ast::crate_num)
     rslt
 }
 
-
 fn family_has_type_params(fam_ch: u8) -> bool {
     ret alt fam_ch as char {
           'c' { false }

src/comp/metadata/encoder.rs

@@ -202,13 +202,17 @@ fn encode_variant_id(ebml_w: ebml::writer, vid: def_id) {
     ebml::end_tag(ebml_w);
 }
 
-fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
-    ebml::start_tag(ebml_w, tag_items_data_item_type);
+fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
     let ty_str_ctxt =
         @{ds: def_to_str,
           tcx: ecx.ccx.tcx,
           abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     tyencode::enc_ty(io::new_writer(ebml_w.writer), ty_str_ctxt, typ);
+}
+
+fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
+    ebml::start_tag(ebml_w, tag_items_data_item_type);
+    write_type(ecx, ebml_w, typ);
     ebml::end_tag(ebml_w);
 }
 
@@ -369,7 +373,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_symbol(ecx, ebml_w, ctor_id);
         ebml::end_tag(ebml_w);
       }
-      item_impl(tps, _, _, methods) {
+      item_impl(tps, ifce, _, 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);
@@ -381,6 +385,15 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             ebml_w.writer.write(str::bytes(def_to_str(local_def(m.id))));
             ebml::end_tag(ebml_w);
         }
+        alt ifce {
+          some(_) {
+            ebml::start_tag(ebml_w, tag_impl_iface);
+            write_type(ecx, ebml_w, ty::lookup_item_type(
+                ecx.ccx.tcx, local_def(item.id)).ty);
+            ebml::end_tag(ebml_w);
+          }
+          _ {}
+        }
         ebml::end_tag(ebml_w);
 
         for m in methods {

src/comp/middle/ty.rs

@@ -102,7 +102,7 @@ export substitute_type_params;
 export t;
 export new_ty_hash;
 export tag_variants;
-export iface_methods, store_iface_methods;
+export iface_methods, store_iface_methods, impl_iface;
 export tag_variant_with_id;
 export ty_param_substs_opt_and_ty;
 export ty_param_bounds_and_ty;
@@ -2670,6 +2670,14 @@ fn iface_methods(cx: ctxt, id: ast::def_id) -> @[method] {
     result
 }
 
+fn impl_iface(cx: ctxt, id: ast::def_id) -> option::t<t> {
+    if id.crate == ast::local_crate {
+        option::map(cx.tcache.find(id), {|it| it.ty})
+    } else {
+        csearch::get_impl_iface(cx, id)
+    }
+}
+
 // Tag information
 type variant_info = @{args: [ty::t], ctor_ty: ty::t, id: ast::def_id};