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