// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use cstore; use encoder; use locator; use schema; use rustc::dep_graph::DepTrackingMapConfig; use rustc::middle::cstore::{CrateStore, CrateSource, LibSource, DepKind, ExternCrate, NativeLibrary, LinkMeta, LinkagePreference, LoadedMacro, EncodedMetadata}; use rustc::hir::def::{self, Def}; use rustc::middle::lang_items; use rustc::session::Session; use rustc::ty::{self, TyCtxt}; use rustc::ty::maps::Providers; use rustc::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE}; use rustc::dep_graph::DepNode; use rustc::hir::map::{DefKey, DefPath, DisambiguatedDefPathData}; use rustc::util::nodemap::{NodeSet, DefIdMap}; use rustc_back::PanicStrategy; use std::any::Any; use std::mem; use std::rc::Rc; use syntax::ast; use syntax::attr; use syntax::parse::filemap_to_stream; use syntax::symbol::Symbol; use syntax_pos::{Span, NO_EXPANSION}; use rustc::hir::svh::Svh; use rustc_back::target::Target; use rustc::hir; use std::collections::BTreeMap; macro_rules! provide { (<$lt:tt> $tcx:ident, $def_id:ident, $cdata:ident $($name:ident => $compute:block)*) => { pub fn provide<$lt>(providers: &mut Providers<$lt>) { $(fn $name<'a, $lt:$lt>($tcx: TyCtxt<'a, $lt, $lt>, $def_id: DefId) -> as DepTrackingMapConfig>::Value { assert!(!$def_id.is_local()); $tcx.dep_graph.read(DepNode::MetaData($def_id)); let $cdata = $tcx.sess.cstore.crate_data_as_rc_any($def_id.krate); let $cdata = $cdata.downcast_ref::() .expect("CrateStore crated ata is not a CrateMetadata"); $compute })* *providers = Providers { $($name,)* ..*providers }; } } } provide! { <'tcx> tcx, def_id, cdata ty => { cdata.get_type(def_id.index, tcx) } generics => { tcx.alloc_generics(cdata.get_generics(def_id.index)) } predicates => { cdata.get_predicates(def_id.index, tcx) } super_predicates => { cdata.get_super_predicates(def_id.index, tcx) } trait_def => { tcx.alloc_trait_def(cdata.get_trait_def(def_id.index)) } adt_def => { cdata.get_adt_def(def_id.index, tcx) } adt_destructor => { let _ = cdata; tcx.calculate_dtor(def_id, &mut |_,_| Ok(())) } variances => { Rc::new(cdata.get_item_variances(def_id.index)) } associated_item_def_ids => { let mut result = vec![]; cdata.each_child_of_item(def_id.index, |child| result.push(child.def.def_id())); Rc::new(result) } associated_item => { cdata.get_associated_item(def_id.index) } impl_trait_ref => { cdata.get_impl_trait(def_id.index, tcx) } impl_polarity => { cdata.get_impl_polarity(def_id.index) } coerce_unsized_info => { cdata.get_coerce_unsized_info(def_id.index).unwrap_or_else(|| { bug!("coerce_unsized_info: `{:?}` is missing its info", def_id); }) } mir => { let mir = cdata.maybe_get_item_mir(tcx, def_id.index).unwrap_or_else(|| { bug!("get_item_mir: missing MIR for `{:?}`", def_id) }); let mir = tcx.alloc_mir(mir); // Perma-borrow MIR from extern crates to prevent mutation. mem::forget(mir.borrow()); mir } mir_const_qualif => { cdata.mir_const_qualif(def_id.index) } typeck_tables => { cdata.item_body_tables(def_id.index, tcx) } closure_kind => { cdata.closure_kind(def_id.index) } closure_type => { cdata.closure_ty(def_id.index, tcx) } inherent_impls => { Rc::new(cdata.get_inherent_implementations_for_type(def_id.index)) } is_foreign_item => { cdata.is_foreign_item(def_id.index) } } impl CrateStore for cstore::CStore { fn crate_data_as_rc_any(&self, krate: CrateNum) -> Rc { self.get_crate_data(krate) } fn describe_def(&self, def: DefId) -> Option { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).get_def(def.index) } fn def_span(&self, sess: &Session, def: DefId) -> Span { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).get_span(def.index, sess) } fn stability(&self, def: DefId) -> Option { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).get_stability(def.index) } fn deprecation(&self, def: DefId) -> Option { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).get_deprecation(def.index) } fn visibility(&self, def: DefId) -> ty::Visibility { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).get_visibility(def.index) } fn item_generics_cloned(&self, def: DefId) -> ty::Generics { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).get_generics(def.index) } fn item_attrs(&self, def_id: DefId) -> Rc<[ast::Attribute]> { self.dep_graph.read(DepNode::MetaData(def_id)); self.get_crate_data(def_id.krate).get_item_attrs(def_id.index) } fn fn_arg_names(&self, did: DefId) -> Vec { // FIXME(#38501) We've skipped a `read` on the `HirBody` of // a `fn` when encoding, so the dep-tracking wouldn't work. // This is only used by rustdoc anyway, which shouldn't have // incremental recompilation ever enabled. assert!(!self.dep_graph.is_fully_enabled()); self.get_crate_data(did.krate).get_fn_arg_names(did.index) } fn implementations_of_trait(&self, filter: Option) -> Vec { if let Some(def_id) = filter { self.dep_graph.read(DepNode::MetaData(def_id)); } let mut result = vec![]; self.iter_crate_data(|_, cdata| { cdata.get_implementations_for_trait(filter, &mut result) }); result } fn impl_parent(&self, impl_def: DefId) -> Option { self.dep_graph.read(DepNode::MetaData(impl_def)); self.get_crate_data(impl_def.krate).get_parent_impl(impl_def.index) } fn trait_of_item(&self, def_id: DefId) -> Option { self.dep_graph.read(DepNode::MetaData(def_id)); self.get_crate_data(def_id.krate).get_trait_of_item(def_id.index) } fn associated_item_cloned(&self, def: DefId) -> ty::AssociatedItem { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).get_associated_item(def.index) } fn is_const_fn(&self, did: DefId) -> bool { self.dep_graph.read(DepNode::MetaData(did)); self.get_crate_data(did.krate).is_const_fn(did.index) } fn is_default_impl(&self, impl_did: DefId) -> bool { self.dep_graph.read(DepNode::MetaData(impl_did)); self.get_crate_data(impl_did.krate).is_default_impl(impl_did.index) } fn is_foreign_item(&self, did: DefId) -> bool { self.get_crate_data(did.krate).is_foreign_item(did.index) } fn is_statically_included_foreign_item(&self, def_id: DefId) -> bool { self.do_is_statically_included_foreign_item(def_id) } fn is_exported_symbol(&self, def_id: DefId) -> bool { self.get_crate_data(def_id.krate).exported_symbols.contains(&def_id.index) } fn is_dllimport_foreign_item(&self, def_id: DefId) -> bool { if def_id.krate == LOCAL_CRATE { self.dllimport_foreign_items.borrow().contains(&def_id.index) } else { self.get_crate_data(def_id.krate).is_dllimport_foreign_item(def_id.index) } } fn dylib_dependency_formats(&self, cnum: CrateNum) -> Vec<(CrateNum, LinkagePreference)> { self.get_crate_data(cnum).get_dylib_dependency_formats() } fn dep_kind(&self, cnum: CrateNum) -> DepKind { self.get_crate_data(cnum).dep_kind.get() } fn export_macros(&self, cnum: CrateNum) { if self.get_crate_data(cnum).dep_kind.get() == DepKind::UnexportedMacrosOnly { self.get_crate_data(cnum).dep_kind.set(DepKind::MacrosOnly) } } fn lang_items(&self, cnum: CrateNum) -> Vec<(DefIndex, usize)> { self.get_crate_data(cnum).get_lang_items() } fn missing_lang_items(&self, cnum: CrateNum) -> Vec { self.get_crate_data(cnum).get_missing_lang_items() } fn is_staged_api(&self, cnum: CrateNum) -> bool { self.get_crate_data(cnum).is_staged_api() } fn is_allocator(&self, cnum: CrateNum) -> bool { self.get_crate_data(cnum).is_allocator() } fn is_panic_runtime(&self, cnum: CrateNum) -> bool { self.get_crate_data(cnum).is_panic_runtime() } fn is_compiler_builtins(&self, cnum: CrateNum) -> bool { self.get_crate_data(cnum).is_compiler_builtins() } fn is_sanitizer_runtime(&self, cnum: CrateNum) -> bool { self.get_crate_data(cnum).is_sanitizer_runtime() } fn panic_strategy(&self, cnum: CrateNum) -> PanicStrategy { self.get_crate_data(cnum).panic_strategy() } fn crate_name(&self, cnum: CrateNum) -> Symbol { self.get_crate_data(cnum).name } fn original_crate_name(&self, cnum: CrateNum) -> Symbol { self.get_crate_data(cnum).name() } fn extern_crate(&self, cnum: CrateNum) -> Option { self.get_crate_data(cnum).extern_crate.get() } fn crate_hash(&self, cnum: CrateNum) -> Svh { self.get_crate_hash(cnum) } fn crate_disambiguator(&self, cnum: CrateNum) -> Symbol { self.get_crate_data(cnum).disambiguator() } fn plugin_registrar_fn(&self, cnum: CrateNum) -> Option { self.get_crate_data(cnum).root.plugin_registrar_fn.map(|index| DefId { krate: cnum, index: index }) } fn derive_registrar_fn(&self, cnum: CrateNum) -> Option { self.get_crate_data(cnum).root.macro_derive_registrar.map(|index| DefId { krate: cnum, index: index }) } fn native_libraries(&self, cnum: CrateNum) -> Vec { self.get_crate_data(cnum).get_native_libraries() } fn exported_symbols(&self, cnum: CrateNum) -> Vec { self.get_crate_data(cnum).get_exported_symbols() } fn is_no_builtins(&self, cnum: CrateNum) -> bool { self.get_crate_data(cnum).is_no_builtins() } fn retrace_path(&self, cnum: CrateNum, path: &[DisambiguatedDefPathData]) -> Option { let cdata = self.get_crate_data(cnum); cdata.def_path_table .retrace_path(&path) .map(|index| DefId { krate: cnum, index: index }) } /// Returns the `DefKey` for a given `DefId`. This indicates the /// parent `DefId` as well as some idea of what kind of data the /// `DefId` refers to. fn def_key(&self, def: DefId) -> DefKey { // Note: loading the def-key (or def-path) for a def-id is not // a *read* of its metadata. This is because the def-id is // really just an interned shorthand for a def-path, which is the // canonical name for an item. // // self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).def_key(def.index) } fn def_path(&self, def: DefId) -> DefPath { // See `Note` above in `def_key()` for why this read is // commented out: // // self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).def_path(def.index) } fn def_path_hash(&self, def: DefId) -> u64 { self.get_crate_data(def.krate).def_path_hash(def.index) } fn struct_field_names(&self, def: DefId) -> Vec { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).get_struct_field_names(def.index) } fn item_children(&self, def_id: DefId) -> Vec { self.dep_graph.read(DepNode::MetaData(def_id)); let mut result = vec![]; self.get_crate_data(def_id.krate) .each_child_of_item(def_id.index, |child| result.push(child)); result } fn load_macro(&self, id: DefId, sess: &Session) -> LoadedMacro { let data = self.get_crate_data(id.krate); if let Some(ref proc_macros) = data.proc_macros { return LoadedMacro::ProcMacro(proc_macros[id.index.as_usize() - 1].1.clone()); } let (name, def) = data.get_macro(id.index); let source_name = format!("<{} macros>", name); let filemap = sess.parse_sess.codemap().new_filemap(source_name, None, def.body); let local_span = Span { lo: filemap.start_pos, hi: filemap.end_pos, ctxt: NO_EXPANSION }; let body = filemap_to_stream(&sess.parse_sess, filemap); // Mark the attrs as used let attrs = data.get_item_attrs(id.index); for attr in attrs.iter() { attr::mark_used(attr); } let name = data.def_key(id.index).disambiguated_data.data .get_opt_name().expect("no name in load_macro"); sess.imported_macro_spans.borrow_mut() .insert(local_span, (name.to_string(), data.get_span(id.index, sess))); LoadedMacro::MacroDef(ast::Item { ident: ast::Ident::with_empty_ctxt(name), id: ast::DUMMY_NODE_ID, span: local_span, attrs: attrs.iter().cloned().collect(), node: ast::ItemKind::MacroDef(body.into()), vis: ast::Visibility::Inherited, }) } fn maybe_get_item_body<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Option<&'tcx hir::Body> { if let Some(cached) = tcx.hir.get_inlined_body(def_id) { return Some(cached); } self.dep_graph.read(DepNode::MetaData(def_id)); debug!("maybe_get_item_body({}): inlining item", tcx.item_path_str(def_id)); self.get_crate_data(def_id.krate).maybe_get_item_body(tcx, def_id.index) } fn item_body_nested_bodies(&self, def: DefId) -> BTreeMap { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).item_body_nested_bodies(def.index) } fn const_is_rvalue_promotable_to_static(&self, def: DefId) -> bool { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).const_is_rvalue_promotable_to_static(def.index) } fn is_item_mir_available(&self, def: DefId) -> bool { self.dep_graph.read(DepNode::MetaData(def)); self.get_crate_data(def.krate).is_item_mir_available(def.index) } fn crates(&self) -> Vec { let mut result = vec![]; self.iter_crate_data(|cnum, _| result.push(cnum)); result } fn used_libraries(&self) -> Vec { self.get_used_libraries().borrow().clone() } fn used_link_args(&self) -> Vec { self.get_used_link_args().borrow().clone() } fn metadata_filename(&self) -> &str { locator::METADATA_FILENAME } fn metadata_section_name(&self, target: &Target) -> &str { locator::meta_section_name(target) } fn used_crates(&self, prefer: LinkagePreference) -> Vec<(CrateNum, LibSource)> { self.do_get_used_crates(prefer) } fn used_crate_source(&self, cnum: CrateNum) -> CrateSource { self.get_crate_data(cnum).source.clone() } fn extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option { self.do_extern_mod_stmt_cnum(emod_id) } fn encode_metadata<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, link_meta: &LinkMeta, reachable: &NodeSet) -> EncodedMetadata { encoder::encode_metadata(tcx, self, link_meta, reachable) } fn metadata_encoding_version(&self) -> &[u8] { schema::METADATA_HEADER } /// Returns a map from a sufficiently visible external item (i.e. an external item that is /// visible from at least one local module) to a sufficiently visible parent (considering /// modules that re-export the external item to be parents). fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap> { { let visible_parent_map = self.visible_parent_map.borrow(); if !visible_parent_map.is_empty() { return visible_parent_map; } } use std::collections::vec_deque::VecDeque; use std::collections::hash_map::Entry; let mut visible_parent_map = self.visible_parent_map.borrow_mut(); for cnum in (1 .. self.next_crate_num().as_usize()).map(CrateNum::new) { let cdata = self.get_crate_data(cnum); match cdata.extern_crate.get() { // Ignore crates without a corresponding local `extern crate` item. Some(extern_crate) if !extern_crate.direct => continue, _ => {}, } let mut bfs_queue = &mut VecDeque::new(); let mut add_child = |bfs_queue: &mut VecDeque<_>, child: def::Export, parent: DefId| { let child = child.def.def_id(); if self.visibility(child) != ty::Visibility::Public { return; } match visible_parent_map.entry(child) { Entry::Occupied(mut entry) => { // If `child` is defined in crate `cnum`, ensure // that it is mapped to a parent in `cnum`. if child.krate == cnum && entry.get().krate != cnum { entry.insert(parent); } } Entry::Vacant(entry) => { entry.insert(parent); bfs_queue.push_back(child); } } }; bfs_queue.push_back(DefId { krate: cnum, index: CRATE_DEF_INDEX }); while let Some(def) = bfs_queue.pop_front() { for child in self.item_children(def) { add_child(bfs_queue, child, def); } } } drop(visible_parent_map); self.visible_parent_map.borrow() } }