use cstore;
use encoder;
-use locator;
use schema;
use rustc::dep_graph::DepTrackingMapConfig;
use rustc::middle::cstore::{CrateStore, CrateSource, LibSource, DepKind,
- ExternCrate, NativeLibrary, LinkMeta,
+ ExternCrate, NativeLibrary, MetadataLoader, LinkMeta,
LinkagePreference, LoadedMacro, EncodedMetadata};
use rustc::hir::def;
+use rustc::ich;
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::dep_graph::{DepNode, GlobalMetaDataKind};
use rustc::hir::map::{DefKey, DefPath, DisambiguatedDefPathData};
use rustc::util::nodemap::{NodeSet, DefIdMap};
use rustc_back::PanicStrategy;
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>) {
def_span => { cdata.get_span(def_id.index, &tcx.sess) }
stability => { cdata.get_stability(def_id.index) }
deprecation => { cdata.get_deprecation(def_id.index) }
- item_body_nested_bodies => {
- let map: BTreeMap<_, _> = cdata.entry(def_id.index).ast.into_iter().flat_map(|ast| {
- ast.decode(cdata).nested_bodies.decode(cdata).map(|body| (body.id(), body))
- }).collect();
-
- Rc::new(map)
- }
+ item_attrs => { cdata.get_item_attrs(def_id.index, &tcx.dep_graph) }
+ // 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.
+ fn_arg_names => { cdata.get_fn_arg_names(def_id.index) }
+ impl_parent => { cdata.get_parent_impl(def_id.index) }
+ trait_of_item => { cdata.get_trait_of_item(def_id.index) }
+ is_exported_symbol => {
+ let dep_node = cdata.metadata_dep_node(GlobalMetaDataKind::ExportedSymbols);
+ cdata.exported_symbols.get(&tcx.dep_graph, dep_node).contains(&def_id.index)
+ }
+ item_body_nested_bodies => { Rc::new(cdata.item_body_nested_bodies(def_id.index)) }
const_is_rvalue_promotable_to_static => {
- cdata.entry(def_id.index).ast.expect("const item missing `ast`")
- .decode(cdata).rvalue_promotable_to_static
- }
- is_mir_available => {
- !cdata.is_proc_macro(def_id.index) &&
- cdata.maybe_entry(def_id.index).and_then(|item| item.decode(cdata).mir).is_some()
+ cdata.const_is_rvalue_promotable_to_static(def_id.index)
}
+ is_mir_available => { cdata.is_item_mir_available(def_id.index) }
}
impl CrateStore for cstore::CStore {
self.get_crate_data(krate)
}
+ fn metadata_loader(&self) -> &MetadataLoader {
+ &*self.metadata_loader
+ }
+
fn visibility(&self, def: DefId) -> ty::Visibility {
self.dep_graph.read(DepNode::MetaData(def));
self.get_crate_data(def.krate).get_visibility(def.index)
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<ast::Name>
- {
- // 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<DefId>) -> Vec<DefId>
{
- 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)
+ cdata.get_implementations_for_trait(filter, &self.dep_graph, &mut result)
});
result
}
self.get_crate_data(def.krate).get_impl_defaultness(def.index)
}
- fn impl_parent(&self, impl_def: DefId) -> Option<DefId> {
- 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<DefId> {
- 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(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)
+ self.get_crate_data(def_id.krate)
+ .is_dllimport_foreign_item(def_id.index, &self.dep_graph)
}
}
fn dylib_dependency_formats(&self, cnum: CrateNum)
-> Vec<(CrateNum, LinkagePreference)>
{
- self.get_crate_data(cnum).get_dylib_dependency_formats()
+ self.get_crate_data(cnum).get_dylib_dependency_formats(&self.dep_graph)
}
fn dep_kind(&self, cnum: CrateNum) -> DepKind
{
- self.get_crate_data(cnum).dep_kind.get()
+ let data = self.get_crate_data(cnum);
+ let dep_node = data.metadata_dep_node(GlobalMetaDataKind::CrateDeps);
+ self.dep_graph.read(dep_node);
+ data.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)
+ let data = self.get_crate_data(cnum);
+ let dep_node = data.metadata_dep_node(GlobalMetaDataKind::CrateDeps);
+
+ self.dep_graph.read(dep_node);
+ if data.dep_kind.get() == DepKind::UnexportedMacrosOnly {
+ data.dep_kind.set(DepKind::MacrosOnly)
}
}
fn lang_items(&self, cnum: CrateNum) -> Vec<(DefIndex, usize)>
{
- self.get_crate_data(cnum).get_lang_items()
+ self.get_crate_data(cnum).get_lang_items(&self.dep_graph)
}
fn missing_lang_items(&self, cnum: CrateNum)
-> Vec<lang_items::LangItem>
{
- 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()
+ self.get_crate_data(cnum).get_missing_lang_items(&self.dep_graph)
}
fn is_allocator(&self, cnum: CrateNum) -> bool
{
- self.get_crate_data(cnum).is_allocator()
+ self.get_crate_data(cnum).is_allocator(&self.dep_graph)
}
fn is_panic_runtime(&self, cnum: CrateNum) -> bool
{
- self.get_crate_data(cnum).is_panic_runtime()
+ self.get_crate_data(cnum).is_panic_runtime(&self.dep_graph)
}
fn is_compiler_builtins(&self, cnum: CrateNum) -> bool {
- self.get_crate_data(cnum).is_compiler_builtins()
+ self.get_crate_data(cnum).is_compiler_builtins(&self.dep_graph)
}
fn is_sanitizer_runtime(&self, cnum: CrateNum) -> bool {
- self.get_crate_data(cnum).is_sanitizer_runtime()
+ self.get_crate_data(cnum).is_sanitizer_runtime(&self.dep_graph)
}
fn panic_strategy(&self, cnum: CrateNum) -> PanicStrategy {
- self.get_crate_data(cnum).panic_strategy()
+ self.get_crate_data(cnum).panic_strategy(&self.dep_graph)
}
fn crate_name(&self, cnum: CrateNum) -> Symbol
fn native_libraries(&self, cnum: CrateNum) -> Vec<NativeLibrary>
{
- self.get_crate_data(cnum).get_native_libraries()
+ self.get_crate_data(cnum).get_native_libraries(&self.dep_graph)
}
fn exported_symbols(&self, cnum: CrateNum) -> Vec<DefId>
{
- self.get_crate_data(cnum).get_exported_symbols()
+ self.get_crate_data(cnum).get_exported_symbols(&self.dep_graph)
}
fn is_no_builtins(&self, cnum: CrateNum) -> bool {
- self.get_crate_data(cnum).is_no_builtins()
+ self.get_crate_data(cnum).is_no_builtins(&self.dep_graph)
}
fn retrace_path(&self,
self.get_crate_data(def.krate).def_path(def.index)
}
- fn def_path_hash(&self, def: DefId) -> u64 {
+ fn def_path_hash(&self, def: DefId) -> ich::Fingerprint {
self.get_crate_data(def.krate).def_path_hash(def.index)
}
let body = filemap_to_stream(&sess.parse_sess, filemap);
// Mark the attrs as used
- let attrs = data.get_item_attrs(id.index);
+ let attrs = data.get_item_attrs(id.index, &self.dep_graph);
for attr in attrs.iter() {
attr::mark_used(attr);
}
{
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)
reachable: &NodeSet)
-> EncodedMetadata
{
- encoder::encode_metadata(tcx, self, link_meta, reachable)
+ encoder::encode_metadata(tcx, link_meta, reachable)
}
fn metadata_encoding_version(&self) -> &[u8]
drop(visible_parent_map);
self.visible_parent_map.borrow()
}
-}
+}
\ No newline at end of file
projects / rust.git / blobdiff