Merge branch 'master' into kmath

Author: boggle

src/comp/metadata/common.rs

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

src/comp/metadata/csearch.rs

@@ -10,9 +10,10 @@ export get_type_param_count;
 export lookup_defs;
 export get_tag_variants;
 export get_impls_for_mod;
-export get_impl_methods;
+export get_iface_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;
@@ -65,33 +66,23 @@ fn get_tag_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] {
 
 fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
                      name: option::t<ast::ident>)
-    -> [@middle::resolve::_impl] {
+    -> @[@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,
-                         iface_did: none::<ast::def_id>, // FIXME[impl]
-                         ident: nm,
-                         methods: decoder::lookup_impl_methods(
-                             cdata, did.node, did.crate)}];
-        }
-    }
-    result
+    let resolver = bind translate_def_id(cstore, def.crate, _);
+    decoder::get_impls_for_mod(cdata, def, name, resolver)
 }
 
-fn get_impl_methods(cstore: cstore::cstore, def: ast::def_id)
-    -> [@middle::resolve::method_info] {
+fn get_iface_methods(tcx: ty::ctxt, def: ast::def_id) -> @[ty::method] {
+    let cstore = tcx.sess.get_cstore();
     let cdata = cstore::get_crate_data(cstore, def.crate).data;
-    decoder::lookup_impl_methods(cdata, def.node, def.crate)
+    let resolver = bind translate_def_id(cstore, def.crate, _);
+    decoder::get_iface_methods(cdata, def, tcx, resolver)
 }
 
 fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_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(cstore, cnum, _);
+    let cdata = cstore::get_crate_data(cstore, def.crate).data;
+    let resolver = bind translate_def_id(cstore, def.crate, _);
     decoder::get_type(cdata, def, tcx, resolver)
 }
 
@@ -100,6 +91,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;
@@ -24,7 +26,7 @@ export get_crate_deps;
 export get_crate_hash;
 export external_resolver;
 export get_impls_for_mod;
-export lookup_impl_methods;
+export get_iface_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
@@ -103,16 +105,42 @@ fn parse_external_def_id(this_cnum: ast::crate_num,
     } else { ret extres(external_def_id); }
 }
 
+fn doc_type(doc: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
+            extres: external_resolver) -> ty::t {
+    let tp = ebml::get_doc(doc, tag_items_data_item_type);
+    let def_parser = bind parse_external_def_id(this_cnum, extres, _);
+    parse_ty_data(tp.data, this_cnum, tp.start, def_parser, tcx)
+}
+
 fn item_type(item: ebml::doc, this_cnum: ast::crate_num, tcx: ty::ctxt,
              extres: external_resolver) -> ty::t {
-    let tp = ebml::get_doc(item, tag_items_data_item_type);
-    let def_parser = bind parse_external_def_id(this_cnum, extres, _);
-    let t = parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start,
-                          def_parser, tcx);
+    let t = doc_type(item, this_cnum, tcx, extres);
     if family_names_type(item_family(item)) {
-        t = ty::mk_named(tcx, t, @item_name(item));
+        ty::mk_named(tcx, t, @item_name(item))
+    } else { 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, def_parser,
+                              tcx);
+        result = some(t);
+    }
+    result
+}
+
+fn item_impl_iface_did(item: ebml::doc, this_cnum: ast::crate_num,
+                       extres: external_resolver)
+    -> option::t<ast::def_id> {
+    let result = none;
+    ebml::tagged_docs(item, tag_impl_iface_did) {|doc|
+        let s = str::unsafe_from_bytes(ebml::doc_data(doc));
+        result = some(parse_external_def_id(this_cnum, extres, s));
     }
-    t
+    result
 }
 
 fn item_ty_param_bounds(item: ebml::doc, this_cnum: ast::crate_num,
@@ -121,8 +149,8 @@ fn item_ty_param_bounds(item: ebml::doc, this_cnum: ast::crate_num,
     let bounds = [];
     let def_parser = bind parse_external_def_id(this_cnum, extres, _);
     ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) {|p|
-        bounds += [tydecode::parse_bounds_data(@ebml::doc_data(p), this_cnum,
-                                               def_parser, tcx)];
+        bounds += [tydecode::parse_bounds_data(p.data, p.start,
+                                               this_cnum, def_parser, tcx)];
     }
     @bounds
 }
@@ -197,18 +225,17 @@ fn lookup_def(cnum: ast::crate_num, data: @[u8], did_: ast::def_id) ->
             tid = {crate: cnum, node: tid.node};
             ast::def_variant(tid, did)
           }
+          'I' { ast::def_ty(did) }
         };
     ret def;
 }
 
 fn get_type(data: @[u8], def: ast::def_id, tcx: ty::ctxt,
             extres: external_resolver) -> ty::ty_param_bounds_and_ty {
-    let this_cnum = def.crate;
-    let node_id = def.node;
-    let item = lookup_item(node_id, data);
-    let t = item_type(item, this_cnum, tcx, extres);
+    let item = lookup_item(def.node, data);
+    let t = item_type(item, def.crate, tcx, extres);
     let tp_bounds = if family_has_type_params(item_family(item)) {
-        item_ty_param_bounds(item, this_cnum, tcx, extres)
+        item_ty_param_bounds(item, def.crate, tcx, extres)
     } else { @[] };
     ret {bounds: tp_bounds, ty: t};
 }
@@ -217,6 +244,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));
 }
@@ -245,52 +277,59 @@ 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)
+fn item_impl_methods(data: @[u8], item: ebml::doc, base_tps: uint)
     -> [@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 rslt = [];
+    ebml::tagged_docs(item, tag_item_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},
+        rslt += [@{did: m_did,
                    n_tps: item_ty_param_count(mth_item) - base_tps,
                    ident: item_name(mth_item)}];
     }
     rslt
 }
 
+fn get_impls_for_mod(data: @[u8], m_def: ast::def_id,
+                     name: option::t<ast::ident>, extres: external_resolver)
+    -> @[@middle::resolve::_impl] {
+    let mod_item = lookup_item(m_def.node, data), result = [];
+    ebml::tagged_docs(mod_item, tag_mod_impl) {|doc|
+        let did = parse_external_def_id(
+            m_def.crate, extres, str::unsafe_from_bytes(ebml::doc_data(doc)));
+        let item = lookup_item(did.node, data), nm = item_name(item);
+        if alt name { some(n) { n == nm } none. { true } } {
+            let base_tps = item_ty_param_count(doc);
+            let i_did = item_impl_iface_did(item, m_def.crate, extres);
+            result += [@{did: did, iface_did: i_did, ident: nm,
+                         methods: item_impl_methods(data, doc, base_tps)}];
+        }
+    }
+    @result
+}
+
+fn get_iface_methods(data: @[u8], def: ast::def_id, tcx: ty::ctxt,
+                     extres: external_resolver) -> @[ty::method] {
+    let item = lookup_item(def.node, data), result = [];
+    ebml::tagged_docs(item, tag_item_method) {|mth|
+        let bounds = item_ty_param_bounds(mth, def.crate, tcx, extres);
+        let name = item_name(mth);
+        let ty = doc_type(mth, def.crate, tcx, extres);
+        let fty = alt ty::struct(tcx, ty) { ty::ty_fn(f) { f } };
+        result += [{ident: name, tps: bounds, fty: fty}];
+    }
+    @result
+}
 
 fn family_has_type_params(fam_ch: u8) -> bool {
-    ret alt fam_ch as char {
-          'c' { false }
-          'f' { true }
-          'u' { true }
-          'p' { true }
-          'F' { true }
-          'U' { true }
-          'P' { true }
-          'y' { true }
-          't' { true }
-          'T' { false }
-          'm' { false }
-          'n' { false }
-          'v' { true }
-          'i' { true }
-        };
+    alt fam_ch as char {
+      'c' | 'T' | 'm' | 'n' { false }
+      'f' | 'u' | 'p' | 'F' | 'U' | 'P' | 'y' | 't' | 'v' | 'i' | 'I' { true }
+    }
 }
 
 fn family_names_type(fam_ch: u8) -> bool {
-    alt fam_ch as char { 'y' | 't' { true } _ { false } }
+    alt fam_ch as char { 'y' | 't' | 'I' { true } _ { false } }
 }
 
 fn read_path(d: ebml::doc) -> {path: str, pos: uint} {
@@ -321,6 +360,8 @@ fn item_family_to_str(fam: u8) -> str {
       'm' { ret "mod"; }
       'n' { ret "native mod"; }
       'v' { ret "tag"; }
+      'i' { ret "impl"; }
+      'I' { ret "iface"; }
     }
 }