1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 // Decoding metadata from a single crate's metadata
13 use metadata::cstore::crate_metadata;
14 use metadata::common::*;
15 use metadata::csearch::{ProvidedTraitMethodInfo, StaticMethodInfo};
16 use metadata::csearch;
18 use metadata::decoder;
19 use metadata::tydecode::{parse_ty_data, parse_def_id,
20 parse_type_param_def_data,
21 parse_bare_fn_ty_data, parse_trait_ref_data};
22 use middle::{ty, resolve};
24 use core::hash::HashUtil;
26 use core::io::WriterUtil;
31 use std::ebml::reader;
33 use std::serialize::Decodable;
36 use syntax::diagnostic::span_handler;
37 use syntax::parse::token::{StringRef, ident_interner, special_idents};
38 use syntax::print::pprust;
39 use syntax::{ast, ast_util};
42 type cmd = @crate_metadata;
44 // A function that takes a def_id relative to the crate being searched and
45 // returns a def_id relative to the compilation environment, i.e. if we hit a
46 // def_id for an item defined in another crate, somebody needs to figure out
47 // what crate that's in and give us a def_id that makes sense for the current
50 fn lookup_hash(d: ebml::Doc, eq_fn: &fn(x:&[u8]) -> bool, hash: uint) ->
52 let index = reader::get_doc(d, tag_index);
53 let table = reader::get_doc(index, tag_index_table);
54 let hash_pos = table.start + hash % 256u * 4u;
55 let pos = io::u64_from_be_bytes(*d.data, hash_pos, 4u) as uint;
56 let tagged_doc = reader::doc_at(d.data, pos);
58 let belt = tag_index_buckets_bucket_elt;
59 for reader::tagged_docs(tagged_doc.doc, belt) |elt| {
60 let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint;
61 if eq_fn(vec::slice(*elt.data, elt.start + 4u, elt.end)) {
62 return Some(reader::doc_at(d.data, pos).doc);
68 pub type GetCrateDataCb<'self> = &'self fn(ast::crate_num) -> cmd;
70 pub fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
71 fn eq_item(bytes: &[u8], item_id: int) -> bool {
72 return io::u64_from_be_bytes(
73 vec::slice(bytes, 0u, 4u), 0u, 4u) as int
77 |a| eq_item(a, item_id),
78 item_id.hash() as uint)
81 fn find_item(item_id: int, items: ebml::Doc) -> ebml::Doc {
82 return maybe_find_item(item_id, items).get();
85 // Looks up an item in the given metadata and returns an ebml doc pointing
87 fn lookup_item(item_id: int, data: @~[u8]) -> ebml::Doc {
88 let items = reader::get_doc(reader::Doc(data), tag_items);
89 match maybe_find_item(item_id, items) {
90 None => fail!(fmt!("lookup_item: id not found: %d", item_id)),
102 UnsafeStaticMethod, // U
103 PureStaticMethod, // P
119 fn item_family(item: ebml::Doc) -> Family {
120 let fam = reader::get_doc(item, tag_items_data_item_family);
121 match reader::doc_as_u8(fam) as char {
127 'U' => UnsafeStaticMethod,
128 'P' => PureStaticMethod,
141 'N' => InheritedField,
142 c => fail!(fmt!("unexpected family char: %c", c))
146 fn item_visibility(item: ebml::Doc) -> ast::visibility {
147 match reader::maybe_get_doc(item, tag_items_data_item_visibility) {
149 Some(visibility_doc) => {
150 match reader::doc_as_u8(visibility_doc) as char {
153 'i' => ast::inherited,
154 _ => fail!(~"unknown visibility character")
160 fn item_method_sort(item: ebml::Doc) -> char {
161 for reader::tagged_docs(item, tag_item_trait_method_sort) |doc| {
162 return str::from_bytes(reader::doc_data(doc))[0] as char;
167 fn item_symbol(item: ebml::Doc) -> ~str {
168 let sym = reader::get_doc(item, tag_items_data_item_symbol);
169 return str::from_bytes(reader::doc_data(sym));
172 fn item_parent_item(d: ebml::Doc) -> Option<ast::def_id> {
173 for reader::tagged_docs(d, tag_items_data_parent_item) |did| {
174 return Some(reader::with_doc_data(did, |d| parse_def_id(d)));
179 fn translated_parent_item_opt(cnum: ast::crate_num, d: ebml::Doc) ->
180 Option<ast::def_id> {
181 let trait_did_opt = item_parent_item(d);
182 do trait_did_opt.map |trait_did| {
183 ast::def_id { crate: cnum, node: trait_did.node }
187 fn item_reqd_and_translated_parent_item(cnum: ast::crate_num,
188 d: ebml::Doc) -> ast::def_id {
189 let trait_did = item_parent_item(d).expect(~"item without parent");
190 ast::def_id { crate: cnum, node: trait_did.node }
193 fn item_def_id(d: ebml::Doc, cdata: cmd) -> ast::def_id {
194 let tagdoc = reader::get_doc(d, tag_def_id);
195 return translate_def_id(cdata, reader::with_doc_data(tagdoc,
196 |d| parse_def_id(d)));
199 fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) {
200 for reader::tagged_docs(d, tag_items_data_item_reexport) |reexport_doc| {
201 if !f(reexport_doc) {
207 fn field_mutability(d: ebml::Doc) -> ast::struct_mutability {
208 // Use maybe_get_doc in case it's a method
209 reader::maybe_get_doc(d, tag_struct_mut).map_default(
210 ast::struct_immutable,
212 match reader::doc_as_u8(*d) as char {
213 'm' => ast::struct_mutable,
214 _ => ast::struct_immutable
219 fn variant_disr_val(d: ebml::Doc) -> Option<int> {
220 do reader::maybe_get_doc(d, tag_disr_val).chain |val_doc| {
221 int::parse_bytes(reader::doc_data(val_doc), 10u)
225 fn doc_type(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::t {
226 let tp = reader::get_doc(doc, tag_items_data_item_type);
227 parse_ty_data(tp.data, cdata.cnum, tp.start, tcx,
228 |_, did| translate_def_id(cdata, did))
231 fn doc_method_fty(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::BareFnTy {
232 let tp = reader::get_doc(doc, tag_item_method_fty);
233 parse_bare_fn_ty_data(tp.data, cdata.cnum, tp.start, tcx,
234 |_, did| translate_def_id(cdata, did))
237 fn doc_transformed_self_ty(doc: ebml::Doc,
239 cdata: cmd) -> Option<ty::t>
241 do reader::maybe_get_doc(doc, tag_item_method_transformed_self_ty).map |tp| {
242 parse_ty_data(tp.data, cdata.cnum, tp.start, tcx,
243 |_, did| translate_def_id(cdata, did))
247 pub fn item_type(_: ast::def_id, item: ebml::Doc, tcx: ty::ctxt, cdata: cmd)
249 doc_type(item, tcx, cdata)
252 fn doc_trait_ref(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::TraitRef {
253 parse_trait_ref_data(doc.data, cdata.cnum, doc.start, tcx,
254 |_, did| translate_def_id(cdata, did))
257 fn item_trait_ref(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::TraitRef {
258 let tp = reader::get_doc(doc, tag_item_trait_ref);
259 doc_trait_ref(tp, tcx, cdata)
262 fn item_ty_param_defs(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd,
264 -> @~[ty::TypeParameterDef] {
265 let mut bounds = ~[];
266 for reader::tagged_docs(item, tag) |p| {
267 let bd = parse_type_param_def_data(
268 p.data, p.start, cdata.cnum, tcx,
269 |_, did| translate_def_id(cdata, did));
275 fn item_ty_region_param(item: ebml::Doc) -> Option<ty::region_variance> {
276 reader::maybe_get_doc(item, tag_region_param).map(|doc| {
277 Decodable::decode(&reader::Decoder(*doc))
281 fn item_ty_param_count(item: ebml::Doc) -> uint {
283 reader::tagged_docs(item, tag_items_data_item_ty_param_bounds,
284 |_p| { n += 1u; true } );
288 fn enum_variant_ids(item: ebml::Doc, cdata: cmd) -> ~[ast::def_id] {
289 let mut ids: ~[ast::def_id] = ~[];
290 let v = tag_items_data_item_variant;
291 for reader::tagged_docs(item, v) |p| {
292 let ext = reader::with_doc_data(p, |d| parse_def_id(d));
293 ids.push(ast::def_id { crate: cdata.cnum, node: ext.node });
298 fn item_path(intr: @ident_interner, item_doc: ebml::Doc) -> ast_map::path {
299 let path_doc = reader::get_doc(item_doc, tag_path);
301 let len_doc = reader::get_doc(path_doc, tag_path_len);
302 let len = reader::doc_as_u32(len_doc) as uint;
304 let mut result = vec::with_capacity(len);
305 for reader::docs(path_doc) |tag, elt_doc| {
306 if tag == tag_path_elt_mod {
307 let str = reader::doc_as_str(elt_doc);
308 result.push(ast_map::path_mod(intr.intern(@str)));
309 } else if tag == tag_path_elt_name {
310 let str = reader::doc_as_str(elt_doc);
311 result.push(ast_map::path_name(intr.intern(@str)));
313 // ignore tag_path_len element
320 fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::ident {
321 let name = reader::get_doc(item, tag_paths_data_name);
322 do reader::with_doc_data(name) |data| {
323 let string = str::from_bytes_slice(data);
324 match intr.find_equiv(&StringRef(string)) {
325 None => intr.intern(@(string.to_owned())),
331 fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::crate_num)
334 let fam = item_family(item);
336 Const => dl_def(ast::def_const(did)),
337 Struct => dl_def(ast::def_struct(did)),
338 UnsafeFn => dl_def(ast::def_fn(did, ast::unsafe_fn)),
339 Fn => dl_def(ast::def_fn(did, ast::impure_fn)),
340 PureFn => dl_def(ast::def_fn(did, ast::pure_fn)),
341 ForeignFn => dl_def(ast::def_fn(did, ast::extern_fn)),
342 UnsafeStaticMethod => {
343 let trait_did_opt = translated_parent_item_opt(cnum, item);
344 dl_def(ast::def_static_method(did, trait_did_opt, ast::unsafe_fn))
347 let trait_did_opt = translated_parent_item_opt(cnum, item);
348 dl_def(ast::def_static_method(did, trait_did_opt, ast::impure_fn))
350 PureStaticMethod => {
351 let trait_did_opt = translated_parent_item_opt(cnum, item);
352 dl_def(ast::def_static_method(did, trait_did_opt, ast::pure_fn))
354 Type | ForeignType => dl_def(ast::def_ty(did)),
355 Mod => dl_def(ast::def_mod(did)),
356 ForeignMod => dl_def(ast::def_foreign_mod(did)),
358 let enum_did = item_reqd_and_translated_parent_item(cnum, item);
359 dl_def(ast::def_variant(enum_did, did))
361 Trait => dl_def(ast::def_trait(did)),
362 Enum => dl_def(ast::def_ty(did)),
363 Impl => dl_impl(did),
364 PublicField | PrivateField | InheritedField => dl_field,
368 pub fn lookup_def(cnum: ast::crate_num, data: @~[u8], did_: ast::def_id) ->
370 let item = lookup_item(did_.node, data);
371 let did = ast::def_id { crate: cnum, node: did_.node };
372 // We treat references to enums as references to types.
373 return def_like_to_def(item_to_def_like(item, did, cnum));
376 pub fn get_trait_def(cdata: cmd,
377 item_id: ast::node_id,
378 tcx: ty::ctxt) -> ty::TraitDef
380 let item_doc = lookup_item(item_id, cdata.data);
381 let tp_defs = item_ty_param_defs(item_doc, tcx, cdata,
382 tag_items_data_item_ty_param_bounds);
383 let rp = item_ty_region_param(item_doc);
385 generics: ty::Generics {type_param_defs: tp_defs,
387 trait_ref: @item_trait_ref(item_doc, tcx, cdata)
391 pub fn get_type(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
392 -> ty::ty_param_bounds_and_ty {
394 let item = lookup_item(id, cdata.data);
395 let t = item_type(ast::def_id { crate: cdata.cnum, node: id }, item, tcx,
397 let tp_defs = if family_has_type_params(item_family(item)) {
398 item_ty_param_defs(item, tcx, cdata, tag_items_data_item_ty_param_bounds)
400 let rp = item_ty_region_param(item);
401 ty::ty_param_bounds_and_ty {
402 generics: ty::Generics {type_param_defs: tp_defs,
408 pub fn get_region_param(cdata: cmd, id: ast::node_id)
409 -> Option<ty::region_variance> {
411 let item = lookup_item(id, cdata.data);
412 return item_ty_region_param(item);
415 pub fn get_type_param_count(data: @~[u8], id: ast::node_id) -> uint {
416 item_ty_param_count(lookup_item(id, data))
419 pub fn get_impl_traits(cdata: cmd,
421 tcx: ty::ctxt) -> ~[@ty::TraitRef]
423 let item_doc = lookup_item(id, cdata.data);
424 let mut results = ~[];
425 for reader::tagged_docs(item_doc, tag_item_trait_ref) |tp| {
427 @parse_trait_ref_data(tp.data, cdata.cnum, tp.start, tcx,
428 |_, did| translate_def_id(cdata, did));
429 results.push(trait_ref);
434 pub fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
435 name: ast::ident) -> ast::def_id {
436 let items = reader::get_doc(reader::Doc(cdata.data), tag_items);
437 let mut found = None;
438 for reader::tagged_docs(find_item(id, items), tag_item_impl_method)
440 let m_did = reader::with_doc_data(mid, |d| parse_def_id(d));
441 if item_name(intr, find_item(m_did.node, items)) == name {
442 found = Some(translate_def_id(cdata, m_did));
448 pub fn get_symbol(data: @~[u8], id: ast::node_id) -> ~str {
449 return item_symbol(lookup_item(id, data));
452 // Something that a name can resolve to.
455 dl_impl(ast::def_id),
459 fn def_like_to_def(def_like: def_like) -> ast::def {
461 dl_def(def) => return def,
462 dl_impl(*) => fail!(~"found impl in def_like_to_def"),
463 dl_field => fail!(~"found field in def_like_to_def")
467 /// Iterates over the language items in the given crate.
468 pub fn each_lang_item(cdata: cmd, f: &fn(ast::node_id, uint) -> bool) {
469 let root = reader::Doc(cdata.data);
470 let lang_items = reader::get_doc(root, tag_lang_items);
471 for reader::tagged_docs(lang_items, tag_lang_items_item) |item_doc| {
472 let id_doc = reader::get_doc(item_doc, tag_lang_items_item_id);
473 let id = reader::doc_as_u32(id_doc) as uint;
474 let node_id_doc = reader::get_doc(item_doc,
475 tag_lang_items_item_node_id);
476 let node_id = reader::doc_as_u32(node_id_doc) as ast::node_id;
484 /// Iterates over all the paths in the given crate.
485 pub fn each_path(intr: @ident_interner, cdata: cmd,
486 get_crate_data: GetCrateDataCb,
487 f: &fn(&str, def_like) -> bool) {
488 let root = reader::Doc(cdata.data);
489 let items = reader::get_doc(root, tag_items);
490 let items_data = reader::get_doc(items, tag_items_data);
492 let mut broken = false;
494 // First, go through all the explicit items.
495 for reader::tagged_docs(items_data, tag_items_data_item) |item_doc| {
497 let path = ast_map::path_to_str_with_sep(
498 item_path(intr, item_doc), ~"::", intr);
499 let path_is_empty = path.is_empty();
501 // Extract the def ID.
502 let def_id = item_def_id(item_doc, cdata);
504 // Construct the def for this item.
505 debug!("(each_path) yielding explicit item: %s", path);
506 let def_like = item_to_def_like(item_doc, def_id, cdata.cnum);
508 // Hand the information off to the iteratee.
509 if !f(path, def_like) {
510 broken = true; // FIXME #4572: This is awful.
514 // If this is a module, find the reexports.
515 for each_reexport(item_doc) |reexport_doc| {
518 reader::get_doc(reexport_doc,
519 tag_items_data_item_reexport_def_id);
521 reader::with_doc_data(def_id_doc,
522 |d| parse_def_id(d));
523 let def_id = translate_def_id(cdata, def_id);
525 let reexport_name_doc =
526 reader::get_doc(reexport_doc,
527 tag_items_data_item_reexport_name);
528 let reexport_name = reader::doc_as_str(reexport_name_doc);
532 reexport_path = reexport_name;
534 reexport_path = path + ~"::" + reexport_name;
537 // This reexport may be in yet another crate
538 let other_crates_items = if def_id.crate == cdata.cnum {
541 let crate_data = get_crate_data(def_id.crate);
542 let root = reader::Doc(crate_data.data);
543 reader::get_doc(root, tag_items)
547 match maybe_find_item(def_id.node, other_crates_items) {
550 // Construct the def for this item.
551 let def_like = item_to_def_like(item_doc,
555 // Hand the information off to the iteratee.
556 debug!("(each_path) yielding reexported \
557 item: %s", reexport_path);
559 if (!f(reexport_path, def_like)) {
560 broken = true; // FIXME #4572: This is awful.
569 // If broken, stop here.
575 pub fn get_item_path(intr: @ident_interner, cdata: cmd, id: ast::node_id)
577 item_path(intr, lookup_item(id, cdata.data))
580 pub type decode_inlined_item<'self> = &'self fn(
581 cdata: @cstore::crate_metadata,
584 par_doc: ebml::Doc) -> Option<ast::inlined_item>;
586 pub fn maybe_get_item_ast(intr: @ident_interner, cdata: cmd, tcx: ty::ctxt,
588 decode_inlined_item: decode_inlined_item)
589 -> csearch::found_ast {
590 debug!("Looking up item: %d", id);
591 let item_doc = lookup_item(id, cdata.data);
593 let item_path = item_path(intr, item_doc);
594 vec::from_slice(item_path.init())
596 match decode_inlined_item(cdata, tcx, copy path, item_doc) {
597 Some(ref ii) => csearch::found((/*bad*/copy *ii)),
599 match item_parent_item(item_doc) {
601 let did = translate_def_id(cdata, did);
602 let parent_item = lookup_item(did.node, cdata.data);
603 match decode_inlined_item(cdata, tcx, path, parent_item) {
604 Some(ref ii) => csearch::found_parent(did, (/*bad*/copy *ii)),
605 None => csearch::not_found
608 None => csearch::not_found
614 pub fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
615 tcx: ty::ctxt) -> ~[ty::VariantInfo] {
616 let data = cdata.data;
617 let items = reader::get_doc(reader::Doc(data), tag_items);
618 let item = find_item(id, items);
619 let mut infos: ~[ty::VariantInfo] = ~[];
620 let variant_ids = enum_variant_ids(item, cdata);
621 let mut disr_val = 0;
622 for variant_ids.each |did| {
623 let item = find_item(did.node, items);
624 let ctor_ty = item_type(ast::def_id { crate: cdata.cnum, node: id},
626 let name = item_name(intr, item);
627 let arg_tys = match ty::get(ctor_ty).sty {
628 ty::ty_bare_fn(ref f) => f.sig.inputs.map(|a| a.ty),
629 _ => ~[], // Nullary enum variant.
631 match variant_disr_val(item) {
632 Some(val) => { disr_val = val; }
635 infos.push(@ty::VariantInfo_{args: arg_tys,
636 ctor_ty: ctor_ty, name: name,
637 // I'm not even sure if we encode visibility
638 // for variants -- TEST -- tjc
639 id: *did, disr_val: disr_val, vis: ast::inherited});
645 fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
646 fn get_mutability(ch: u8) -> ast::mutability {
648 'i' => { ast::m_imm }
649 'm' => { ast::m_mutbl }
650 'c' => { ast::m_const }
652 fail!(fmt!("unknown mutability character: `%c`", ch as char))
657 let self_type_doc = reader::get_doc(item, tag_item_trait_method_self_ty);
658 let string = reader::doc_as_str(self_type_doc);
660 let self_ty_kind = string[0];
661 match self_ty_kind as char {
662 's' => { return ast::sty_static; }
663 'v' => { return ast::sty_value; }
664 '@' => { return ast::sty_box(get_mutability(string[1])); }
665 '~' => { return ast::sty_uniq(get_mutability(string[1])); }
667 // FIXME(#4846) expl. region
668 return ast::sty_region(None, get_mutability(string[1]));
671 fail!(fmt!("unknown self type code: `%c`", self_ty_kind as char));
676 fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
677 base_tps: uint) -> ~[@resolve::MethodInfo] {
679 for reader::tagged_docs(item, tag_item_impl_method) |doc| {
680 let m_did = reader::with_doc_data(doc, |d| parse_def_id(d));
681 let mth_item = lookup_item(m_did.node, cdata.data);
682 let self_ty = get_self_ty(mth_item);
683 rslt.push(@resolve::MethodInfo {
684 did: translate_def_id(cdata, m_did),
685 n_tps: item_ty_param_count(mth_item) - base_tps,
686 ident: item_name(intr, mth_item),
687 self_type: self_ty});
692 pub fn get_impls_for_mod(intr: @ident_interner,
695 name: Option<ast::ident>,
696 get_cdata: &fn(ast::crate_num) -> cmd)
697 -> @~[@resolve::Impl] {
698 let data = cdata.data;
699 let mod_item = lookup_item(m_id, data);
700 let mut result = ~[];
701 for reader::tagged_docs(mod_item, tag_mod_impl) |doc| {
702 let did = reader::with_doc_data(doc, |d| parse_def_id(d));
703 let local_did = translate_def_id(cdata, did);
704 debug!("(get impls for mod) getting did %? for '%?'",
706 // The impl may be defined in a different crate. Ask the caller
707 // to give us the metadata
708 let impl_cdata = get_cdata(local_did.crate);
709 let impl_data = impl_cdata.data;
710 let item = lookup_item(local_did.node, impl_data);
711 let nm = item_name(intr, item);
712 if match name { Some(n) => { n == nm } None => { true } } {
713 let base_tps = item_ty_param_count(item);
714 result.push(@resolve::Impl {
715 did: local_did, ident: nm,
716 methods: item_impl_methods(intr, impl_cdata, item, base_tps)
723 pub fn get_method_name_and_self_ty(
724 intr: @ident_interner,
726 id: ast::node_id) -> (ast::ident, ast::self_ty_)
728 let method_doc = lookup_item(id, cdata.data);
729 let name = item_name(intr, method_doc);
730 let self_ty = get_self_ty(method_doc);
734 pub fn get_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
735 tcx: ty::ctxt) -> ty::method
737 let method_doc = lookup_item(id, cdata.data);
738 let def_id = item_def_id(method_doc, cdata);
739 let name = item_name(intr, method_doc);
740 let type_param_defs = item_ty_param_defs(method_doc, tcx, cdata,
741 tag_item_method_tps);
742 let transformed_self_ty = doc_transformed_self_ty(method_doc, tcx, cdata);
743 let fty = doc_method_fty(method_doc, tcx, cdata);
744 let vis = item_visibility(method_doc);
745 let self_ty = get_self_ty(method_doc);
748 generics: ty::Generics {
749 type_param_defs: type_param_defs,
752 transformed_self_ty: transformed_self_ty,
760 pub fn get_trait_method_def_ids(cdata: cmd,
761 id: ast::node_id) -> ~[ast::def_id] {
762 let data = cdata.data;
763 let item = lookup_item(id, data);
764 let mut result = ~[];
765 for reader::tagged_docs(item, tag_item_trait_method) |mth| {
766 result.push(item_def_id(mth, cdata));
771 pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
772 id: ast::node_id, tcx: ty::ctxt) ->
773 ~[ProvidedTraitMethodInfo] {
774 let data = cdata.data;
775 let item = lookup_item(id, data);
776 let mut result = ~[];
778 for reader::tagged_docs(item, tag_item_trait_method) |mth| {
779 if item_method_sort(mth) != 'p' { loop; }
781 let did = item_def_id(mth, cdata);
783 let type_param_defs =
784 item_ty_param_defs(mth, tcx, cdata,
785 tag_items_data_item_ty_param_bounds);
786 let name = item_name(intr, mth);
787 let ty = doc_type(mth, tcx, cdata);
789 let fty = match ty::get(ty).sty {
790 ty::ty_bare_fn(ref f) => copy *f,
792 tcx.diag.handler().bug(~"get_provided_trait_methods(): id \
793 has non-function type");
797 let transformed_self_ty = doc_transformed_self_ty(mth, tcx, cdata);
798 let self_ty = get_self_ty(mth);
799 let ty_method = ty::method {
801 generics: ty::Generics {
802 type_param_defs: type_param_defs,
805 transformed_self_ty: transformed_self_ty,
811 let provided_trait_method_info = ProvidedTraitMethodInfo {
816 vec::push(&mut result, provided_trait_method_info);
822 /// Returns the supertraits of the given trait.
823 pub fn get_supertraits(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
824 -> ~[@ty::TraitRef] {
825 let mut results = ~[];
826 let item_doc = lookup_item(id, cdata.data);
827 for reader::tagged_docs(item_doc, tag_item_super_trait_ref) |trait_doc| {
828 results.push(@doc_trait_ref(trait_doc, tcx, cdata));
833 pub fn get_type_name_if_impl(intr: @ident_interner,
835 node_id: ast::node_id) -> Option<ast::ident> {
836 let item = lookup_item(node_id, cdata.data);
837 if item_family(item) != Impl {
841 for reader::tagged_docs(item, tag_item_impl_type_basename) |doc| {
842 return Some(intr.intern(@str::from_bytes(reader::doc_data(doc))));
848 pub fn get_static_methods_if_impl(intr: @ident_interner,
850 node_id: ast::node_id)
851 -> Option<~[StaticMethodInfo]> {
852 let item = lookup_item(node_id, cdata.data);
853 if item_family(item) != Impl {
857 // If this impl implements a trait, don't consider it.
858 for reader::tagged_docs(item, tag_item_trait_ref) |_doc| {
862 let mut impl_method_ids = ~[];
863 for reader::tagged_docs(item, tag_item_impl_method) |impl_method_doc| {
864 impl_method_ids.push(parse_def_id(reader::doc_data(impl_method_doc)));
867 let mut static_impl_methods = ~[];
868 for impl_method_ids.each |impl_method_id| {
869 let impl_method_doc = lookup_item(impl_method_id.node, cdata.data);
870 let family = item_family(impl_method_doc);
872 StaticMethod | UnsafeStaticMethod | PureStaticMethod => {
874 match item_family(impl_method_doc) {
875 StaticMethod => purity = ast::impure_fn,
876 UnsafeStaticMethod => purity = ast::unsafe_fn,
877 PureStaticMethod => purity = ast::pure_fn,
881 static_impl_methods.push(StaticMethodInfo {
882 ident: item_name(intr, impl_method_doc),
883 def_id: item_def_id(impl_method_doc, cdata),
891 return Some(static_impl_methods);
894 pub fn get_item_attrs(cdata: cmd,
895 node_id: ast::node_id,
896 f: &fn(~[@ast::meta_item])) {
898 let item = lookup_item(node_id, cdata.data);
899 for reader::tagged_docs(item, tag_attributes) |attributes| {
900 for reader::tagged_docs(attributes, tag_attribute) |attribute| {
901 f(get_meta_items(attribute));
906 fn struct_field_family_to_visibility(family: Family) -> ast::visibility {
908 PublicField => ast::public,
909 PrivateField => ast::private,
910 InheritedField => ast::inherited,
915 pub fn get_struct_fields(intr: @ident_interner, cdata: cmd, id: ast::node_id)
917 let data = cdata.data;
918 let item = lookup_item(id, data);
919 let mut result = ~[];
920 for reader::tagged_docs(item, tag_item_field) |an_item| {
921 let f = item_family(an_item);
922 if f == PublicField || f == PrivateField || f == InheritedField {
923 let name = item_name(intr, an_item);
924 let did = item_def_id(an_item, cdata);
925 let mt = field_mutability(an_item);
926 result.push(ty::field_ty {
929 struct_field_family_to_visibility(f),
934 for reader::tagged_docs(item, tag_item_unnamed_field) |an_item| {
935 let did = item_def_id(an_item, cdata);
936 result.push(ty::field_ty {
937 ident: special_idents::unnamed_field,
940 mutability: ast::struct_immutable,
946 pub fn get_item_visibility(cdata: cmd, id: ast::node_id)
948 item_visibility(lookup_item(id, cdata.data))
951 fn family_has_type_params(fam: Family) -> bool {
953 Const | ForeignType | Mod | ForeignMod | PublicField | PrivateField
954 | ForeignFn => false,
959 fn family_names_type(fam: Family) -> bool {
960 match fam { Type | Mod | Trait => true, _ => false }
963 fn read_path(d: ebml::Doc) -> (~str, uint) {
964 let desc = reader::doc_data(d);
965 let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint;
966 let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc));
967 let path = str::from_bytes(pathbytes);
972 fn describe_def(items: ebml::Doc, id: ast::def_id) -> ~str {
973 if id.crate != ast::local_crate { return ~"external"; }
974 let it = match maybe_find_item(id.node, items) {
976 None => fail!(fmt!("describe_def: item not found %?", id))
978 return item_family_to_str(item_family(it));
981 fn item_family_to_str(fam: Family) -> ~str {
985 UnsafeFn => ~"unsafe fn",
986 PureFn => ~"pure fn",
987 StaticMethod => ~"static method",
988 UnsafeStaticMethod => ~"unsafe static method",
989 PureStaticMethod => ~"pure static method",
990 ForeignFn => ~"foreign fn",
992 ForeignType => ~"foreign type",
994 ForeignMod => ~"foreign mod",
996 Variant => ~"variant",
1000 PublicField => ~"public field",
1001 PrivateField => ~"private field",
1002 InheritedField => ~"inherited field",
1006 fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
1007 let mut items: ~[@ast::meta_item] = ~[];
1008 for reader::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
1009 let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
1010 let n = str::from_bytes(reader::doc_data(nd));
1011 items.push(attr::mk_word_item(@n));
1013 for reader::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| {
1014 let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
1015 let vd = reader::get_doc(meta_item_doc, tag_meta_item_value);
1016 let n = str::from_bytes(reader::doc_data(nd));
1017 let v = str::from_bytes(reader::doc_data(vd));
1018 // FIXME (#623): Should be able to decode meta_name_value variants,
1019 // but currently the encoder just drops them
1020 items.push(attr::mk_name_value_item_str(@n, @v));
1022 for reader::tagged_docs(md, tag_meta_item_list) |meta_item_doc| {
1023 let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
1024 let n = str::from_bytes(reader::doc_data(nd));
1025 let subitems = get_meta_items(meta_item_doc);
1026 items.push(attr::mk_list_item(@n, subitems));
1031 fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
1032 let mut attrs: ~[ast::attribute] = ~[];
1033 match reader::maybe_get_doc(md, tag_attributes) {
1034 option::Some(attrs_d) => {
1035 for reader::tagged_docs(attrs_d, tag_attribute) |attr_doc| {
1036 let meta_items = get_meta_items(attr_doc);
1037 // Currently it's only possible to have a single meta item on
1039 assert!((vec::len(meta_items) == 1u));
1040 let meta_item = meta_items[0];
1043 node: ast::attribute_ {
1044 style: ast::attr_outer,
1046 is_sugared_doc: false,
1048 span: codemap::dummy_sp()
1057 fn list_meta_items(intr: @ident_interner,
1058 meta_items: ebml::Doc,
1060 for get_meta_items(meta_items).each |mi| {
1061 out.write_str(fmt!("%s\n", pprust::meta_item_to_str(*mi, intr)));
1065 fn list_crate_attributes(intr: @ident_interner, md: ebml::Doc, hash: &str,
1067 out.write_str(fmt!("=Crate Attributes (%s)=\n", hash));
1069 for get_attributes(md).each |attr| {
1070 out.write_str(fmt!("%s\n", pprust::attribute_to_str(*attr, intr)));
1073 out.write_str(~"\n\n");
1076 pub fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] {
1077 return get_attributes(reader::Doc(data));
1080 pub struct crate_dep {
1081 cnum: ast::crate_num,
1087 pub fn get_crate_deps(intr: @ident_interner, data: @~[u8]) -> ~[crate_dep] {
1088 let mut deps: ~[crate_dep] = ~[];
1089 let cratedoc = reader::Doc(data);
1090 let depsdoc = reader::get_doc(cratedoc, tag_crate_deps);
1091 let mut crate_num = 1;
1092 fn docstr(doc: ebml::Doc, tag_: uint) -> ~str {
1093 str::from_bytes(reader::doc_data(reader::get_doc(doc, tag_)))
1095 for reader::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {
1096 deps.push(crate_dep {cnum: crate_num,
1097 name: intr.intern(@docstr(depdoc, tag_crate_dep_name)),
1098 vers: @docstr(depdoc, tag_crate_dep_vers),
1099 hash: @docstr(depdoc, tag_crate_dep_hash)});
1105 fn list_crate_deps(intr: @ident_interner, data: @~[u8], out: @io::Writer) {
1106 out.write_str(~"=External Dependencies=\n");
1108 for get_crate_deps(intr, data).each |dep| {
1110 fmt!("%d %s-%s-%s\n",
1111 dep.cnum, *intr.get(dep.name), *dep.hash, *dep.vers));
1114 out.write_str(~"\n");
1117 pub fn get_crate_hash(data: @~[u8]) -> @~str {
1118 let cratedoc = reader::Doc(data);
1119 let hashdoc = reader::get_doc(cratedoc, tag_crate_hash);
1120 @str::from_bytes(reader::doc_data(hashdoc))
1123 pub fn get_crate_vers(data: @~[u8]) -> @~str {
1124 let attrs = decoder::get_crate_attributes(data);
1125 let linkage_attrs = attr::find_linkage_metas(attrs);
1127 match attr::last_meta_item_value_str_by_name(linkage_attrs, ~"vers") {
1133 fn iter_crate_items(intr: @ident_interner, cdata: cmd,
1134 get_crate_data: GetCrateDataCb,
1135 proc: &fn(path: &str, ast::def_id)) {
1136 for each_path(intr, cdata, get_crate_data) |path_string, def_like| {
1138 dl_impl(*) | dl_field => {}
1141 ast_util::def_id_of_def(def))
1147 pub fn list_crate_metadata(intr: @ident_interner, bytes: @~[u8],
1149 let hash = get_crate_hash(bytes);
1150 let md = reader::Doc(bytes);
1151 list_crate_attributes(intr, md, *hash, out);
1152 list_crate_deps(intr, bytes, out);
1155 // Translates a def_id from an external crate to a def_id for the current
1156 // compilation environment. We use this when trying to load types from
1157 // external crates - if those types further refer to types in other crates
1158 // then we must translate the crate number from that encoded in the external
1159 // crate to the correct local crate number.
1160 pub fn translate_def_id(cdata: cmd, did: ast::def_id) -> ast::def_id {
1161 if did.crate == ast::local_crate {
1162 return ast::def_id { crate: cdata.cnum, node: did.node };
1165 match cdata.cnum_map.find(&did.crate) {
1166 option::Some(&n) => ast::def_id { crate: n, node: did.node },
1167 option::None => fail!(~"didn't find a crate in the cnum_map")
1171 pub fn get_link_args_for_crate(cdata: cmd) -> ~[~str] {
1172 let link_args = reader::get_doc(reader::Doc(cdata.data), tag_link_args);
1173 let mut result = ~[];
1174 for reader::tagged_docs(link_args, tag_link_args_arg) |arg_doc| {
1175 result.push(reader::doc_as_str(arg_doc));