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_fn(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool
 264     {
 265         let cdata = self.get_crate_data(did.krate);
 266         decoder::is_extern_fn(&*cdata, did.index, tcx)
 267     }
 268
 269     fn is_static(&self, did: DefId) -> bool
 270     {
 271         let cdata = self.get_crate_data(did.krate);
 272         decoder::is_static(&*cdata, did.index)
 273     }
 274
 275     fn is_static_method(&self, def: DefId) -> bool
 276     {
 277         let cdata = self.get_crate_data(def.krate);
 278         decoder::is_static_method(&*cdata, def.index)
 279     }
 280
 281     fn is_statically_included_foreign_item(&self, id: ast::NodeId) -> bool
 282     {
 283         self.do_is_statically_included_foreign_item(id)
 284     }
 285
 286     fn is_typedef(&self, did: DefId) -> bool {
 287         let cdata = self.get_crate_data(did.krate);
 288         decoder::is_typedef(&*cdata, did.index)
 289     }
 290
 291     fn dylib_dependency_formats(&self, cnum: ast::CrateNum)
 292                                 -> Vec<(ast::CrateNum, LinkagePreference)>
 293     {
 294         let cdata = self.get_crate_data(cnum);
 295         decoder::get_dylib_dependency_formats(&cdata)
 296     }
 297
 298     fn lang_items(&self, cnum: ast::CrateNum) -> Vec<(DefIndex, usize)>
 299     {
 300         let mut result = vec![];
 301         let crate_data = self.get_crate_data(cnum);
 302         decoder::each_lang_item(&*crate_data, |did, lid| {
 303             result.push((did, lid)); true
 304         });
 305         result
 306     }
 307
 308     fn missing_lang_items(&self, cnum: ast::CrateNum)
 309                           -> Vec<lang_items::LangItem>
 310     {
 311         let cdata = self.get_crate_data(cnum);
 312         decoder::get_missing_lang_items(&*cdata)
 313     }
 314
 315     fn is_staged_api(&self, cnum: ast::CrateNum) -> bool
 316     {
 317         self.get_crate_data(cnum).staged_api
 318     }
 319
 320     fn is_explicitly_linked(&self, cnum: ast::CrateNum) -> bool
 321     {
 322         self.get_crate_data(cnum).explicitly_linked.get()
 323     }
 324
 325     fn is_allocator(&self, cnum: ast::CrateNum) -> bool
 326     {
 327         self.get_crate_data(cnum).is_allocator()
 328     }
 329
 330     fn crate_attrs(&self, cnum: ast::CrateNum) -> Vec<ast::Attribute>
 331     {
 332         decoder::get_crate_attributes(self.get_crate_data(cnum).data())
 333     }
 334
 335     fn crate_name(&self, cnum: ast::CrateNum) -> String
 336     {
 337         self.get_crate_data(cnum).name.clone()
 338     }
 339
 340     fn crate_hash(&self, cnum: ast::CrateNum) -> Svh
 341     {
 342         let cdata = self.get_crate_data(cnum);
 343         decoder::get_crate_hash(cdata.data())
 344     }
 345
 346     fn crate_struct_field_attrs(&self, cnum: ast::CrateNum)
 347                                 -> FnvHashMap<DefId, Vec<ast::Attribute>>
 348     {
 349         decoder::get_struct_field_attrs(&*self.get_crate_data(cnum))
 350     }
 351
 352     fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option<DefId>
 353     {
 354         let cdata = self.get_crate_data(cnum);
 355         decoder::get_plugin_registrar_fn(cdata.data()).map(|index| DefId {
 356             krate: cnum,
 357             index: index
 358         })
 359     }
 360
 361     fn native_libraries(&self, cnum: ast::CrateNum) -> Vec<(NativeLibraryKind, String)>
 362     {
 363         let cdata = self.get_crate_data(cnum);
 364         decoder::get_native_libraries(&*cdata)
 365     }
 366
 367     fn reachable_ids(&self, cnum: ast::CrateNum) -> Vec<DefId>
 368     {
 369         let cdata = self.get_crate_data(cnum);
 370         decoder::get_reachable_ids(&*cdata)
 371     }
 372
 373     fn def_path(&self, def: DefId) -> hir_map::DefPath
 374     {
 375         let cdata = self.get_crate_data(def.krate);
 376         let path = decoder::def_path(&*cdata, def.index);
 377         let local_path = cdata.local_def_path();
 378         local_path.into_iter().chain(path).collect()
 379     }
 380
 381     fn variant_kind(&self, def_id: DefId) -> Option<VariantKind> {
 382         let cdata = self.get_crate_data(def_id.krate);
 383         decoder::get_variant_kind(&cdata, def_id.index)
 384     }
 385
 386     fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>
 387     {
 388         let cdata = self.get_crate_data(struct_def_id.krate);
 389         decoder::get_struct_ctor_def_id(&cdata, struct_def_id.index)
 390     }
 391
 392     fn tuple_struct_definition_if_ctor(&self, did: DefId) -> Option<DefId>
 393     {
 394         let cdata = self.get_crate_data(did.krate);
 395         decoder::get_tuple_struct_definition_if_ctor(&*cdata, did.index)
 396     }
 397
 398     fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
 399     {
 400         let cdata = self.get_crate_data(def.krate);
 401         decoder::get_struct_field_names(&self.intr, &*cdata, def.index)
 402     }
 403
 404     fn item_children(&self, def_id: DefId) -> Vec<ChildItem>
 405     {
 406         let mut result = vec![];
 407         let crate_data = self.get_crate_data(def_id.krate);
 408         let get_crate_data = |cnum| self.get_crate_data(cnum);
 409         decoder::each_child_of_item(
 410             self.intr.clone(), &*crate_data,
 411             def_id.index, get_crate_data,
 412             |def, name, vis| result.push(ChildItem {
 413                 def: def,
 414                 name: name,
 415                 vis: vis
 416             }));
 417         result
 418     }
 419
 420     fn crate_top_level_items(&self, cnum: ast::CrateNum) -> Vec<ChildItem>
 421     {
 422         let mut result = vec![];
 423         let crate_data = self.get_crate_data(cnum);
 424         let get_crate_data = |cnum| self.get_crate_data(cnum);
 425         decoder::each_top_level_item_of_crate(
 426             self.intr.clone(), &*crate_data, get_crate_data,
 427             |def, name, vis| result.push(ChildItem {
 428                 def: def,
 429                 name: name,
 430                 vis: vis
 431             }));
 432         result
 433     }
 434
 435     fn maybe_get_item_ast(&'tcx self, tcx: &ty::ctxt<'tcx>, def: DefId)
 436                           -> FoundAst<'tcx>
 437     {
 438         let cdata = self.get_crate_data(def.krate);
 439         let decode_inlined_item = Box::new(astencode::decode_inlined_item);
 440         decoder::maybe_get_item_ast(&*cdata, tcx, def.index, decode_inlined_item)
 441     }
 442
 443     fn maybe_get_item_mir(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
 444                           -> Option<Mir<'tcx>> {
 445         let cdata = self.get_crate_data(def.krate);
 446         decoder::maybe_get_item_mir(&*cdata, tcx, def.index)
 447     }
 448
 449     fn is_item_mir_available(&self, def: DefId) -> bool {
 450         let cdata = self.get_crate_data(def.krate);
 451         decoder::is_item_mir_available(&*cdata, def.index)
 452     }
 453
 454     fn crates(&self) -> Vec<ast::CrateNum>
 455     {
 456         let mut result = vec![];
 457         self.iter_crate_data(|cnum, _| result.push(cnum));
 458         result
 459     }
 460
 461     fn used_libraries(&self) -> Vec<(String, NativeLibraryKind)>
 462     {
 463         self.get_used_libraries().borrow().clone()
 464     }
 465
 466     fn used_link_args(&self) -> Vec<String>
 467     {
 468         self.get_used_link_args().borrow().clone()
 469     }
 470
 471     fn metadata_filename(&self) -> &str
 472     {
 473         loader::METADATA_FILENAME
 474     }
 475
 476     fn metadata_section_name(&self, target: &Target) -> &str
 477     {
 478         loader::meta_section_name(target)
 479     }
 480     fn encode_type(&self, tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Vec<u8>
 481     {
 482         encoder::encoded_ty(tcx, ty)
 483     }
 484
 485     fn used_crates(&self, prefer: LinkagePreference) -> Vec<(ast::CrateNum, Option<PathBuf>)>
 486     {
 487         self.do_get_used_crates(prefer)
 488     }
 489
 490     fn used_crate_source(&self, cnum: ast::CrateNum) -> CrateSource
 491     {
 492         self.opt_used_crate_source(cnum).unwrap()
 493     }
 494
 495     fn extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option<ast::CrateNum>
 496     {
 497         self.do_extern_mod_stmt_cnum(emod_id)
 498     }
 499
 500     fn encode_metadata(&self,
 501                        tcx: &ty::ctxt<'tcx>,
 502                        reexports: &def::ExportMap,
 503                        item_symbols: &RefCell<NodeMap<String>>,
 504                        link_meta: &LinkMeta,
 505                        reachable: &NodeSet,
 506                        mir_map: &MirMap<'tcx>,
 507                        krate: &hir::Crate) -> Vec<u8>
 508     {
 509         let encode_inlined_item: encoder::EncodeInlinedItem =
 510             Box::new(|ecx, rbml_w, ii| astencode::encode_inlined_item(ecx, rbml_w, ii));
 511
 512         let encode_params = encoder::EncodeParams {
 513             diag: tcx.sess.diagnostic(),
 514             tcx: tcx,
 515             reexports: reexports,
 516             item_symbols: item_symbols,
 517             link_meta: link_meta,
 518             cstore: self,
 519             encode_inlined_item: encode_inlined_item,
 520             reachable: reachable,
 521             mir_map: mir_map,
 522         };
 523         encoder::encode_metadata(encode_params, krate)
 524
 525     }
 526
 527     fn metadata_encoding_version(&self) -> &[u8]
 528     {
 529         encoder::metadata_encoding_version
 530     }
 531 }