2011-07-07 23:29:09 -07:00
|
|
|
// Searching for information from the cstore
|
|
|
|
|
2012-03-19 10:19:00 -07:00
|
|
|
import std::{ebml};
|
2011-07-07 22:18:38 -07:00
|
|
|
import syntax::ast;
|
2012-01-21 02:45:25 +08:00
|
|
|
import syntax::ast_util;
|
2012-05-21 23:34:34 -07:00
|
|
|
import syntax::ast_map;
|
|
|
|
import middle::ty;
|
2012-02-10 06:01:32 -08:00
|
|
|
import option::{some, none};
|
2012-05-22 17:48:04 -07:00
|
|
|
import syntax::diagnostic::span_handler;
|
|
|
|
import syntax::diagnostic::expect;
|
2012-03-19 10:19:00 -07:00
|
|
|
import common::*;
|
2012-03-07 16:48:57 -08:00
|
|
|
import std::map::hashmap;
|
2012-08-07 18:10:06 -07:00
|
|
|
import dvec::dvec;
|
2011-07-08 14:53:25 -07:00
|
|
|
|
2012-05-15 17:59:55 -07:00
|
|
|
export class_dtor;
|
2011-07-08 14:53:25 -07:00
|
|
|
export get_symbol;
|
2012-03-19 10:19:00 -07:00
|
|
|
export get_class_fields;
|
2012-03-22 18:03:12 -07:00
|
|
|
export get_class_method;
|
2012-03-19 10:19:00 -07:00
|
|
|
export get_field_type;
|
2011-07-08 14:53:25 -07:00
|
|
|
export get_type_param_count;
|
2012-07-11 10:28:30 -07:00
|
|
|
export get_region_param;
|
2011-07-08 14:53:25 -07:00
|
|
|
export lookup_defs;
|
2012-02-13 18:56:09 +01:00
|
|
|
export lookup_method_purity;
|
2012-01-25 14:34:31 +01:00
|
|
|
export get_enum_variants;
|
2011-12-16 14:41:12 +01:00
|
|
|
export get_impls_for_mod;
|
2012-07-03 16:30:42 -07:00
|
|
|
export get_trait_methods;
|
2012-07-11 15:00:40 -07:00
|
|
|
export get_method_names_if_trait;
|
2012-07-25 18:36:18 -07:00
|
|
|
export get_item_attrs;
|
2012-05-22 10:54:12 -07:00
|
|
|
export each_path;
|
2011-07-08 14:53:25 -07:00
|
|
|
export get_type;
|
2012-07-18 17:34:59 -07:00
|
|
|
export get_impl_traits;
|
2012-03-08 12:15:02 +01:00
|
|
|
export get_impl_method;
|
2012-02-10 06:01:32 -08:00
|
|
|
export get_item_path;
|
2012-03-08 23:13:57 +01:00
|
|
|
export maybe_get_item_ast, found_ast, found, found_parent, not_found;
|
2011-07-07 22:18:38 -07:00
|
|
|
|
2012-07-13 22:57:48 -07:00
|
|
|
fn get_symbol(cstore: cstore::cstore, def: ast::def_id) -> ~str {
|
2011-07-27 14:19:39 +02:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate).data;
|
2012-08-01 17:30:05 -07:00
|
|
|
return decoder::get_symbol(cdata, def.node);
|
2011-07-07 22:18:38 -07:00
|
|
|
}
|
|
|
|
|
2011-09-12 11:27:30 +02:00
|
|
|
fn get_type_param_count(cstore: cstore::cstore, def: ast::def_id) -> uint {
|
2011-07-27 14:19:39 +02:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate).data;
|
2012-08-01 17:30:05 -07:00
|
|
|
return decoder::get_type_param_count(cdata, def.node);
|
2011-07-07 22:18:38 -07:00
|
|
|
}
|
|
|
|
|
2011-09-12 11:27:30 +02:00
|
|
|
fn lookup_defs(cstore: cstore::cstore, cnum: ast::crate_num,
|
2012-06-29 16:26:56 -07:00
|
|
|
path: ~[ast::ident]) -> ~[ast::def] {
|
|
|
|
let mut result = ~[];
|
2012-07-30 16:01:07 -07:00
|
|
|
debug!{"lookup_defs: path = %? cnum = %?", path, cnum};
|
2012-06-30 16:19:07 -07:00
|
|
|
for resolve_path(cstore, cnum, path).each |elt| {
|
2012-04-06 20:01:43 +02:00
|
|
|
let (c, data, def) = elt;
|
2012-06-26 00:39:18 -07:00
|
|
|
vec::push(result, decoder::lookup_def(c, data, def));
|
2011-12-15 18:42:27 +08:00
|
|
|
}
|
2012-08-01 17:30:05 -07:00
|
|
|
return result;
|
2011-12-15 18:42:27 +08:00
|
|
|
}
|
|
|
|
|
2012-02-13 18:56:09 +01:00
|
|
|
fn lookup_method_purity(cstore: cstore::cstore, did: ast::def_id)
|
|
|
|
-> ast::purity {
|
|
|
|
let cdata = cstore::get_crate_data(cstore, did.crate).data;
|
2012-08-06 12:34:08 -07:00
|
|
|
match check decoder::lookup_def(did.crate, cdata, did) {
|
2012-08-03 19:59:04 -07:00
|
|
|
ast::def_fn(_, p) => p
|
2012-02-13 18:56:09 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-16 19:19:37 -07:00
|
|
|
/* Returns a vector of possible def IDs for a given path,
|
|
|
|
in a given crate */
|
2011-12-15 18:42:27 +08:00
|
|
|
fn resolve_path(cstore: cstore::cstore, cnum: ast::crate_num,
|
2012-06-29 16:26:56 -07:00
|
|
|
path: ~[ast::ident]) ->
|
|
|
|
~[(ast::crate_num, @~[u8], ast::def_id)] {
|
2011-12-15 18:42:27 +08:00
|
|
|
let cm = cstore::get_crate_data(cstore, cnum);
|
2012-07-30 16:01:07 -07:00
|
|
|
debug!{"resolve_path %s in crates[%d]:%s",
|
|
|
|
ast_util::path_name_i(path), cnum, cm.name};
|
2012-06-29 16:26:56 -07:00
|
|
|
let mut result = ~[];
|
2012-06-30 16:19:07 -07:00
|
|
|
for decoder::resolve_path(path, cm.data).each |def| {
|
2011-12-15 18:42:27 +08:00
|
|
|
if def.crate == ast::local_crate {
|
2012-06-26 00:39:18 -07:00
|
|
|
vec::push(result, (cnum, cm.data, def));
|
2011-12-15 18:42:27 +08:00
|
|
|
} else {
|
|
|
|
if cm.cnum_map.contains_key(def.crate) {
|
2012-04-30 23:26:21 -07:00
|
|
|
// This reexport is itself a reexport from another crate
|
2011-12-15 18:42:27 +08:00
|
|
|
let next_cnum = cm.cnum_map.get(def.crate);
|
|
|
|
let next_cm_data = cstore::get_crate_data(cstore, next_cnum);
|
2012-06-26 00:39:18 -07:00
|
|
|
vec::push(result, (next_cnum, next_cm_data.data, def));
|
2011-12-15 18:42:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-08-01 17:30:05 -07:00
|
|
|
return result;
|
2011-07-08 14:53:25 -07:00
|
|
|
}
|
|
|
|
|
2012-07-04 22:53:12 +01:00
|
|
|
/// Iterates over all the paths in the given crate.
|
2012-05-22 10:54:12 -07:00
|
|
|
fn each_path(cstore: cstore::cstore, cnum: ast::crate_num,
|
|
|
|
f: fn(decoder::path_entry) -> bool) {
|
|
|
|
let crate_data = cstore::get_crate_data(cstore, cnum);
|
|
|
|
decoder::each_path(crate_data, f);
|
|
|
|
}
|
|
|
|
|
2012-02-10 06:01:32 -08:00
|
|
|
fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {
|
2012-05-22 17:48:04 -07:00
|
|
|
let cstore = tcx.cstore;
|
2012-02-10 06:01:32 -08:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-02-11 09:49:38 -08:00
|
|
|
let path = decoder::get_item_path(cdata, def.node);
|
2012-03-02 20:06:08 -08:00
|
|
|
|
|
|
|
// FIXME #1920: This path is not always correct if the crate is not linked
|
|
|
|
// into the root namespace.
|
2012-06-29 16:26:56 -07:00
|
|
|
vec::append(~[ast_map::path_mod(@cdata.name)], path)
|
2012-02-10 06:01:32 -08:00
|
|
|
}
|
|
|
|
|
2012-03-08 23:13:57 +01:00
|
|
|
enum found_ast {
|
|
|
|
found(ast::inlined_item),
|
|
|
|
found_parent(ast::def_id, ast::inlined_item),
|
|
|
|
not_found,
|
|
|
|
}
|
|
|
|
|
2012-02-14 15:21:53 -08:00
|
|
|
// Finds the AST for this item in the crate metadata, if any. If the item was
|
|
|
|
// not marked for inlining, then the AST will not be present and hence none
|
|
|
|
// will be returned.
|
2012-05-14 17:46:45 -07:00
|
|
|
fn maybe_get_item_ast(tcx: ty::ctxt, def: ast::def_id,
|
|
|
|
decode_inlined_item: decoder::decode_inlined_item)
|
2012-03-08 23:13:57 +01:00
|
|
|
-> found_ast {
|
2012-05-22 17:48:04 -07:00
|
|
|
let cstore = tcx.cstore;
|
2012-02-14 15:21:53 -08:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-05-14 17:46:45 -07:00
|
|
|
decoder::maybe_get_item_ast(cdata, tcx, def.node,
|
|
|
|
decode_inlined_item)
|
2012-02-14 15:21:53 -08:00
|
|
|
}
|
|
|
|
|
2012-06-25 20:00:46 -07:00
|
|
|
fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id)
|
2012-06-29 16:26:56 -07:00
|
|
|
-> ~[ty::variant_info] {
|
2012-05-22 17:48:04 -07:00
|
|
|
let cstore = tcx.cstore;
|
2012-01-05 16:04:59 +01:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-08-01 17:30:05 -07:00
|
|
|
return decoder::get_enum_variants(cdata, def.node, tcx)
|
2011-07-07 22:18:38 -07:00
|
|
|
}
|
|
|
|
|
2011-12-16 14:41:12 +01:00
|
|
|
fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
|
2012-01-31 17:05:20 -08:00
|
|
|
name: option<ast::ident>)
|
2012-06-29 16:26:56 -07:00
|
|
|
-> @~[@decoder::_impl] {
|
2012-01-05 16:04:59 +01:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-06-30 16:19:07 -07:00
|
|
|
do decoder::get_impls_for_mod(cdata, def.node, name) |cnum| {
|
2012-04-16 14:58:58 -07:00
|
|
|
cstore::get_crate_data(cstore, cnum)
|
|
|
|
}
|
2011-12-16 14:41:12 +01:00
|
|
|
}
|
|
|
|
|
2012-07-03 16:30:42 -07:00
|
|
|
fn get_trait_methods(tcx: ty::ctxt, def: ast::def_id) -> @~[ty::method] {
|
2012-05-22 17:48:04 -07:00
|
|
|
let cstore = tcx.cstore;
|
2012-01-05 16:04:59 +01:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-07-03 16:30:42 -07:00
|
|
|
decoder::get_trait_methods(cdata, def.node, tcx)
|
2011-12-16 14:41:12 +01:00
|
|
|
}
|
|
|
|
|
2012-07-11 15:00:40 -07:00
|
|
|
fn get_method_names_if_trait(cstore: cstore::cstore, def: ast::def_id)
|
2012-08-02 16:01:38 -07:00
|
|
|
-> option<@dvec<(@~str, ast::self_ty_)>> {
|
2012-07-11 15:00:40 -07:00
|
|
|
|
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-08-01 17:30:05 -07:00
|
|
|
return decoder::get_method_names_if_trait(cdata, def.node);
|
2012-07-11 15:00:40 -07:00
|
|
|
}
|
|
|
|
|
2012-07-25 18:36:18 -07:00
|
|
|
fn get_item_attrs(cstore: cstore::cstore,
|
|
|
|
def_id: ast::def_id,
|
|
|
|
f: fn(~[@ast::meta_item])) {
|
|
|
|
|
|
|
|
let cdata = cstore::get_crate_data(cstore, def_id.crate);
|
|
|
|
decoder::get_item_attrs(cdata, def_id.node, f)
|
|
|
|
}
|
|
|
|
|
2012-06-29 16:26:56 -07:00
|
|
|
fn get_class_fields(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::field_ty] {
|
2012-05-22 17:48:04 -07:00
|
|
|
let cstore = tcx.cstore;
|
2012-03-06 08:02:13 -08:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-03-21 12:42:34 -07:00
|
|
|
decoder::get_class_fields(cdata, def.node)
|
2012-03-06 08:02:13 -08:00
|
|
|
}
|
|
|
|
|
2011-12-28 17:50:12 +01:00
|
|
|
fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
|
2012-05-22 17:48:04 -07:00
|
|
|
let cstore = tcx.cstore;
|
2012-01-05 16:04:59 +01:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
|
|
|
decoder::get_type(cdata, def.node, tcx)
|
2011-07-07 22:18:38 -07:00
|
|
|
}
|
|
|
|
|
2012-07-11 10:28:30 -07:00
|
|
|
fn get_region_param(cstore: metadata::cstore::cstore,
|
|
|
|
def: ast::def_id) -> bool {
|
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-08-01 17:30:05 -07:00
|
|
|
return decoder::get_region_param(cdata, def.node);
|
2012-07-11 10:28:30 -07:00
|
|
|
}
|
|
|
|
|
2012-03-19 10:19:00 -07:00
|
|
|
fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
|
|
|
|
def: ast::def_id) -> ty::ty_param_bounds_and_ty {
|
2012-05-22 17:48:04 -07:00
|
|
|
let cstore = tcx.cstore;
|
2012-03-19 10:19:00 -07:00
|
|
|
let cdata = cstore::get_crate_data(cstore, class_id.crate);
|
|
|
|
let all_items = ebml::get_doc(ebml::doc(cdata.data), tag_items);
|
2012-07-30 16:01:07 -07:00
|
|
|
debug!{"Looking up %?", class_id};
|
2012-05-22 17:48:04 -07:00
|
|
|
let class_doc = expect(tcx.diag,
|
2012-03-19 10:19:00 -07:00
|
|
|
decoder::maybe_find_item(class_id.node, all_items),
|
2012-07-30 16:01:07 -07:00
|
|
|
|| fmt!{"get_field_type: class ID %? not found",
|
|
|
|
class_id} );
|
|
|
|
debug!{"looking up %? : %?", def, class_doc};
|
2012-05-22 17:48:04 -07:00
|
|
|
let the_field = expect(tcx.diag,
|
2012-03-19 10:19:00 -07:00
|
|
|
decoder::maybe_find_item(def.node, class_doc),
|
2012-07-30 16:01:07 -07:00
|
|
|
|| fmt!{"get_field_type: in class %?, field ID %? not found",
|
|
|
|
class_id, def} );
|
|
|
|
debug!{"got field data %?", the_field};
|
2012-03-19 10:19:00 -07:00
|
|
|
let ty = decoder::item_type(def, the_field, tcx, cdata);
|
2012-08-01 17:30:05 -07:00
|
|
|
return {bounds: @~[], rp: false, ty: ty};
|
2012-03-19 10:19:00 -07:00
|
|
|
}
|
|
|
|
|
2012-07-18 17:34:59 -07:00
|
|
|
// Given a def_id for an impl or class, return the traits it implements,
|
|
|
|
// or the empty vector if it's not for an impl or for a class that implements
|
|
|
|
// traits
|
|
|
|
fn get_impl_traits(tcx: ty::ctxt, def: ast::def_id) -> ~[ty::t] {
|
2012-05-22 17:48:04 -07:00
|
|
|
let cstore = tcx.cstore;
|
2012-01-05 16:04:59 +01:00
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
2012-07-18 17:34:59 -07:00
|
|
|
decoder::get_impl_traits(cdata, def.node, tcx)
|
2011-07-07 22:18:38 -07:00
|
|
|
}
|
|
|
|
|
2012-06-10 00:49:59 -07:00
|
|
|
fn get_impl_method(cstore: cstore::cstore,
|
|
|
|
def: ast::def_id, mname: ast::ident)
|
2012-03-08 12:15:02 +01:00
|
|
|
-> ast::def_id {
|
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
|
|
|
decoder::get_impl_method(cdata, def.node, mname)
|
|
|
|
}
|
|
|
|
|
2012-07-03 16:30:42 -07:00
|
|
|
/* Because classes use the trait format rather than the impl format
|
|
|
|
for their methods (so that get_trait_methods can be reused to get
|
2012-03-22 18:03:12 -07:00
|
|
|
class methods), classes require a slightly different version of
|
|
|
|
get_impl_method. Sigh. */
|
2012-06-10 00:49:59 -07:00
|
|
|
fn get_class_method(cstore: cstore::cstore,
|
|
|
|
def: ast::def_id, mname: ast::ident)
|
2012-03-22 18:03:12 -07:00
|
|
|
-> ast::def_id {
|
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
|
|
|
decoder::get_class_method(cdata, def.node, mname)
|
|
|
|
}
|
|
|
|
|
2012-05-15 17:59:55 -07:00
|
|
|
/* If def names a class with a dtor, return it. Otherwise, return none. */
|
|
|
|
fn class_dtor(cstore: cstore::cstore, def: ast::def_id)
|
|
|
|
-> option<ast::def_id> {
|
|
|
|
let cdata = cstore::get_crate_data(cstore, def.crate);
|
|
|
|
decoder::class_dtor(cdata, def.node)
|
|
|
|
}
|
2011-07-07 22:18:38 -07:00
|
|
|
// Local Variables:
|
|
|
|
// mode: rust
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|