use cstore;
use encoder;
-use locator;
+use link_args;
+use native_libs;
use schema;
-use rustc::middle::cstore::{InlinedItem, CrateStore, CrateSource, LibSource, DepKind, ExternCrate};
-use rustc::middle::cstore::{NativeLibrary, LinkMeta, LinkagePreference, LoadedMacro};
-use rustc::hir::def::{self, Def};
-use rustc::middle::lang_items;
-use rustc::session::Session;
-use rustc::ty::{self, Ty, TyCtxt};
-use rustc::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
-
-use rustc::dep_graph::DepNode;
-use rustc::hir::map as hir_map;
-use rustc::hir::map::DefKey;
-use rustc::mir::Mir;
+use rustc::ty::maps::QueryConfig;
+use rustc::middle::cstore::{CrateStore, DepKind,
+ MetadataLoader, LinkMeta,
+ LoadedMacro, EncodedMetadata,
+ EncodedMetadataHashes, NativeLibraryKind};
+use rustc::middle::stability::DeprecationEntry;
+use rustc::hir::def;
+use rustc::session::{CrateDisambiguator, Session};
+use rustc::ty::{self, TyCtxt};
+use rustc::ty::maps::Providers;
+use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE, CRATE_DEF_INDEX};
+use rustc::hir::map::{DefKey, DefPath, DefPathHash};
+use rustc::hir::map::blocks::FnLikeNode;
+use rustc::hir::map::definitions::DefPathTable;
use rustc::util::nodemap::{NodeSet, DefIdMap};
-use rustc_back::PanicStrategy;
+
+use std::any::Any;
+use std::rc::Rc;
use syntax::ast;
use syntax::attr;
-use syntax::parse::new_parser_from_source_str;
+use syntax::ext::base::SyntaxExtension;
+use syntax::parse::filemap_to_stream;
use syntax::symbol::Symbol;
-use syntax_pos::{mk_sp, Span};
-use rustc::hir::svh::Svh;
-use rustc_back::target::Target;
+use syntax_pos::{Span, NO_EXPANSION};
+use rustc_data_structures::indexed_set::IdxSetBuf;
use rustc::hir;
-impl<'tcx> CrateStore<'tcx> for cstore::CStore {
- fn describe_def(&self, def: DefId) -> Option<Def> {
- 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<attr::Stability> {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_stability(def.index)
- }
-
- fn deprecation(&self, def: DefId) -> Option<attr::Deprecation> {
- 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 closure_kind(&self, def_id: DefId) -> ty::ClosureKind
- {
- assert!(!def_id.is_local());
- self.dep_graph.read(DepNode::MetaData(def_id));
- self.get_crate_data(def_id.krate).closure_kind(def_id.index)
- }
-
- fn closure_ty<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> ty::ClosureTy<'tcx> {
- assert!(!def_id.is_local());
- self.dep_graph.read(DepNode::MetaData(def_id));
- self.get_crate_data(def_id.krate).closure_ty(def_id.index, tcx)
+macro_rules! provide {
+ (<$lt:tt> $tcx:ident, $def_id:ident, $other:ident, $cdata:ident,
+ $($name:ident => $compute:block)*) => {
+ pub fn provide_extern<$lt>(providers: &mut Providers<$lt>) {
+ $(fn $name<'a, $lt:$lt, T>($tcx: TyCtxt<'a, $lt, $lt>, def_id_arg: T)
+ -> <ty::queries::$name<$lt> as
+ QueryConfig>::Value
+ where T: IntoArgs,
+ {
+ #[allow(unused_variables)]
+ let ($def_id, $other) = def_id_arg.into_args();
+ assert!(!$def_id.is_local());
+
+ let def_path_hash = $tcx.def_path_hash(DefId {
+ krate: $def_id.krate,
+ index: CRATE_DEF_INDEX
+ });
+ let dep_node = def_path_hash
+ .to_dep_node(::rustc::dep_graph::DepKind::CrateMetadata);
+ // The DepNodeIndex of the DepNode::CrateMetadata should be
+ // cached somewhere, so that we can use read_index().
+ $tcx.dep_graph.read(dep_node);
+
+ let $cdata = $tcx.crate_data_as_rc_any($def_id.krate);
+ let $cdata = $cdata.downcast_ref::<cstore::CrateMetadata>()
+ .expect("CrateStore crated ata is not a CrateMetadata");
+ $compute
+ })*
+
+ *providers = Providers {
+ $($name,)*
+ ..*providers
+ };
+ }
}
+}
- fn item_variances(&self, def: DefId) -> Vec<ty::Variance> {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_item_variances(def.index)
- }
+// small trait to work around different signature queries all being defined via
+// the macro above.
+trait IntoArgs {
+ fn into_args(self) -> (DefId, DefId);
+}
- fn item_type<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
- -> Ty<'tcx>
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_type(def.index, tcx)
- }
+impl IntoArgs for DefId {
+ fn into_args(self) -> (DefId, DefId) { (self, self) }
+}
- fn item_predicates<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
- -> ty::GenericPredicates<'tcx>
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_predicates(def.index, tcx)
- }
+impl IntoArgs for CrateNum {
+ fn into_args(self) -> (DefId, DefId) { (self.as_def_id(), self.as_def_id()) }
+}
- fn item_super_predicates<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
- -> ty::GenericPredicates<'tcx>
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_super_predicates(def.index, tcx)
- }
+impl IntoArgs for (CrateNum, DefId) {
+ fn into_args(self) -> (DefId, DefId) { (self.0.as_def_id(), self.1) }
+}
- fn item_generics<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
- -> ty::Generics<'tcx>
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_generics(def.index, tcx)
+provide! { <'tcx> tcx, def_id, other, cdata,
+ type_of => { cdata.get_type(def_id.index, tcx) }
+ generics_of => {
+ tcx.alloc_generics(cdata.get_generics(def_id.index, tcx.sess))
}
-
- fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute>
- {
- self.dep_graph.read(DepNode::MetaData(def_id));
- self.get_crate_data(def_id.krate).get_item_attrs(def_id.index)
+ predicates_of => { cdata.get_predicates(def_id.index, tcx) }
+ super_predicates_of => { cdata.get_super_predicates(def_id.index, tcx) }
+ trait_def => {
+ tcx.alloc_trait_def(cdata.get_trait_def(def_id.index, tcx.sess))
}
-
- fn trait_def<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> ty::TraitDef
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_trait_def(def.index, tcx)
+ adt_def => { cdata.get_adt_def(def_id.index, tcx) }
+ adt_destructor => {
+ let _ = cdata;
+ tcx.calculate_dtor(def_id, &mut |_,_| Ok(()))
}
-
- fn adt_def<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> &'tcx ty::AdtDef
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_adt_def(def.index, tcx)
+ variances_of => { 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()), tcx.sess);
+ 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);
+ })
}
+ optimized_mir => {
+ let mir = cdata.maybe_get_optimized_mir(tcx, def_id.index).unwrap_or_else(|| {
+ bug!("get_optimized_mir: missing MIR for `{:?}`", def_id)
+ });
- fn fn_arg_names(&self, did: DefId) -> Vec<ast::Name>
- {
- self.dep_graph.read(DepNode::MetaData(did));
- self.get_crate_data(did.krate).get_fn_arg_names(did.index)
+ let mir = tcx.alloc_mir(mir);
+
+ mir
+ }
+ generator_sig => { cdata.generator_sig(def_id.index, tcx) }
+ mir_const_qualif => {
+ (cdata.mir_const_qualif(def_id.index), Rc::new(IdxSetBuf::new_empty(0)))
+ }
+ typeck_tables_of => { cdata.item_body_tables(def_id.index, tcx) }
+ closure_kind => { cdata.closure_kind(def_id.index) }
+ fn_sig => { cdata.fn_sig(def_id.index, tcx) }
+ inherent_impls => { Rc::new(cdata.get_inherent_implementations_for_type(def_id.index)) }
+ is_const_fn => { cdata.is_const_fn(def_id.index) }
+ is_foreign_item => { cdata.is_foreign_item(def_id.index) }
+ is_auto_impl => { cdata.is_auto_impl(def_id.index) }
+ describe_def => { cdata.get_def(def_id.index) }
+ def_span => { cdata.get_span(def_id.index, &tcx.sess) }
+ lookup_stability => {
+ cdata.get_stability(def_id.index).map(|s| tcx.intern_stability(s))
+ }
+ lookup_deprecation_entry => {
+ cdata.get_deprecation(def_id.index).map(DeprecationEntry::external)
+ }
+ item_attrs => { cdata.get_item_attrs(def_id.index, tcx.sess) }
+ // 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 => {
+ cdata.exported_symbols.contains(&def_id.index)
+ }
+ item_body_nested_bodies => { cdata.item_body_nested_bodies(def_id.index) }
+ const_is_rvalue_promotable_to_static => {
+ cdata.const_is_rvalue_promotable_to_static(def_id.index)
+ }
+ is_mir_available => { cdata.is_item_mir_available(def_id.index) }
+
+ dylib_dependency_formats => { Rc::new(cdata.get_dylib_dependency_formats()) }
+ is_panic_runtime => { cdata.is_panic_runtime(tcx.sess) }
+ is_compiler_builtins => { cdata.is_compiler_builtins(tcx.sess) }
+ has_global_allocator => { cdata.has_global_allocator() }
+ is_sanitizer_runtime => { cdata.is_sanitizer_runtime(tcx.sess) }
+ is_profiler_runtime => { cdata.is_profiler_runtime(tcx.sess) }
+ panic_strategy => { cdata.panic_strategy() }
+ extern_crate => { Rc::new(cdata.extern_crate.get()) }
+ is_no_builtins => { cdata.is_no_builtins(tcx.sess) }
+ impl_defaultness => { cdata.get_impl_defaultness(def_id.index) }
+ exported_symbol_ids => { Rc::new(cdata.get_exported_symbols()) }
+ native_libraries => { Rc::new(cdata.get_native_libraries(tcx.sess)) }
+ plugin_registrar_fn => {
+ cdata.root.plugin_registrar_fn.map(|index| {
+ DefId { krate: def_id.krate, index }
+ })
}
-
- fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId>
- {
- self.dep_graph.read(DepNode::MetaData(def_id));
- self.get_crate_data(def_id.krate).get_inherent_implementations_for_type(def_id.index)
+ derive_registrar_fn => {
+ cdata.root.macro_derive_registrar.map(|index| {
+ DefId { krate: def_id.krate, index }
+ })
}
+ crate_disambiguator => { cdata.disambiguator() }
+ crate_hash => { cdata.hash() }
+ original_crate_name => { cdata.name() }
- fn implementations_of_trait(&self, filter: Option<DefId>) -> Vec<DefId>
- {
- if let Some(def_id) = filter {
- self.dep_graph.read(DepNode::MetaData(def_id));
- }
+ implementations_of_trait => {
let mut result = vec![];
- self.iter_crate_data(|_, cdata| {
- cdata.get_implementations_for_trait(filter, &mut result)
- });
- result
+ let filter = Some(other);
+ cdata.get_implementations_for_trait(filter, &mut result);
+ Rc::new(result)
}
- fn associated_item_def_ids(&self, def_id: DefId) -> Vec<DefId> {
- self.dep_graph.read(DepNode::MetaData(def_id));
+ all_trait_implementations => {
let mut result = vec![];
- self.get_crate_data(def_id.krate)
- .each_child_of_item(def_id.index, |child| result.push(child.def.def_id()));
- result
+ cdata.get_implementations_for_trait(None, &mut result);
+ Rc::new(result)
}
- fn impl_polarity(&self, def: DefId) -> hir::ImplPolarity
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_impl_polarity(def.index)
- }
-
- fn impl_trait_ref<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
- -> Option<ty::TraitRef<'tcx>>
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_impl_trait(def.index, tcx)
- }
-
- fn custom_coerce_unsized_kind(&self, def: DefId)
- -> Option<ty::adjustment::CustomCoerceUnsized>
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_custom_coerce_unsized_kind(def.index)
+ is_dllimport_foreign_item => {
+ cdata.is_dllimport_foreign_item(def_id.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<'a>(&self, def: DefId) -> Option<ty::AssociatedItem>
- {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).get_associated_item(def.index)
+ visibility => { cdata.get_visibility(def_id.index) }
+ dep_kind => { cdata.dep_kind.get() }
+ crate_name => { cdata.name }
+ item_children => {
+ let mut result = vec![];
+ cdata.each_child_of_item(def_id.index, |child| result.push(child), tcx.sess);
+ Rc::new(result)
}
+ defined_lang_items => { Rc::new(cdata.get_lang_items()) }
+ missing_lang_items => { Rc::new(cdata.get_missing_lang_items()) }
- 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)
+ extern_const_body => {
+ debug!("item_body({:?}): inlining item", def_id);
+ cdata.extern_const_body(tcx, def_id.index)
}
- fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool
- {
- self.dep_graph.read(DepNode::MetaData(trait_def_id));
- self.get_crate_data(trait_def_id.krate).is_defaulted_trait(trait_def_id.index)
+ missing_extern_crate_item => {
+ match cdata.extern_crate.get() {
+ Some(extern_crate) if !extern_crate.direct => true,
+ _ => false,
+ }
}
- 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)
- }
+ used_crate_source => { Rc::new(cdata.source.clone()) }
- fn is_foreign_item(&self, did: DefId) -> bool {
- self.get_crate_data(did.krate).is_foreign_item(did.index)
- }
+ has_copy_closures => { cdata.has_copy_closures(tcx.sess) }
+ has_clone_closures => { cdata.has_clone_closures(tcx.sess) }
+}
- fn is_statically_included_foreign_item(&self, def_id: DefId) -> bool
- {
- self.do_is_statically_included_foreign_item(def_id)
- }
+pub fn provide<'tcx>(providers: &mut Providers<'tcx>) {
+ fn is_const_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> bool {
+ let node_id = tcx.hir.as_local_node_id(def_id)
+ .expect("Non-local call to local provider is_const_fn");
- 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)
+ if let Some(fn_like) = FnLikeNode::from_node(tcx.hir.get(node_id)) {
+ fn_like.constness() == hir::Constness::Const
} else {
- self.get_crate_data(def_id.krate).is_dllimport_foreign_item(def_id.index)
+ false
}
}
- fn dylib_dependency_formats(&self, cnum: CrateNum)
- -> Vec<(CrateNum, LinkagePreference)>
- {
- self.get_crate_data(cnum).get_dylib_dependency_formats()
- }
+ // FIXME(#44234) - almost all of these queries have no sub-queries and
+ // therefore no actual inputs, they're just reading tables calculated in
+ // resolve! Does this work? Unsure! That's what the issue is about
+ *providers = Providers {
+ is_const_fn,
+ is_dllimport_foreign_item: |tcx, id| {
+ tcx.native_library_kind(id) == Some(NativeLibraryKind::NativeUnknown)
+ },
+ is_statically_included_foreign_item: |tcx, id| {
+ match tcx.native_library_kind(id) {
+ Some(NativeLibraryKind::NativeStatic) |
+ Some(NativeLibraryKind::NativeStaticNobundle) => true,
+ _ => false,
+ }
+ },
+ native_library_kind: |tcx, id| {
+ tcx.native_libraries(id.krate)
+ .iter()
+ .filter(|lib| native_libs::relevant_lib(&tcx.sess, lib))
+ .find(|l| l.foreign_items.contains(&id))
+ .map(|l| l.kind)
+ },
+ native_libraries: |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ Rc::new(native_libs::collect(tcx))
+ },
+ link_args: |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ Rc::new(link_args::collect(tcx))
+ },
+
+ // 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).
+ visible_parent_map: |tcx, cnum| {
+ use std::collections::vec_deque::VecDeque;
+ use std::collections::hash_map::Entry;
+
+ assert_eq!(cnum, LOCAL_CRATE);
+ let mut visible_parent_map: DefIdMap<DefId> = DefIdMap();
+
+ // Preferring shortest paths alone does not guarantee a
+ // deterministic result; so sort by crate num to avoid
+ // hashtable iteration non-determinism. This only makes
+ // things as deterministic as crate-nums assignment is,
+ // which is to say, its not deterministic in general. But
+ // we believe that libstd is consistently assigned crate
+ // num 1, so it should be enough to resolve #46112.
+ let mut crates: Vec<CrateNum> = (*tcx.crates()).clone();
+ crates.sort();
+
+ for &cnum in crates.iter() {
+ // Ignore crates without a corresponding local `extern crate` item.
+ if tcx.missing_extern_crate_item(cnum) {
+ continue
+ }
- fn dep_kind(&self, cnum: CrateNum) -> DepKind
- {
- self.get_crate_data(cnum).dep_kind.get()
- }
+ let bfs_queue = &mut VecDeque::new();
+ let visible_parent_map = &mut visible_parent_map;
+ let mut add_child = |bfs_queue: &mut VecDeque<_>,
+ child: &def::Export,
+ parent: DefId| {
+ let child = child.def.def_id();
- 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)
- }
- }
+ if tcx.visibility(child) != ty::Visibility::Public {
+ return;
+ }
- fn lang_items(&self, cnum: CrateNum) -> Vec<(DefIndex, usize)>
- {
- self.get_crate_data(cnum).get_lang_items()
- }
+ 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 tcx.item_children(def).iter() {
+ add_child(bfs_queue, child, def);
+ }
+ }
+ }
- fn missing_lang_items(&self, cnum: CrateNum)
- -> Vec<lang_items::LangItem>
- {
- self.get_crate_data(cnum).get_missing_lang_items()
- }
+ Rc::new(visible_parent_map)
+ },
- fn is_staged_api(&self, cnum: CrateNum) -> bool
- {
- self.get_crate_data(cnum).is_staged_api()
- }
+ ..*providers
+ };
+}
- fn is_allocator(&self, cnum: CrateNum) -> bool
- {
- self.get_crate_data(cnum).is_allocator()
+impl CrateStore for cstore::CStore {
+ fn crate_data_as_rc_any(&self, krate: CrateNum) -> Rc<Any> {
+ self.get_crate_data(krate)
}
- fn is_panic_runtime(&self, cnum: CrateNum) -> bool
- {
- self.get_crate_data(cnum).is_panic_runtime()
+ fn metadata_loader(&self) -> &MetadataLoader {
+ &*self.metadata_loader
}
- fn is_compiler_builtins(&self, cnum: CrateNum) -> bool {
- self.get_crate_data(cnum).is_compiler_builtins()
+ fn visibility_untracked(&self, def: DefId) -> ty::Visibility {
+ self.get_crate_data(def.krate).get_visibility(def.index)
}
- fn panic_strategy(&self, cnum: CrateNum) -> PanicStrategy {
- self.get_crate_data(cnum).panic_strategy()
+ fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics {
+ self.get_crate_data(def.krate).get_generics(def.index, sess)
}
- fn crate_name(&self, cnum: CrateNum) -> Symbol
+ fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem
{
- self.get_crate_data(cnum).name
+ self.get_crate_data(def.krate).get_associated_item(def.index)
}
- fn original_crate_name(&self, cnum: CrateNum) -> Symbol
+ fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind
{
- self.get_crate_data(cnum).name()
+ self.get_crate_data(cnum).dep_kind.get()
}
- fn extern_crate(&self, cnum: CrateNum) -> Option<ExternCrate>
- {
- self.get_crate_data(cnum).extern_crate.get()
+ fn export_macros_untracked(&self, cnum: CrateNum) {
+ let data = self.get_crate_data(cnum);
+ if data.dep_kind.get() == DepKind::UnexportedMacrosOnly {
+ data.dep_kind.set(DepKind::MacrosOnly)
+ }
}
- fn crate_hash(&self, cnum: CrateNum) -> Svh
+ fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol
{
- self.get_crate_hash(cnum)
+ self.get_crate_data(cnum).name
}
- fn crate_disambiguator(&self, cnum: CrateNum) -> Symbol
+ fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator
{
self.get_crate_data(cnum).disambiguator()
}
- fn plugin_registrar_fn(&self, cnum: CrateNum) -> Option<DefId>
+ fn crate_hash_untracked(&self, cnum: CrateNum) -> hir::svh::Svh
{
- self.get_crate_data(cnum).root.plugin_registrar_fn.map(|index| DefId {
- krate: cnum,
- index: index
- })
- }
-
- fn derive_registrar_fn(&self, cnum: CrateNum) -> Option<DefId>
- {
- self.get_crate_data(cnum).root.macro_derive_registrar.map(|index| DefId {
- krate: cnum,
- index: index
- })
- }
-
- fn native_libraries(&self, cnum: CrateNum) -> Vec<NativeLibrary>
- {
- self.get_crate_data(cnum).get_native_libraries()
- }
-
- fn exported_symbols(&self, cnum: CrateNum) -> Vec<DefId>
- {
- 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 def_index_for_def_key(&self,
- cnum: CrateNum,
- def: DefKey)
- -> Option<DefIndex> {
- let cdata = self.get_crate_data(cnum);
- cdata.key_map.get(&def).cloned()
+ self.get_crate_data(cnum).hash()
}
/// 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) -> hir_map::DefKey {
+ 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
self.get_crate_data(def.krate).def_key(def.index)
}
- fn relative_def_path(&self, def: DefId) -> Option<hir_map::DefPath> {
+ fn def_path(&self, def: DefId) -> DefPath {
// See `Note` above in `def_key()` for why this read is
// commented out:
//
self.get_crate_data(def.krate).def_path(def.index)
}
- fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
+ fn def_path_hash(&self, def: DefId) -> DefPathHash {
+ self.get_crate_data(def.krate).def_path_hash(def.index)
+ }
+
+ fn def_path_table(&self, cnum: CrateNum) -> Rc<DefPathTable> {
+ self.get_crate_data(cnum).def_path_table.clone()
+ }
+
+ fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name>
{
- 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<def::Export>
+ fn item_children_untracked(&self, def_id: DefId, sess: &Session) -> Vec<def::Export>
{
- 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));
+ .each_child_of_item(def_id.index, |child| result.push(child), sess);
result
}
- fn load_macro(&self, id: DefId, sess: &Session) -> LoadedMacro {
+ fn load_macro_untracked(&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());
+ } else if data.name == "proc_macro" &&
+ self.get_crate_data(id.krate).item_name(id.index) == "quote" {
+ let ext = SyntaxExtension::ProcMacro(Box::new(::proc_macro::__internal::Quoter));
+ return LoadedMacro::ProcMacro(Rc::new(ext));
}
let (name, def) = data.get_macro(id.index);
let source_name = format!("<{} macros>", name);
- // NB: Don't use parse_tts_from_source_str because it parses with quote_depth > 0.
- let mut parser = new_parser_from_source_str(&sess.parse_sess, source_name, def.body);
-
- let lo = parser.span.lo;
- let body = match parser.parse_all_token_trees() {
- Ok(body) => body,
- Err(mut err) => {
- err.emit();
- sess.abort_if_errors();
- unreachable!();
- }
- };
- let local_span = mk_sp(lo, parser.prev_span.hi);
+ let filemap = sess.parse_sess.codemap().new_filemap(source_name, def.body);
+ let local_span = Span::new(filemap.start_pos, filemap.end_pos, NO_EXPANSION);
+ let body = filemap_to_stream(&sess.parse_sess, filemap, None);
// Mark the attrs as used
- let attrs = data.get_item_attrs(id.index);
- for attr in &attrs {
+ let attrs = data.get_item_attrs(id.index, sess);
+ for attr in attrs.iter() {
attr::mark_used(attr);
}
sess.imported_macro_spans.borrow_mut()
.insert(local_span, (name.to_string(), data.get_span(id.index, sess)));
- LoadedMacro::MacroRules(ast::MacroDef {
- ident: ast::Ident::with_empty_ctxt(name),
+ LoadedMacro::MacroDef(ast::Item {
+ ident: ast::Ident::from_str(&name),
id: ast::DUMMY_NODE_ID,
span: local_span,
- imported_from: None, // FIXME
- allow_internal_unstable: attr::contains_name(&attrs, "allow_internal_unstable"),
- attrs: attrs,
- body: body,
- })
- }
-
- fn maybe_get_item_ast<'a>(&'tcx self,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- def_id: DefId)
- -> Option<(&'tcx InlinedItem, ast::NodeId)>
- {
- self.dep_graph.read(DepNode::MetaData(def_id));
-
- match self.inlined_item_cache.borrow().get(&def_id) {
- Some(&None) => {
- return None; // Not inlinable
- }
- Some(&Some(ref cached_inlined_item)) => {
- // Already inline
- debug!("maybe_get_item_ast({}): already inline as node id {}",
- tcx.item_path_str(def_id), cached_inlined_item.item_id);
- return Some((tcx.map.expect_inlined_item(cached_inlined_item.inlined_root),
- cached_inlined_item.item_id));
- }
- None => {
- // Not seen yet
- }
- }
-
- debug!("maybe_get_item_ast({}): inlining item", tcx.item_path_str(def_id));
-
- let inlined = self.get_crate_data(def_id.krate).maybe_get_item_ast(tcx, def_id.index);
-
- let cache_inlined_item = |original_def_id, inlined_item_id, inlined_root_node_id| {
- let cache_entry = cstore::CachedInlinedItem {
- inlined_root: inlined_root_node_id,
- item_id: inlined_item_id,
- };
- self.inlined_item_cache
- .borrow_mut()
- .insert(original_def_id, Some(cache_entry));
- self.defid_for_inlined_node
- .borrow_mut()
- .insert(inlined_item_id, original_def_id);
- };
-
- let find_inlined_item_root = |inlined_item_id| {
- let mut node = inlined_item_id;
-
- // If we can't find the inline root after a thousand hops, we can
- // be pretty sure there's something wrong with the HIR map.
- for _ in 0 .. 1000 {
- let parent_node = tcx.map.get_parent_node(node);
- if parent_node == node {
- return node;
- }
- node = parent_node;
- }
- bug!("cycle in HIR map parent chain")
- };
-
- match inlined {
- None => {
- self.inlined_item_cache
- .borrow_mut()
- .insert(def_id, None);
- }
- Some(&InlinedItem { ref body, .. }) => {
- let inlined_root_node_id = find_inlined_item_root(body.id);
- cache_inlined_item(def_id, inlined_root_node_id, inlined_root_node_id);
- }
- }
-
- // We can be sure to hit the cache now
- return self.maybe_get_item_ast(tcx, def_id);
- }
-
- fn local_node_for_inlined_defid(&'tcx self, def_id: DefId) -> Option<ast::NodeId> {
- assert!(!def_id.is_local());
- match self.inlined_item_cache.borrow().get(&def_id) {
- Some(&Some(ref cached_inlined_item)) => {
- Some(cached_inlined_item.item_id)
- }
- Some(&None) => {
- None
- }
- _ => {
- bug!("Trying to lookup inlined NodeId for unexpected item");
- }
- }
- }
-
- fn defid_for_inlined_node(&'tcx self, node_id: ast::NodeId) -> Option<DefId> {
- self.defid_for_inlined_node.borrow().get(&node_id).map(|x| *x)
- }
-
- fn get_item_mir<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> Mir<'tcx> {
- self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).maybe_get_item_mir(tcx, def.index).unwrap_or_else(|| {
- bug!("get_item_mir: missing MIR for {}", tcx.item_path_str(def))
+ attrs: attrs.iter().cloned().collect(),
+ node: ast::ItemKind::MacroDef(ast::MacroDef {
+ tokens: body.into(),
+ legacy: def.legacy,
+ }),
+ vis: ast::Visibility::Inherited,
+ tokens: None,
})
}
- 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 can_have_local_instance<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> bool {
- self.dep_graph.read(DepNode::MetaData(def));
- def.is_local() || self.get_crate_data(def.krate).can_have_local_instance(tcx, def.index)
- }
-
- fn crates(&self) -> Vec<CrateNum>
+ fn crates_untracked(&self) -> Vec<CrateNum>
{
let mut result = vec![];
self.iter_crate_data(|cnum, _| result.push(cnum));
result
}
- fn used_libraries(&self) -> Vec<NativeLibrary>
- {
- self.get_used_libraries().borrow().clone()
- }
-
- fn used_link_args(&self) -> Vec<String>
- {
- 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
+ fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum>
{
- self.get_crate_data(cnum).source.clone()
+ self.do_extern_mod_stmt_cnum(emod_id)
}
- fn extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option<CrateNum>
- {
- self.do_extern_mod_stmt_cnum(emod_id)
+ fn postorder_cnums_untracked(&self) -> Vec<CrateNum> {
+ self.do_postorder_cnums_untracked()
}
- fn encode_metadata<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>,
- reexports: &def::ExportMap,
- link_meta: &LinkMeta,
- reachable: &NodeSet) -> Vec<u8>
+ fn encode_metadata<'a, 'tcx>(&self,
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ link_meta: &LinkMeta,
+ reachable: &NodeSet)
+ -> (EncodedMetadata, EncodedMetadataHashes)
{
- encoder::encode_metadata(tcx, self, reexports, link_meta, reachable)
+ encoder::encode_metadata(tcx, 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::RefMut<'a, DefIdMap<DefId>> {
- let mut visible_parent_map = self.visible_parent_map.borrow_mut();
- if !visible_parent_map.is_empty() { return visible_parent_map; }
-
- use std::collections::vec_deque::VecDeque;
- use std::collections::hash_map::Entry;
- 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);
- }
- }
- }
-
- visible_parent_map
- }
}