use cstore;
use encoder;
-use locator;
+use link_args;
+use native_libs;
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::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, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
-
-use rustc::dep_graph::DepNode;
-use rustc::hir::map::{DefKey, DefPath, DisambiguatedDefPathData};
+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::mem;
use std::rc::Rc;
use syntax::ast;
use syntax::attr;
+use syntax::ext::base::SyntaxExtension;
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_data_structures::indexed_set::IdxSetBuf;
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)
+ (<$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
- DepTrackingMapConfig>::Value {
+ QueryConfig>::Value
+ where T: IntoArgs,
+ {
+ #[allow(unused_variables)]
+ let ($def_id, $other) = def_id_arg.into_args();
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 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
}
}
-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) }
+// small trait to work around different signature queries all being defined via
+// the macro above.
+trait IntoArgs {
+ fn into_args(self) -> (DefId, DefId);
+}
+
+impl IntoArgs for DefId {
+ fn into_args(self) -> (DefId, DefId) { (self, self) }
+}
+
+impl IntoArgs for CrateNum {
+ fn into_args(self) -> (DefId, DefId) { (self.as_def_id(), self.as_def_id()) }
+}
+
+impl IntoArgs for (CrateNum, DefId) {
+ fn into_args(self) -> (DefId, DefId) { (self.0.as_def_id(), self.1) }
+}
+
+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))
+ }
+ 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.alloc_trait_def(cdata.get_trait_def(def_id.index, tcx.sess))
}
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)) }
+ 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()));
+ 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) }
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)
+ 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)
});
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) }
+ 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) }
- closure_type => { cdata.closure_ty(def_id.index, tcx) }
+ 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) }
-}
-
-impl CrateStore for cstore::CStore {
- fn crate_data_as_rc_any(&self, krate: CrateNum) -> Rc<Any> {
- self.get_crate_data(krate)
- }
-
- 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 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)
+ 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 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)
+ 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 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)
+ all_trait_implementations => {
+ let mut result = vec![];
+ cdata.get_implementations_for_trait(None, &mut result);
+ Rc::new(result)
}
- 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)
+ is_dllimport_foreign_item => {
+ cdata.is_dllimport_foreign_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)
+ 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_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)
+ missing_extern_crate_item => {
+ match cdata.extern_crate.get() {
+ Some(extern_crate) if !extern_crate.direct => true,
+ _ => false,
+ }
}
- fn is_foreign_item(&self, did: DefId) -> bool {
- self.get_crate_data(did.krate).is_foreign_item(did.index)
- }
+ used_crate_source => { Rc::new(cdata.source.clone()) }
- fn is_statically_included_foreign_item(&self, def_id: DefId) -> bool
- {
- self.do_is_statically_included_foreign_item(def_id)
- }
+ has_copy_closures => { cdata.has_copy_closures(tcx.sess) }
+ has_clone_closures => { cdata.has_clone_closures(tcx.sess) }
+}
- fn is_exported_symbol(&self, def_id: DefId) -> bool {
- self.get_crate_data(def_id.krate).exported_symbols.contains(&def_id.index)
- }
+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()
- }
-
- fn dep_kind(&self, cnum: CrateNum) -> DepKind
- {
- self.get_crate_data(cnum).dep_kind.get()
- }
+ // 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 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 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 lang_items(&self, cnum: CrateNum) -> Vec<(DefIndex, usize)>
- {
- self.get_crate_data(cnum).get_lang_items()
- }
+ if tcx.visibility(child) != ty::Visibility::Public {
+ return;
+ }
- fn missing_lang_items(&self, cnum: CrateNum)
- -> Vec<lang_items::LangItem>
- {
- self.get_crate_data(cnum).get_missing_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 is_staged_api(&self, cnum: CrateNum) -> bool
- {
- self.get_crate_data(cnum).is_staged_api()
- }
+ Rc::new(visible_parent_map)
+ },
- fn is_allocator(&self, cnum: CrateNum) -> bool
- {
- self.get_crate_data(cnum).is_allocator()
- }
+ ..*providers
+ };
+}
- fn is_panic_runtime(&self, cnum: CrateNum) -> bool
- {
- self.get_crate_data(cnum).is_panic_runtime()
+impl CrateStore for cstore::CStore {
+ fn crate_data_as_rc_any(&self, krate: CrateNum) -> Rc<Any> {
+ self.get_crate_data(krate)
}
- fn is_compiler_builtins(&self, cnum: CrateNum) -> bool {
- self.get_crate_data(cnum).is_compiler_builtins()
+ fn metadata_loader(&self) -> &MetadataLoader {
+ &*self.metadata_loader
}
- fn is_sanitizer_runtime(&self, cnum: CrateNum) -> bool {
- self.get_crate_data(cnum).is_sanitizer_runtime()
+ 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>
- {
- 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>
+ fn crate_hash_untracked(&self, cnum: CrateNum) -> hir::svh::Svh
{
- 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 retrace_path(&self,
- cnum: CrateNum,
- path: &[DisambiguatedDefPathData])
- -> Option<DefId> {
- let cdata = self.get_crate_data(cnum);
- cdata.def_path_table
- .retrace_path(&path)
- .map(|index| DefId { krate: cnum, index: index })
+ self.get_crate_data(cnum).hash()
}
/// Returns the `DefKey` for a given `DefId`. This indicates the
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) -> DefPathHash {
self.get_crate_data(def.krate).def_path_hash(def.index)
}
- fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
+ 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);
- 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);
+ 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);
+ let attrs = data.get_item_attrs(id.index, sess);
for attr in attrs.iter() {
attr::mark_used(attr);
}
.insert(local_span, (name.to_string(), data.get_span(id.index, sess)));
LoadedMacro::MacroDef(ast::Item {
- ident: ast::Ident::with_empty_ctxt(name),
+ ident: ast::Ident::from_str(&name),
id: ast::DUMMY_NODE_ID,
span: local_span,
attrs: attrs.iter().cloned().collect(),
- node: ast::ItemKind::MacroDef(body.into()),
+ node: ast::ItemKind::MacroDef(ast::MacroDef {
+ tokens: body.into(),
+ legacy: def.legacy,
+ }),
vis: ast::Visibility::Inherited,
+ tokens: None,
})
}
- fn item_body<'a, 'tcx>(&self,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- def_id: DefId)
- -> &'tcx hir::Body {
- if let Some(cached) = tcx.hir.get_inlined_body(def_id) {
- return cached;
- }
-
- self.dep_graph.read(DepNode::MetaData(def_id));
- debug!("item_body({}): inlining item", tcx.item_path_str(def_id));
-
- self.get_crate_data(def_id.krate).item_body(tcx, def_id.index)
- }
-
- fn item_body_nested_bodies(&self, def: DefId) -> BTreeMap<hir::BodyId, hir::Body> {
- 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<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)>
+ fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum>
{
- self.do_get_used_crates(prefer)
- }
-
- fn used_crate_source(&self, cnum: CrateNum) -> CrateSource
- {
- 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, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
link_meta: &LinkMeta,
reachable: &NodeSet)
- -> EncodedMetadata
+ -> (EncodedMetadata, EncodedMetadataHashes)
{
- encoder::encode_metadata(tcx, self, 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::Ref<'a, DefIdMap<DefId>> {
- {
- 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()
- }
}
projects / rustc.git / blobdiff