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, VariantKind};
  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::mir::mir_map::MirMap;
  27 use rustc::util::nodemap::{FnvHashMap, NodeMap, NodeSet};
  28
  29 use std::cell::RefCell;
  30 use std::rc::Rc;
  31 use std::path::PathBuf;
  32 use syntax::ast;
  33 use syntax::attr;
  34 use syntax::parse::token;
  35 use rustc_back::svh::Svh;
  36 use rustc_back::target::Target;
  37 use rustc_front::hir;
  38
  39 impl<'tcx> CrateStore<'tcx> for cstore::CStore {
  40     fn stability(&self, def: DefId) -> Option<attr::Stability>
  41     {
  42         let cdata = self.get_crate_data(def.krate);
  43         decoder::get_stability(&*cdata, def.index)
  44     }
  45
  46     fn deprecation(&self, def: DefId) -> Option<attr::Deprecation>
  47     {
  48         let cdata = self.get_crate_data(def.krate);
  49         decoder::get_deprecation(&*cdata, def.index)
  50     }
  51
  52     fn closure_kind(&self, _tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureKind
  53     {
  54         assert!(!def_id.is_local());
  55         let cdata = self.get_crate_data(def_id.krate);
  56         decoder::closure_kind(&*cdata, def_id.index)
  57     }
  58
  59     fn closure_ty(&self, tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureTy<'tcx>
  60     {
  61         assert!(!def_id.is_local());
  62         let cdata = self.get_crate_data(def_id.krate);
  63         decoder::closure_ty(&*cdata, def_id.index, tcx)
  64     }
  65
  66     fn item_variances(&self, def: DefId) -> ty::ItemVariances {
  67         let cdata = self.get_crate_data(def.krate);
  68         decoder::get_item_variances(&*cdata, def.index)
  69     }
  70
  71     fn repr_attrs(&self, def: DefId) -> Vec<attr::ReprAttr> {
  72         let cdata = self.get_crate_data(def.krate);
  73         decoder::get_repr_attrs(&*cdata, def.index)
  74     }
  75
  76     fn item_type(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
  77                  -> ty::TypeScheme<'tcx>
  78     {
  79         let cdata = self.get_crate_data(def.krate);
  80         decoder::get_type(&*cdata, def.index, tcx)
  81     }
  82
  83     fn item_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_predicates(&*cdata, def.index, tcx)
  88     }
  89
  90     fn item_super_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
  91                              -> ty::GenericPredicates<'tcx>
  92     {
  93         let cdata = self.get_crate_data(def.krate);
  94         decoder::get_super_predicates(&*cdata, def.index, tcx)
  95     }
  96
  97     fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute>
  98     {
  99         let cdata = self.get_crate_data(def_id.krate);
 100         decoder::get_item_attrs(&*cdata, def_id.index)
 101     }
 102
 103     fn item_symbol(&self, def: DefId) -> String
 104     {
 105         let cdata = self.get_crate_data(def.krate);
 106         decoder::get_symbol(&cdata, def.index)
 107     }
 108
 109     fn trait_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx>
 110     {
 111         let cdata = self.get_crate_data(def.krate);
 112         decoder::get_trait_def(&*cdata, def.index, tcx)
 113     }
 114
 115     fn adt_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx>
 116     {
 117         let cdata = self.get_crate_data(def.krate);
 118         decoder::get_adt_def(&self.intr, &*cdata, def.index, tcx)
 119     }
 120
 121     fn method_arg_names(&self, did: DefId) -> Vec<String>
 122     {
 123         let cdata = self.get_crate_data(did.krate);
 124         decoder::get_method_arg_names(&cdata, did.index)
 125     }
 126
 127     fn item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
 128         let cdata = self.get_crate_data(def.krate);
 129         let path = decoder::get_item_path(&*cdata, def.index);
 130
 131         cdata.with_local_path(|cpath| {
 132             let mut r = Vec::with_capacity(cpath.len() + path.len());
 133             r.extend_from_slice(cpath);
 134             r.extend_from_slice(&path);
 135             r
 136         })
 137     }
 138
 139     fn extern_item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
 140         let cdata = self.get_crate_data(def.krate);
 141         let path = decoder::get_item_path(&*cdata, def.index);
 142
 143         let mut r = Vec::with_capacity(path.len() + 1);
 144         let crate_name = hir_map::PathMod(token::intern(&cdata.name));
 145         r.push(crate_name);
 146         r.extend_from_slice(&path);
 147         r
 148     }
 149
 150     fn item_name(&self, def: DefId) -> ast::Name {
 151         let cdata = self.get_crate_data(def.krate);
 152         decoder::get_item_name(&self.intr, &cdata, def.index)
 153     }
 154
 155
 156     fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId>
 157     {
 158         let mut result = vec![];
 159         let cdata = self.get_crate_data(def_id.krate);
 160         decoder::each_inherent_implementation_for_type(&*cdata, def_id.index,
 161                                                        |iid| result.push(iid));
 162         result
 163     }
 164
 165     fn implementations_of_trait(&self, def_id: DefId) -> Vec<DefId>
 166     {
 167         let mut result = vec![];
 168         self.iter_crate_data(|_, cdata| {
 169             decoder::each_implementation_for_trait(cdata, def_id, &mut |iid| {
 170                 result.push(iid)
 171             })
 172         });
 173         result
 174     }
 175
 176     fn provided_trait_methods(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 177                               -> Vec<Rc<ty::Method<'tcx>>>
 178     {
 179         let cdata = self.get_crate_data(def.krate);
 180         decoder::get_provided_trait_methods(self.intr.clone(), &*cdata, def.index, tcx)
 181     }
 182
 183     fn trait_item_def_ids(&self, def: DefId)
 184                           -> Vec<ty::ImplOrTraitItemId>
 185     {
 186         let cdata = self.get_crate_data(def.krate);
 187         decoder::get_trait_item_def_ids(&*cdata, def.index)
 188     }
 189
 190     fn impl_items(&self, impl_def_id: DefId) -> Vec<ty::ImplOrTraitItemId>
 191     {
 192         let cdata = self.get_crate_data(impl_def_id.krate);
 193         decoder::get_impl_items(&*cdata, impl_def_id.index)
 194     }
 195
 196     fn impl_polarity(&self, def: DefId) -> Option<hir::ImplPolarity>
 197     {
 198         let cdata = self.get_crate_data(def.krate);
 199         decoder::get_impl_polarity(&*cdata, def.index)
 200     }
 201
 202     fn impl_trait_ref(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 203                       -> Option<ty::TraitRef<'tcx>>
 204     {
 205         let cdata = self.get_crate_data(def.krate);
 206         decoder::get_impl_trait(&*cdata, def.index, tcx)
 207     }
 208
 209     fn custom_coerce_unsized_kind(&self, def: DefId)
 210                                   -> Option<ty::adjustment::CustomCoerceUnsized>
 211     {
 212         let cdata = self.get_crate_data(def.krate);
 213         decoder::get_custom_coerce_unsized_kind(&*cdata, def.index)
 214     }
 215
 216     // FIXME: killme
 217     fn associated_consts(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 218                          -> Vec<Rc<ty::AssociatedConst<'tcx>>> {
 219         let cdata = self.get_crate_data(def.krate);
 220         decoder::get_associated_consts(self.intr.clone(), &*cdata, def.index, tcx)
 221     }
 222
 223     fn trait_of_item(&self, tcx: &ty::ctxt<'tcx>, def_id: DefId) -> Option<DefId>
 224     {
 225         let cdata = self.get_crate_data(def_id.krate);
 226         decoder::get_trait_of_item(&*cdata, def_id.index, tcx)
 227     }
 228
 229     fn impl_or_trait_item(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 230                           -> ty::ImplOrTraitItem<'tcx>
 231     {
 232         let cdata = self.get_crate_data(def.krate);
 233         decoder::get_impl_or_trait_item(
 234             self.intr.clone(),
 235             &*cdata,
 236             def.index,
 237             tcx)
 238     }
 239
 240     fn is_const_fn(&self, did: DefId) -> bool
 241     {
 242         let cdata = self.get_crate_data(did.krate);
 243         decoder::is_const_fn(&cdata, did.index)
 244     }
 245
 246     fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool
 247     {
 248         let cdata = self.get_crate_data(trait_def_id.krate);
 249         decoder::is_defaulted_trait(&*cdata, trait_def_id.index)
 250     }
 251
 252     fn is_impl(&self, did: DefId) -> bool
 253     {
 254         let cdata = self.get_crate_data(did.krate);
 255         decoder::is_impl(&*cdata, did.index)
 256     }
 257
 258     fn is_default_impl(&self, impl_did: DefId) -> bool {
 259         let cdata = self.get_crate_data(impl_did.krate);
 260         decoder::is_default_impl(&*cdata, impl_did.index)
 261     }
 262
 263     fn is_extern_item(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool {
 264         let cdata = self.get_crate_data(did.krate);
 265         decoder::is_extern_item(&*cdata, did.index, tcx)
 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 variant_kind(&self, def_id: DefId) -> Option<VariantKind> {
 375         let cdata = self.get_crate_data(def_id.krate);
 376         decoder::get_variant_kind(&cdata, def_id.index)
 377     }
 378
 379     fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>
 380     {
 381         let cdata = self.get_crate_data(struct_def_id.krate);
 382         decoder::get_struct_ctor_def_id(&cdata, struct_def_id.index)
 383     }
 384
 385     fn tuple_struct_definition_if_ctor(&self, did: DefId) -> Option<DefId>
 386     {
 387         let cdata = self.get_crate_data(did.krate);
 388         decoder::get_tuple_struct_definition_if_ctor(&*cdata, did.index)
 389     }
 390
 391     fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
 392     {
 393         let cdata = self.get_crate_data(def.krate);
 394         decoder::get_struct_field_names(&self.intr, &*cdata, def.index)
 395     }
 396
 397     fn item_children(&self, def_id: DefId) -> Vec<ChildItem>
 398     {
 399         let mut result = vec![];
 400         let crate_data = self.get_crate_data(def_id.krate);
 401         let get_crate_data = |cnum| self.get_crate_data(cnum);
 402         decoder::each_child_of_item(
 403             self.intr.clone(), &*crate_data,
 404             def_id.index, get_crate_data,
 405             |def, name, vis| result.push(ChildItem {
 406                 def: def,
 407                 name: name,
 408                 vis: vis
 409             }));
 410         result
 411     }
 412
 413     fn crate_top_level_items(&self, cnum: ast::CrateNum) -> Vec<ChildItem>
 414     {
 415         let mut result = vec![];
 416         let crate_data = self.get_crate_data(cnum);
 417         let get_crate_data = |cnum| self.get_crate_data(cnum);
 418         decoder::each_top_level_item_of_crate(
 419             self.intr.clone(), &*crate_data, get_crate_data,
 420             |def, name, vis| result.push(ChildItem {
 421                 def: def,
 422                 name: name,
 423                 vis: vis
 424             }));
 425         result
 426     }
 427
 428     fn maybe_get_item_ast(&'tcx self, tcx: &ty::ctxt<'tcx>, def: DefId)
 429                           -> FoundAst<'tcx>
 430     {
 431         let cdata = self.get_crate_data(def.krate);
 432         let decode_inlined_item = Box::new(astencode::decode_inlined_item);
 433         decoder::maybe_get_item_ast(&*cdata, tcx, def.index, decode_inlined_item)
 434     }
 435
 436     fn maybe_get_item_mir(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 437                           -> Option<Mir<'tcx>> {
 438         let cdata = self.get_crate_data(def.krate);
 439         decoder::maybe_get_item_mir(&*cdata, tcx, def.index)
 440     }
 441
 442     fn is_item_mir_available(&self, def: DefId) -> bool {
 443         let cdata = self.get_crate_data(def.krate);
 444         decoder::is_item_mir_available(&*cdata, def.index)
 445     }
 446
 447     fn crates(&self) -> Vec<ast::CrateNum>
 448     {
 449         let mut result = vec![];
 450         self.iter_crate_data(|cnum, _| result.push(cnum));
 451         result
 452     }
 453
 454     fn used_libraries(&self) -> Vec<(String, NativeLibraryKind)>
 455     {
 456         self.get_used_libraries().borrow().clone()
 457     }
 458
 459     fn used_link_args(&self) -> Vec<String>
 460     {
 461         self.get_used_link_args().borrow().clone()
 462     }
 463
 464     fn metadata_filename(&self) -> &str
 465     {
 466         loader::METADATA_FILENAME
 467     }
 468
 469     fn metadata_section_name(&self, target: &Target) -> &str
 470     {
 471         loader::meta_section_name(target)
 472     }
 473     fn encode_type(&self, tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Vec<u8>
 474     {
 475         encoder::encoded_ty(tcx, ty)
 476     }
 477
 478     fn used_crates(&self, prefer: LinkagePreference) -> Vec<(ast::CrateNum, Option<PathBuf>)>
 479     {
 480         self.do_get_used_crates(prefer)
 481     }
 482
 483     fn used_crate_source(&self, cnum: ast::CrateNum) -> CrateSource
 484     {
 485         self.opt_used_crate_source(cnum).unwrap()
 486     }
 487
 488     fn extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option<ast::CrateNum>
 489     {
 490         self.do_extern_mod_stmt_cnum(emod_id)
 491     }
 492
 493     fn encode_metadata(&self,
 494                        tcx: &ty::ctxt<'tcx>,
 495                        reexports: &def::ExportMap,
 496                        item_symbols: &RefCell<NodeMap<String>>,
 497                        link_meta: &LinkMeta,
 498                        reachable: &NodeSet,
 499                        mir_map: &MirMap<'tcx>,
 500                        krate: &hir::Crate) -> Vec<u8>
 501     {
 502         let encode_inlined_item: encoder::EncodeInlinedItem =
 503             Box::new(|ecx, rbml_w, ii| astencode::encode_inlined_item(ecx, rbml_w, ii));
 504
 505         let encode_params = encoder::EncodeParams {
 506             diag: tcx.sess.diagnostic(),
 507             tcx: tcx,
 508             reexports: reexports,
 509             item_symbols: item_symbols,
 510             link_meta: link_meta,
 511             cstore: self,
 512             encode_inlined_item: encode_inlined_item,
 513             reachable: reachable,
 514             mir_map: mir_map,
 515         };
 516         encoder::encode_metadata(encode_params, krate)
 517
 518     }
 519
 520     fn metadata_encoding_version(&self) -> &[u8]
 521     {
 522         encoder::metadata_encoding_version
 523     }
 524 }