src/librustc_metadata/csearch.rs

   1 // Copyright 2015 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.
   4 //
   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.
  10
  11 use astencode;
  12 use cstore;
  13 use decoder;
  14 use encoder;
  15 use loader;
  16
  17 use middle::cstore::{CrateStore, CrateSource, ChildItem, FoundAst};
  18 use middle::cstore::{NativeLibraryKind, LinkMeta, LinkagePreference};
  19 use middle::def;
  20 use middle::lang_items;
  21 use middle::ty::{self, Ty};
  22 use middle::def_id::{DefId, DefIndex};
  23
  24 use rustc::front::map as hir_map;
  25 use rustc::mir::repr::Mir;
  26 use rustc::util::nodemap::{FnvHashMap, NodeMap, NodeSet};
  27
  28 use std::cell::RefCell;
  29 use std::rc::Rc;
  30 use std::path::PathBuf;
  31 use syntax::ast;
  32 use syntax::attr;
  33 use syntax::parse::token;
  34 use rustc_back::svh::Svh;
  35 use rustc_back::target::Target;
  36 use rustc_front::hir;
  37
  38 impl<'tcx> CrateStore<'tcx> for cstore::CStore {
  39     fn stability(&self, def: DefId) -> Option<attr::Stability>
  40     {
  41         let cdata = self.get_crate_data(def.krate);
  42         decoder::get_stability(&*cdata, def.index)
  43     }
  44
  45     fn closure_kind(&self, _tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureKind
  46     {
  47         assert!(!def_id.is_local());
  48         let cdata = self.get_crate_data(def_id.krate);
  49         decoder::closure_kind(&*cdata, def_id.index)
  50     }
  51
  52     fn closure_ty(&self, tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureTy<'tcx>
  53     {
  54         assert!(!def_id.is_local());
  55         let cdata = self.get_crate_data(def_id.krate);
  56         decoder::closure_ty(&*cdata, def_id.index, tcx)
  57     }
  58
  59     fn item_variances(&self, def: DefId) -> ty::ItemVariances {
  60         let cdata = self.get_crate_data(def.krate);
  61         decoder::get_item_variances(&*cdata, def.index)
  62     }
  63
  64     fn repr_attrs(&self, def: DefId) -> Vec<attr::ReprAttr> {
  65         let cdata = self.get_crate_data(def.krate);
  66         decoder::get_repr_attrs(&*cdata, def.index)
  67     }
  68
  69     fn item_type(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
  70                  -> ty::TypeScheme<'tcx>
  71     {
  72         let cdata = self.get_crate_data(def.krate);
  73         decoder::get_type(&*cdata, def.index, tcx)
  74     }
  75
  76     fn item_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
  77                        -> ty::GenericPredicates<'tcx>
  78     {
  79         let cdata = self.get_crate_data(def.krate);
  80         decoder::get_predicates(&*cdata, def.index, tcx)
  81     }
  82
  83     fn item_super_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
  84                              -> ty::GenericPredicates<'tcx>
  85     {
  86         let cdata = self.get_crate_data(def.krate);
  87         decoder::get_super_predicates(&*cdata, def.index, tcx)
  88     }
  89
  90     fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute>
  91     {
  92         let cdata = self.get_crate_data(def_id.krate);
  93         decoder::get_item_attrs(&*cdata, def_id.index)
  94     }
  95
  96     fn item_symbol(&self, def: DefId) -> String
  97     {
  98         let cdata = self.get_crate_data(def.krate);
  99         decoder::get_symbol(&cdata, def.index)
 100     }
 101
 102     fn trait_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx>
 103     {
 104         let cdata = self.get_crate_data(def.krate);
 105         decoder::get_trait_def(&*cdata, def.index, tcx)
 106     }
 107
 108     fn adt_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx>
 109     {
 110         let cdata = self.get_crate_data(def.krate);
 111         decoder::get_adt_def(&self.intr, &*cdata, def.index, tcx)
 112     }
 113
 114     fn method_arg_names(&self, did: DefId) -> Vec<String>
 115     {
 116         let cdata = self.get_crate_data(did.krate);
 117         decoder::get_method_arg_names(&cdata, did.index)
 118     }
 119
 120     fn item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
 121         let cdata = self.get_crate_data(def.krate);
 122         let path = decoder::get_item_path(&*cdata, def.index);
 123
 124         cdata.with_local_path(|cpath| {
 125             let mut r = Vec::with_capacity(cpath.len() + path.len());
 126             r.extend_from_slice(cpath);
 127             r.extend_from_slice(&path);
 128             r
 129         })
 130     }
 131
 132     fn extern_item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
 133         let cdata = self.get_crate_data(def.krate);
 134         let path = decoder::get_item_path(&*cdata, def.index);
 135
 136         let mut r = Vec::with_capacity(path.len() + 1);
 137         let crate_name = hir_map::PathMod(token::intern(&cdata.name));
 138         r.push(crate_name);
 139         r.extend_from_slice(&path);
 140         r
 141     }
 142
 143     fn item_name(&self, def: DefId) -> ast::Name {
 144         let cdata = self.get_crate_data(def.krate);
 145         decoder::get_item_name(&self.intr, &cdata, def.index)
 146     }
 147
 148
 149     fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId>
 150     {
 151         let mut result = vec![];
 152         let cdata = self.get_crate_data(def_id.krate);
 153         decoder::each_inherent_implementation_for_type(&*cdata, def_id.index,
 154                                                        |iid| result.push(iid));
 155         result
 156     }
 157
 158     fn implementations_of_trait(&self, def_id: DefId) -> Vec<DefId>
 159     {
 160         let mut result = vec![];
 161         self.iter_crate_data(|_, cdata| {
 162             decoder::each_implementation_for_trait(cdata, def_id, &mut |iid| {
 163                 result.push(iid)
 164             })
 165         });
 166         result
 167     }
 168
 169     fn provided_trait_methods(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 170                               -> Vec<Rc<ty::Method<'tcx>>>
 171     {
 172         let cdata = self.get_crate_data(def.krate);
 173         decoder::get_provided_trait_methods(self.intr.clone(), &*cdata, def.index, tcx)
 174     }
 175
 176     fn trait_item_def_ids(&self, def: DefId)
 177                           -> Vec<ty::ImplOrTraitItemId>
 178     {
 179         let cdata = self.get_crate_data(def.krate);
 180         decoder::get_trait_item_def_ids(&*cdata, def.index)
 181     }
 182
 183     fn impl_items(&self, impl_def_id: DefId) -> Vec<ty::ImplOrTraitItemId>
 184     {
 185         let cdata = self.get_crate_data(impl_def_id.krate);
 186         decoder::get_impl_items(&*cdata, impl_def_id.index)
 187     }
 188
 189     fn impl_polarity(&self, def: DefId) -> Option<hir::ImplPolarity>
 190     {
 191         let cdata = self.get_crate_data(def.krate);
 192         decoder::get_impl_polarity(&*cdata, def.index)
 193     }
 194
 195     fn impl_trait_ref(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 196                       -> Option<ty::TraitRef<'tcx>>
 197     {
 198         let cdata = self.get_crate_data(def.krate);
 199         decoder::get_impl_trait(&*cdata, def.index, tcx)
 200     }
 201
 202     fn custom_coerce_unsized_kind(&self, def: DefId)
 203                                   -> Option<ty::adjustment::CustomCoerceUnsized>
 204     {
 205         let cdata = self.get_crate_data(def.krate);
 206         decoder::get_custom_coerce_unsized_kind(&*cdata, def.index)
 207     }
 208
 209     // FIXME: killme
 210     fn associated_consts(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 211                          -> Vec<Rc<ty::AssociatedConst<'tcx>>> {
 212         let cdata = self.get_crate_data(def.krate);
 213         decoder::get_associated_consts(self.intr.clone(), &*cdata, def.index, tcx)
 214     }
 215
 216     fn trait_of_item(&self, tcx: &ty::ctxt<'tcx>, def_id: DefId) -> Option<DefId>
 217     {
 218         let cdata = self.get_crate_data(def_id.krate);
 219         decoder::get_trait_of_item(&*cdata, def_id.index, tcx)
 220     }
 221
 222     fn impl_or_trait_item(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 223                           -> ty::ImplOrTraitItem<'tcx>
 224     {
 225         let cdata = self.get_crate_data(def.krate);
 226         decoder::get_impl_or_trait_item(
 227             self.intr.clone(),
 228             &*cdata,
 229             def.index,
 230             tcx)
 231     }
 232
 233     fn is_const_fn(&self, did: DefId) -> bool
 234     {
 235         let cdata = self.get_crate_data(did.krate);
 236         decoder::is_const_fn(&cdata, did.index)
 237     }
 238
 239     fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool
 240     {
 241         let cdata = self.get_crate_data(trait_def_id.krate);
 242         decoder::is_defaulted_trait(&*cdata, trait_def_id.index)
 243     }
 244
 245     fn is_impl(&self, did: DefId) -> bool
 246     {
 247         let cdata = self.get_crate_data(did.krate);
 248         decoder::is_impl(&*cdata, did.index)
 249     }
 250
 251     fn is_default_impl(&self, impl_did: DefId) -> bool {
 252         let cdata = self.get_crate_data(impl_did.krate);
 253         decoder::is_default_impl(&*cdata, impl_did.index)
 254     }
 255
 256     fn is_extern_fn(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool
 257     {
 258         let cdata = self.get_crate_data(did.krate);
 259         decoder::is_extern_fn(&*cdata, did.index, tcx)
 260     }
 261
 262     fn is_static(&self, did: DefId) -> bool
 263     {
 264         let cdata = self.get_crate_data(did.krate);
 265         decoder::is_static(&*cdata, did.index)
 266     }
 267
 268     fn is_static_method(&self, def: DefId) -> bool
 269     {
 270         let cdata = self.get_crate_data(def.krate);
 271         decoder::is_static_method(&*cdata, def.index)
 272     }
 273
 274     fn is_statically_included_foreign_item(&self, id: ast::NodeId) -> bool
 275     {
 276         self.do_is_statically_included_foreign_item(id)
 277     }
 278
 279     fn is_typedef(&self, did: DefId) -> bool {
 280         let cdata = self.get_crate_data(did.krate);
 281         decoder::is_typedef(&*cdata, did.index)
 282     }
 283
 284     fn dylib_dependency_formats(&self, cnum: ast::CrateNum)
 285                                 -> Vec<(ast::CrateNum, LinkagePreference)>
 286     {
 287         let cdata = self.get_crate_data(cnum);
 288         decoder::get_dylib_dependency_formats(&cdata)
 289     }
 290
 291     fn lang_items(&self, cnum: ast::CrateNum) -> Vec<(DefIndex, usize)>
 292     {
 293         let mut result = vec![];
 294         let crate_data = self.get_crate_data(cnum);
 295         decoder::each_lang_item(&*crate_data, |did, lid| {
 296             result.push((did, lid)); true
 297         });
 298         result
 299     }
 300
 301     fn missing_lang_items(&self, cnum: ast::CrateNum)
 302                           -> Vec<lang_items::LangItem>
 303     {
 304         let cdata = self.get_crate_data(cnum);
 305         decoder::get_missing_lang_items(&*cdata)
 306     }
 307
 308     fn is_staged_api(&self, cnum: ast::CrateNum) -> bool
 309     {
 310         self.get_crate_data(cnum).staged_api
 311     }
 312
 313     fn is_explicitly_linked(&self, cnum: ast::CrateNum) -> bool
 314     {
 315         self.get_crate_data(cnum).explicitly_linked.get()
 316     }
 317
 318     fn is_allocator(&self, cnum: ast::CrateNum) -> bool
 319     {
 320         self.get_crate_data(cnum).is_allocator()
 321     }
 322
 323     fn crate_attrs(&self, cnum: ast::CrateNum) -> Vec<ast::Attribute>
 324     {
 325         decoder::get_crate_attributes(self.get_crate_data(cnum).data())
 326     }
 327
 328     fn crate_name(&self, cnum: ast::CrateNum) -> String
 329     {
 330         self.get_crate_data(cnum).name.clone()
 331     }
 332
 333     fn crate_hash(&self, cnum: ast::CrateNum) -> Svh
 334     {
 335         let cdata = self.get_crate_data(cnum);
 336         decoder::get_crate_hash(cdata.data())
 337     }
 338
 339     fn crate_struct_field_attrs(&self, cnum: ast::CrateNum)
 340                                 -> FnvHashMap<DefId, Vec<ast::Attribute>>
 341     {
 342         decoder::get_struct_field_attrs(&*self.get_crate_data(cnum))
 343     }
 344
 345     fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option<DefId>
 346     {
 347         let cdata = self.get_crate_data(cnum);
 348         decoder::get_plugin_registrar_fn(cdata.data()).map(|index| DefId {
 349             krate: cnum,
 350             index: index
 351         })
 352     }
 353
 354     fn native_libraries(&self, cnum: ast::CrateNum) -> Vec<(NativeLibraryKind, String)>
 355     {
 356         let cdata = self.get_crate_data(cnum);
 357         decoder::get_native_libraries(&*cdata)
 358     }
 359
 360     fn reachable_ids(&self, cnum: ast::CrateNum) -> Vec<DefId>
 361     {
 362         let cdata = self.get_crate_data(cnum);
 363         decoder::get_reachable_ids(&*cdata)
 364     }
 365
 366     fn def_path(&self, def: DefId) -> hir_map::DefPath
 367     {
 368         let cdata = self.get_crate_data(def.krate);
 369         let path = decoder::def_path(&*cdata, def.index);
 370         let local_path = cdata.local_def_path();
 371         local_path.into_iter().chain(path).collect()
 372     }
 373
 374     fn tuple_struct_definition_if_ctor(&self, did: DefId) -> Option<DefId>
 375     {
 376         let cdata = self.get_crate_data(did.krate);
 377         decoder::get_tuple_struct_definition_if_ctor(&*cdata, did.index)
 378     }
 379
 380     fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
 381     {
 382         let cdata = self.get_crate_data(def.krate);
 383         decoder::get_struct_field_names(&self.intr, &*cdata, def.index)
 384     }
 385
 386     fn item_children(&self, def_id: DefId) -> Vec<ChildItem>
 387     {
 388         let mut result = vec![];
 389         let crate_data = self.get_crate_data(def_id.krate);
 390         let get_crate_data = |cnum| self.get_crate_data(cnum);
 391         decoder::each_child_of_item(
 392             self.intr.clone(), &*crate_data,
 393             def_id.index, get_crate_data,
 394             |def, name, vis| result.push(ChildItem {
 395                 def: def,
 396                 name: name,
 397                 vis: vis
 398             }));
 399         result
 400     }
 401
 402     fn crate_top_level_items(&self, cnum: ast::CrateNum) -> Vec<ChildItem>
 403     {
 404         let mut result = vec![];
 405         let crate_data = self.get_crate_data(cnum);
 406         let get_crate_data = |cnum| self.get_crate_data(cnum);
 407         decoder::each_top_level_item_of_crate(
 408             self.intr.clone(), &*crate_data, get_crate_data,
 409             |def, name, vis| result.push(ChildItem {
 410                 def: def,
 411                 name: name,
 412                 vis: vis
 413             }));
 414         result
 415     }
 416
 417     fn maybe_get_item_ast(&'tcx self, tcx: &ty::ctxt<'tcx>, def: DefId)
 418                           -> FoundAst<'tcx>
 419     {
 420         let cdata = self.get_crate_data(def.krate);
 421         let decode_inlined_item = Box::new(astencode::decode_inlined_item);
 422         decoder::maybe_get_item_ast(&*cdata, tcx, def.index, decode_inlined_item)
 423     }
 424
 425     fn maybe_get_item_mir(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 426                           -> Option<Mir<'tcx>> {
 427         let cdata = self.get_crate_data(def.krate);
 428         decoder::maybe_get_item_mir(&*cdata, tcx, def.index)
 429     }
 430
 431     fn crates(&self) -> Vec<ast::CrateNum>
 432     {
 433         let mut result = vec![];
 434         self.iter_crate_data(|cnum, _| result.push(cnum));
 435         result
 436     }
 437
 438     fn used_libraries(&self) -> Vec<(String, NativeLibraryKind)>
 439     {
 440         self.get_used_libraries().borrow().clone()
 441     }
 442
 443     fn used_link_args(&self) -> Vec<String>
 444     {
 445         self.get_used_link_args().borrow().clone()
 446     }
 447
 448     fn metadata_filename(&self) -> &str
 449     {
 450         loader::METADATA_FILENAME
 451     }
 452
 453     fn metadata_section_name(&self, target: &Target) -> &str
 454     {
 455         loader::meta_section_name(target)
 456     }
 457     fn encode_type(&self, tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Vec<u8>
 458     {
 459         encoder::encoded_ty(tcx, ty)
 460     }
 461
 462     fn used_crates(&self, prefer: LinkagePreference) -> Vec<(ast::CrateNum, Option<PathBuf>)>
 463     {
 464         self.do_get_used_crates(prefer)
 465     }
 466
 467     fn used_crate_source(&self, cnum: ast::CrateNum) -> CrateSource
 468     {
 469         self.opt_used_crate_source(cnum).unwrap()
 470     }
 471
 472     fn extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option<ast::CrateNum>
 473     {
 474         self.do_extern_mod_stmt_cnum(emod_id)
 475     }
 476
 477     fn encode_metadata(&self,
 478                        tcx: &ty::ctxt<'tcx>,
 479                        reexports: &def::ExportMap,
 480                        item_symbols: &RefCell<NodeMap<String>>,
 481                        link_meta: &LinkMeta,
 482                        reachable: &NodeSet,
 483                        mir_map: &NodeMap<Mir<'tcx>>,
 484                        krate: &hir::Crate) -> Vec<u8>
 485     {
 486         let encode_inlined_item: encoder::EncodeInlinedItem =
 487             Box::new(|ecx, rbml_w, ii| astencode::encode_inlined_item(ecx, rbml_w, ii));
 488
 489         let encode_params = encoder::EncodeParams {
 490             diag: tcx.sess.diagnostic(),
 491             tcx: tcx,
 492             reexports: reexports,
 493             item_symbols: item_symbols,
 494             link_meta: link_meta,
 495             cstore: self,
 496             encode_inlined_item: encode_inlined_item,
 497             reachable: reachable,
 498             mir_map: mir_map,
 499         };
 500         encoder::encode_metadata(encode_params, krate)
 501
 502     }
 503
 504     fn metadata_encoding_version(&self) -> &[u8]
 505     {
 506         encoder::metadata_encoding_version
 507     }
 508 }