1 // Copyright 2012-2014 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 // Searching for information from the cstore
13 #![allow(non_camel_case_types)]
15 use metadata::common::*;
17 use metadata::decoder;
18 use middle::lang_items;
22 use middle::subst::VecPerParamSpace;
30 use syntax::diagnostic::expect;
31 use syntax::parse::token;
33 use std::collections::hashmap::HashMap;
35 pub struct StaticMethodInfo {
36 pub ident: ast::Ident,
37 pub def_id: ast::DefId,
38 pub fn_style: ast::FnStyle,
39 pub vis: ast::Visibility,
42 pub fn get_symbol(cstore: &cstore::CStore, def: ast::DefId) -> String {
43 let cdata = cstore.get_crate_data(def.krate);
44 decoder::get_symbol(cdata.data(), def.node)
47 /// Iterates over all the language items in the given crate.
48 pub fn each_lang_item(cstore: &cstore::CStore,
50 f: |ast::NodeId, uint| -> bool)
52 let crate_data = cstore.get_crate_data(cnum);
53 decoder::each_lang_item(&*crate_data, f)
56 /// Iterates over each child of the given item.
57 pub fn each_child_of_item(cstore: &cstore::CStore,
59 callback: |decoder::DefLike,
62 let crate_data = cstore.get_crate_data(def_id.krate);
63 let get_crate_data: decoder::GetCrateDataCb = |cnum| {
64 cstore.get_crate_data(cnum)
66 decoder::each_child_of_item(cstore.intr.clone(),
73 /// Iterates over each top-level crate item.
74 pub fn each_top_level_item_of_crate(cstore: &cstore::CStore,
76 callback: |decoder::DefLike,
79 let crate_data = cstore.get_crate_data(cnum);
80 let get_crate_data: decoder::GetCrateDataCb = |cnum| {
81 cstore.get_crate_data(cnum)
83 decoder::each_top_level_item_of_crate(cstore.intr.clone(),
89 pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem> {
90 let cstore = &tcx.sess.cstore;
91 let cdata = cstore.get_crate_data(def.krate);
92 let path = decoder::get_item_path(&*cdata, def.node);
94 // FIXME #1920: This path is not always correct if the crate is not linked
95 // into the root namespace.
96 (vec!(ast_map::PathMod(token::intern(cdata.name.as_slice())))).append(
100 pub enum found_ast<'ast> {
101 found(&'ast ast::InlinedItem),
102 found_parent(ast::DefId, &'ast ast::InlinedItem),
106 // Finds the AST for this item in the crate metadata, if any. If the item was
107 // not marked for inlining, then the AST will not be present and hence none
109 pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId,
110 decode_inlined_item: decoder::DecodeInlinedItem)
112 let cstore = &tcx.sess.cstore;
113 let cdata = cstore.get_crate_data(def.krate);
114 decoder::maybe_get_item_ast(&*cdata, tcx, def.node, decode_inlined_item)
117 pub fn get_enum_variants(tcx: &ty::ctxt, def: ast::DefId)
118 -> Vec<Rc<ty::VariantInfo>> {
119 let cstore = &tcx.sess.cstore;
120 let cdata = cstore.get_crate_data(def.krate);
121 decoder::get_enum_variants(cstore.intr.clone(), &*cdata, def.node, tcx)
124 /// Returns information about the given implementation.
125 pub fn get_impl_items(cstore: &cstore::CStore, impl_def_id: ast::DefId)
126 -> Vec<ty::ImplOrTraitItemId> {
127 let cdata = cstore.get_crate_data(impl_def_id.krate);
128 decoder::get_impl_items(&*cdata, impl_def_id.node)
131 pub fn get_impl_or_trait_item(tcx: &ty::ctxt, def: ast::DefId)
132 -> ty::ImplOrTraitItem {
133 let cdata = tcx.sess.cstore.get_crate_data(def.krate);
134 decoder::get_impl_or_trait_item(tcx.sess.cstore.intr.clone(),
140 pub fn get_trait_item_name_and_kind(cstore: &cstore::CStore, def: ast::DefId)
141 -> (ast::Ident, resolve::TraitItemKind) {
142 let cdata = cstore.get_crate_data(def.krate);
143 decoder::get_trait_item_name_and_kind(cstore.intr.clone(),
148 pub fn get_trait_item_def_ids(cstore: &cstore::CStore, def: ast::DefId)
149 -> Vec<ty::ImplOrTraitItemId> {
150 let cdata = cstore.get_crate_data(def.krate);
151 decoder::get_trait_item_def_ids(&*cdata, def.node)
154 pub fn get_item_variances(cstore: &cstore::CStore,
155 def: ast::DefId) -> ty::ItemVariances {
156 let cdata = cstore.get_crate_data(def.krate);
157 decoder::get_item_variances(&*cdata, def.node)
160 pub fn get_provided_trait_methods(tcx: &ty::ctxt,
162 -> Vec<Rc<ty::Method>> {
163 let cstore = &tcx.sess.cstore;
164 let cdata = cstore.get_crate_data(def.krate);
165 decoder::get_provided_trait_methods(cstore.intr.clone(), &*cdata, def.node, tcx)
168 pub fn get_supertraits(tcx: &ty::ctxt, def: ast::DefId) -> Vec<Rc<ty::TraitRef>> {
169 let cstore = &tcx.sess.cstore;
170 let cdata = cstore.get_crate_data(def.krate);
171 decoder::get_supertraits(&*cdata, def.node, tcx)
174 pub fn get_type_name_if_impl(cstore: &cstore::CStore, def: ast::DefId)
175 -> Option<ast::Ident> {
176 let cdata = cstore.get_crate_data(def.krate);
177 decoder::get_type_name_if_impl(&*cdata, def.node)
180 pub fn get_static_methods_if_impl(cstore: &cstore::CStore,
182 -> Option<Vec<StaticMethodInfo> > {
183 let cdata = cstore.get_crate_data(def.krate);
184 decoder::get_static_methods_if_impl(cstore.intr.clone(), &*cdata, def.node)
187 pub fn get_item_attrs(cstore: &cstore::CStore,
189 f: |Vec<ast::Attribute>|) {
190 let cdata = cstore.get_crate_data(def_id.krate);
191 decoder::get_item_attrs(&*cdata, def_id.node, f)
194 pub fn get_struct_fields(cstore: &cstore::CStore,
196 -> Vec<ty::field_ty> {
197 let cdata = cstore.get_crate_data(def.krate);
198 decoder::get_struct_fields(cstore.intr.clone(), &*cdata, def.node)
201 pub fn get_struct_field_attrs(cstore: &cstore::CStore, def: ast::DefId) -> HashMap<ast::NodeId,
202 Vec<ast::Attribute>> {
203 let cdata = cstore.get_crate_data(def.krate);
204 decoder::get_struct_field_attrs(&*cdata)
207 pub fn get_type(tcx: &ty::ctxt,
210 let cstore = &tcx.sess.cstore;
211 let cdata = cstore.get_crate_data(def.krate);
212 decoder::get_type(&*cdata, def.node, tcx)
215 pub fn get_trait_def(tcx: &ty::ctxt, def: ast::DefId) -> ty::TraitDef {
216 let cstore = &tcx.sess.cstore;
217 let cdata = cstore.get_crate_data(def.krate);
218 decoder::get_trait_def(&*cdata, def.node, tcx)
221 pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
222 def: ast::DefId) -> ty::Polytype {
223 let cstore = &tcx.sess.cstore;
224 let cdata = cstore.get_crate_data(class_id.krate);
225 let all_items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_items);
226 let class_doc = expect(tcx.sess.diagnostic(),
227 decoder::maybe_find_item(class_id.node, all_items),
229 (format!("get_field_type: class ID {:?} not found",
230 class_id)).to_string()
232 let the_field = expect(tcx.sess.diagnostic(),
233 decoder::maybe_find_item(def.node, class_doc),
235 (format!("get_field_type: in class {:?}, field ID {:?} not found",
239 let ty = decoder::item_type(def, the_field, tcx, &*cdata);
241 generics: ty::Generics {types: VecPerParamSpace::empty(),
242 regions: VecPerParamSpace::empty()},
247 // Given a def_id for an impl, return the trait it implements,
249 pub fn get_impl_trait(tcx: &ty::ctxt,
250 def: ast::DefId) -> Option<Rc<ty::TraitRef>> {
251 let cstore = &tcx.sess.cstore;
252 let cdata = cstore.get_crate_data(def.krate);
253 decoder::get_impl_trait(&*cdata, def.node, tcx)
256 // Given a def_id for an impl, return information about its vtables
257 pub fn get_impl_vtables(tcx: &ty::ctxt,
259 -> typeck::vtable_res {
260 let cstore = &tcx.sess.cstore;
261 let cdata = cstore.get_crate_data(def.krate);
262 decoder::get_impl_vtables(&*cdata, def.node, tcx)
265 pub fn get_native_libraries(cstore: &cstore::CStore,
266 crate_num: ast::CrateNum)
267 -> Vec<(cstore::NativeLibaryKind, String)> {
268 let cdata = cstore.get_crate_data(crate_num);
269 decoder::get_native_libraries(&*cdata)
272 pub fn each_impl(cstore: &cstore::CStore,
273 crate_num: ast::CrateNum,
274 callback: |ast::DefId|) {
275 let cdata = cstore.get_crate_data(crate_num);
276 decoder::each_impl(&*cdata, callback)
279 pub fn each_implementation_for_type(cstore: &cstore::CStore,
281 callback: |ast::DefId|) {
282 let cdata = cstore.get_crate_data(def_id.krate);
283 decoder::each_implementation_for_type(&*cdata, def_id.node, callback)
286 pub fn each_implementation_for_trait(cstore: &cstore::CStore,
288 callback: |ast::DefId|) {
289 let cdata = cstore.get_crate_data(def_id.krate);
290 decoder::each_implementation_for_trait(&*cdata, def_id.node, callback)
293 /// If the given def ID describes an item belonging to a trait (either a
294 /// default method or an implementation of a trait method), returns the ID of
295 /// the trait that the method belongs to. Otherwise, returns `None`.
296 pub fn get_trait_of_item(cstore: &cstore::CStore,
299 -> Option<ast::DefId> {
300 let cdata = cstore.get_crate_data(def_id.krate);
301 decoder::get_trait_of_item(&*cdata, def_id.node, tcx)
304 pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore,
306 -> Option<ast::DefId>
308 let cdata = cstore.get_crate_data(def_id.krate);
309 decoder::get_tuple_struct_definition_if_ctor(&*cdata, def_id.node)
312 pub fn get_dylib_dependency_formats(cstore: &cstore::CStore,
314 -> Vec<(ast::CrateNum, cstore::LinkagePreference)>
316 let cdata = cstore.get_crate_data(cnum);
317 decoder::get_dylib_dependency_formats(&*cdata)
320 pub fn get_missing_lang_items(cstore: &cstore::CStore, cnum: ast::CrateNum)
321 -> Vec<lang_items::LangItem>
323 let cdata = cstore.get_crate_data(cnum);
324 decoder::get_missing_lang_items(&*cdata)
327 pub fn get_method_arg_names(cstore: &cstore::CStore, did: ast::DefId)
330 let cdata = cstore.get_crate_data(did.krate);
331 decoder::get_method_arg_names(&*cdata, did.node)
334 pub fn get_reachable_extern_fns(cstore: &cstore::CStore, cnum: ast::CrateNum)
337 let cdata = cstore.get_crate_data(cnum);
338 decoder::get_reachable_extern_fns(&*cdata)
341 pub fn is_typedef(cstore: &cstore::CStore, did: ast::DefId) -> bool {
342 let cdata = cstore.get_crate_data(did.krate);
343 decoder::is_typedef(&*cdata, did.node)
346 pub fn get_stability(cstore: &cstore::CStore,
348 -> Option<attr::Stability> {
349 let cdata = cstore.get_crate_data(def.krate);
350 decoder::get_stability(&*cdata, def.node)
353 pub fn is_associated_type(cstore: &cstore::CStore, def: ast::DefId) -> bool {
354 let cdata = cstore.get_crate_data(def.krate);
355 decoder::is_associated_type(&*cdata, def.node)