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