Make AST lowering a query.
This commit is contained in:
parent
43bb31b954
commit
250c71b85d
@ -3869,6 +3869,7 @@ name = "rustc_hir"
|
||||
version = "0.0.0"
|
||||
dependencies = [
|
||||
"odht",
|
||||
"rustc_arena",
|
||||
"rustc_ast",
|
||||
"rustc_data_structures",
|
||||
"rustc_error_messages",
|
||||
|
@ -1,7 +1,6 @@
|
||||
use super::ResolverAstLoweringExt;
|
||||
use super::{AstOwner, ImplTraitContext, ImplTraitPosition};
|
||||
use super::{LoweringContext, ParamMode};
|
||||
use crate::{Arena, FnDeclKind};
|
||||
use super::{FnDeclKind, LoweringContext, ParamMode};
|
||||
|
||||
use rustc_ast::ptr::P;
|
||||
use rustc_ast::visit::AssocCtxt;
|
||||
@ -12,12 +11,9 @@ use rustc_errors::struct_span_err;
|
||||
use rustc_hir as hir;
|
||||
use rustc_hir::def::{DefKind, Res};
|
||||
use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID};
|
||||
use rustc_hir::definitions::Definitions;
|
||||
use rustc_hir::PredicateOrigin;
|
||||
use rustc_index::vec::{Idx, IndexVec};
|
||||
use rustc_middle::ty::{ResolverAstLowering, ResolverOutputs};
|
||||
use rustc_session::cstore::CrateStoreDyn;
|
||||
use rustc_session::Session;
|
||||
use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
|
||||
use rustc_span::source_map::DesugaringKind;
|
||||
use rustc_span::symbol::{kw, sym, Ident};
|
||||
use rustc_span::Span;
|
||||
@ -27,12 +23,8 @@ use smallvec::{smallvec, SmallVec};
|
||||
use std::iter;
|
||||
|
||||
pub(super) struct ItemLowerer<'a, 'hir> {
|
||||
pub(super) sess: &'a Session,
|
||||
pub(super) definitions: &'a mut Definitions,
|
||||
pub(super) cstore: &'a CrateStoreDyn,
|
||||
pub(super) resolutions: &'a ResolverOutputs,
|
||||
pub(super) tcx: TyCtxt<'hir>,
|
||||
pub(super) resolver: &'a mut ResolverAstLowering,
|
||||
pub(super) arena: &'hir Arena<'hir>,
|
||||
pub(super) ast_index: &'a IndexVec<LocalDefId, AstOwner<'a>>,
|
||||
pub(super) owners: &'a mut IndexVec<LocalDefId, hir::MaybeOwner<&'hir hir::OwnerInfo<'hir>>>,
|
||||
}
|
||||
@ -65,12 +57,10 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
|
||||
) {
|
||||
let mut lctx = LoweringContext {
|
||||
// Pseudo-globals.
|
||||
sess: &self.sess,
|
||||
definitions: self.definitions,
|
||||
cstore: self.cstore,
|
||||
resolutions: self.resolutions,
|
||||
tcx: self.tcx,
|
||||
sess: &self.tcx.sess,
|
||||
resolver: self.resolver,
|
||||
arena: self.arena,
|
||||
arena: self.tcx.hir_arena,
|
||||
|
||||
// HirId handling.
|
||||
bodies: Vec::new(),
|
||||
@ -145,7 +135,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
|
||||
let def_id = self.resolver.node_id_to_def_id[&item.id];
|
||||
|
||||
let parent_id = {
|
||||
let parent = self.definitions.def_key(def_id).parent;
|
||||
let parent = self.tcx.hir().def_key(def_id).parent;
|
||||
let local_def_index = parent.unwrap();
|
||||
LocalDefId { local_def_index }
|
||||
};
|
||||
|
@ -53,12 +53,10 @@ use rustc_errors::{struct_span_err, Applicability};
|
||||
use rustc_hir as hir;
|
||||
use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
|
||||
use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID};
|
||||
use rustc_hir::definitions::{DefPathData, Definitions};
|
||||
use rustc_hir::definitions::DefPathData;
|
||||
use rustc_hir::{ConstArg, GenericArg, ItemLocalId, ParamName, TraitCandidate};
|
||||
use rustc_index::vec::{Idx, IndexVec};
|
||||
use rustc_middle::ty::{ResolverAstLowering, ResolverOutputs};
|
||||
use rustc_query_system::ich::StableHashingContext;
|
||||
use rustc_session::cstore::CrateStoreDyn;
|
||||
use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
|
||||
use rustc_session::parse::feature_err;
|
||||
use rustc_session::Session;
|
||||
use rustc_span::hygiene::MacroKind;
|
||||
@ -83,19 +81,13 @@ mod item;
|
||||
mod pat;
|
||||
mod path;
|
||||
|
||||
rustc_hir::arena_types!(rustc_arena::declare_arena);
|
||||
|
||||
struct LoweringContext<'a, 'hir: 'a> {
|
||||
/// Used to assign IDs to HIR nodes that do not directly correspond to AST nodes.
|
||||
sess: &'a Session,
|
||||
|
||||
definitions: &'a mut Definitions,
|
||||
cstore: &'a CrateStoreDyn,
|
||||
resolutions: &'a ResolverOutputs,
|
||||
struct LoweringContext<'a, 'hir> {
|
||||
tcx: TyCtxt<'hir>,
|
||||
sess: &'hir Session,
|
||||
resolver: &'a mut ResolverAstLowering,
|
||||
|
||||
/// Used to allocate HIR nodes.
|
||||
arena: &'hir Arena<'hir>,
|
||||
arena: &'hir hir::Arena<'hir>,
|
||||
|
||||
/// Bodies inside the owner being lowered.
|
||||
bodies: Vec<(hir::ItemLocalId, &'hir hir::Body<'hir>)>,
|
||||
@ -391,61 +383,58 @@ fn index_crate<'a>(
|
||||
/// Compute the hash for the HIR of the full crate.
|
||||
/// This hash will then be part of the crate_hash which is stored in the metadata.
|
||||
fn compute_hir_hash(
|
||||
sess: &Session,
|
||||
definitions: &Definitions,
|
||||
cstore: &CrateStoreDyn,
|
||||
resolver: &ResolverOutputs,
|
||||
tcx: TyCtxt<'_>,
|
||||
owners: &IndexVec<LocalDefId, hir::MaybeOwner<&hir::OwnerInfo<'_>>>,
|
||||
) -> Fingerprint {
|
||||
let mut hir_body_nodes: Vec<_> = owners
|
||||
.iter_enumerated()
|
||||
.filter_map(|(def_id, info)| {
|
||||
let info = info.as_owner()?;
|
||||
let def_path_hash = definitions.def_path_hash(def_id);
|
||||
let def_path_hash = tcx.hir().def_path_hash(def_id);
|
||||
Some((def_path_hash, info))
|
||||
})
|
||||
.collect();
|
||||
hir_body_nodes.sort_unstable_by_key(|bn| bn.0);
|
||||
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
let mut hcx = StableHashingContext::new(sess, definitions, cstore, &resolver.source_span);
|
||||
hir_body_nodes.hash_stable(&mut hcx, &mut stable_hasher);
|
||||
stable_hasher.finish()
|
||||
tcx.with_stable_hashing_context(|mut hcx| {
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
hir_body_nodes.hash_stable(&mut hcx, &mut stable_hasher);
|
||||
stable_hasher.finish()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn lower_crate<'hir>(
|
||||
sess: &Session,
|
||||
krate: &Crate,
|
||||
definitions: &mut Definitions,
|
||||
cstore: &CrateStoreDyn,
|
||||
resolutions: &ResolverOutputs,
|
||||
mut resolver: ResolverAstLowering,
|
||||
arena: &'hir Arena<'hir>,
|
||||
) -> &'hir hir::Crate<'hir> {
|
||||
let _prof_timer = sess.prof.verbose_generic_activity("hir_lowering");
|
||||
pub fn lower_to_hir<'hir>(tcx: TyCtxt<'hir>, (): ()) -> hir::Crate<'hir> {
|
||||
let sess = tcx.sess;
|
||||
let krate = tcx.untracked_crate.steal();
|
||||
let mut resolver = tcx.resolver_for_lowering(()).steal();
|
||||
|
||||
let ast_index = index_crate(&resolver.node_id_to_def_id, krate);
|
||||
|
||||
let mut owners =
|
||||
IndexVec::from_fn_n(|_| hir::MaybeOwner::Phantom, definitions.def_index_count());
|
||||
let ast_index = index_crate(&resolver.node_id_to_def_id, &krate);
|
||||
let mut owners = IndexVec::from_fn_n(
|
||||
|_| hir::MaybeOwner::Phantom,
|
||||
tcx.definitions_untracked().def_index_count(),
|
||||
);
|
||||
|
||||
for def_id in ast_index.indices() {
|
||||
item::ItemLowerer {
|
||||
sess,
|
||||
definitions,
|
||||
cstore,
|
||||
resolutions,
|
||||
tcx,
|
||||
resolver: &mut resolver,
|
||||
arena,
|
||||
ast_index: &ast_index,
|
||||
owners: &mut owners,
|
||||
}
|
||||
.lower_node(def_id);
|
||||
}
|
||||
|
||||
let hir_hash = compute_hir_hash(sess, definitions, cstore, resolutions, &owners);
|
||||
let krate = hir::Crate { owners, hir_hash };
|
||||
arena.alloc(krate)
|
||||
// Drop AST to free memory
|
||||
std::mem::drop(ast_index);
|
||||
sess.time("drop_ast", || std::mem::drop(krate));
|
||||
|
||||
// Discard hygiene data, which isn't required after lowering to HIR.
|
||||
if !sess.opts.debugging_opts.keep_hygiene_data {
|
||||
rustc_span::hygiene::clear_syntax_context_map();
|
||||
}
|
||||
|
||||
let hir_hash = compute_hir_hash(tcx, &owners);
|
||||
hir::Crate { owners, hir_hash }
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Debug)]
|
||||
@ -464,15 +453,6 @@ enum ParenthesizedGenericArgs {
|
||||
}
|
||||
|
||||
impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
||||
fn create_stable_hashing_context(&self) -> StableHashingContext<'_> {
|
||||
StableHashingContext::new(
|
||||
self.sess,
|
||||
self.definitions,
|
||||
self.cstore,
|
||||
&self.resolutions.source_span,
|
||||
)
|
||||
}
|
||||
|
||||
fn create_def(
|
||||
&mut self,
|
||||
parent: LocalDefId,
|
||||
@ -484,10 +464,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
||||
"adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}",
|
||||
node_id,
|
||||
data,
|
||||
self.definitions.def_key(self.local_def_id(node_id)),
|
||||
self.tcx.hir().def_key(self.local_def_id(node_id)),
|
||||
);
|
||||
|
||||
let def_id = self.definitions.create_def(parent, data);
|
||||
let def_id = self.tcx.create_def(parent, data);
|
||||
|
||||
// Some things for which we allocate `LocalDefId`s don't correspond to
|
||||
// anything in the AST, so they don't have a `NodeId`. For these cases
|
||||
@ -578,7 +558,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
||||
bodies.sort_by_key(|(k, _)| *k);
|
||||
let bodies = SortedMap::from_presorted_elements(bodies);
|
||||
let (hash_including_bodies, hash_without_bodies) = self.hash_owner(node, &bodies);
|
||||
let (nodes, parenting) = index::index_hir(self.sess, self.definitions, node, &bodies);
|
||||
let (nodes, parenting) =
|
||||
index::index_hir(self.tcx.sess, &*self.tcx.definitions_untracked(), node, &bodies);
|
||||
let nodes = hir::OwnerNodes {
|
||||
hash_including_bodies,
|
||||
hash_without_bodies,
|
||||
@ -587,10 +568,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
||||
local_id_to_def_id,
|
||||
};
|
||||
let attrs = {
|
||||
let mut hcx = self.create_stable_hashing_context();
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
attrs.hash_stable(&mut hcx, &mut stable_hasher);
|
||||
let hash = stable_hasher.finish();
|
||||
let hash = self.tcx.with_stable_hashing_context(|mut hcx| {
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
attrs.hash_stable(&mut hcx, &mut stable_hasher);
|
||||
stable_hasher.finish()
|
||||
});
|
||||
hir::AttributeMap { map: attrs, hash }
|
||||
};
|
||||
|
||||
@ -604,18 +586,19 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
||||
node: hir::OwnerNode<'hir>,
|
||||
bodies: &SortedMap<hir::ItemLocalId, &'hir hir::Body<'hir>>,
|
||||
) -> (Fingerprint, Fingerprint) {
|
||||
let mut hcx = self.create_stable_hashing_context();
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
hcx.with_hir_bodies(true, node.def_id(), bodies, |hcx| {
|
||||
node.hash_stable(hcx, &mut stable_hasher)
|
||||
});
|
||||
let hash_including_bodies = stable_hasher.finish();
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
hcx.with_hir_bodies(false, node.def_id(), bodies, |hcx| {
|
||||
node.hash_stable(hcx, &mut stable_hasher)
|
||||
});
|
||||
let hash_without_bodies = stable_hasher.finish();
|
||||
(hash_including_bodies, hash_without_bodies)
|
||||
self.tcx.with_stable_hashing_context(|mut hcx| {
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
hcx.with_hir_bodies(true, node.def_id(), bodies, |hcx| {
|
||||
node.hash_stable(hcx, &mut stable_hasher)
|
||||
});
|
||||
let hash_including_bodies = stable_hasher.finish();
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
hcx.with_hir_bodies(false, node.def_id(), bodies, |hcx| {
|
||||
node.hash_stable(hcx, &mut stable_hasher)
|
||||
});
|
||||
let hash_without_bodies = stable_hasher.finish();
|
||||
(hash_including_bodies, hash_without_bodies)
|
||||
})
|
||||
}
|
||||
|
||||
/// This method allocates a new `HirId` for the given `NodeId` and stores it in
|
||||
@ -703,12 +686,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
||||
span: Span,
|
||||
allow_internal_unstable: Option<Lrc<[Symbol]>>,
|
||||
) -> Span {
|
||||
span.mark_with_reason(
|
||||
allow_internal_unstable,
|
||||
reason,
|
||||
self.sess.edition(),
|
||||
self.create_stable_hashing_context(),
|
||||
)
|
||||
self.tcx.with_stable_hashing_context(|hcx| {
|
||||
span.mark_with_reason(allow_internal_unstable, reason, self.sess.edition(), hcx)
|
||||
})
|
||||
}
|
||||
|
||||
/// Intercept all spans entering HIR.
|
||||
|
@ -7,6 +7,7 @@ edition = "2021"
|
||||
doctest = false
|
||||
|
||||
[dependencies]
|
||||
rustc_arena = { path = "../rustc_arena" }
|
||||
rustc_target = { path = "../rustc_target" }
|
||||
rustc_macros = { path = "../rustc_macros" }
|
||||
rustc_data_structures = { path = "../rustc_data_structures" }
|
||||
|
@ -9,7 +9,7 @@ macro_rules! arena_types {
|
||||
// HIR types
|
||||
[] hir_krate: rustc_hir::Crate<'tcx>,
|
||||
[] arm: rustc_hir::Arm<'tcx>,
|
||||
[] asm_operand: (rustc_hir::InlineAsmOperand<'tcx>, Span),
|
||||
[] asm_operand: (rustc_hir::InlineAsmOperand<'tcx>, rustc_span::Span),
|
||||
[] asm_template: rustc_ast::InlineAsmTemplatePiece,
|
||||
[] attribute: rustc_ast::Attribute,
|
||||
[] block: rustc_hir::Block<'tcx>,
|
||||
|
@ -18,6 +18,8 @@ extern crate rustc_macros;
|
||||
#[macro_use]
|
||||
extern crate rustc_data_structures;
|
||||
|
||||
extern crate self as rustc_hir;
|
||||
|
||||
mod arena;
|
||||
pub mod def;
|
||||
pub mod def_path_hash_map;
|
||||
@ -41,3 +43,5 @@ pub use hir_id::*;
|
||||
pub use lang_items::{LangItem, LanguageItems};
|
||||
pub use stable_hash_impls::HashStableContext;
|
||||
pub use target::{MethodKind, Target};
|
||||
|
||||
arena_types!(rustc_arena::declare_arena);
|
||||
|
@ -14,7 +14,6 @@ use rustc_errors::{Applicability, ErrorGuaranteed, MultiSpan, PResult};
|
||||
use rustc_expand::base::{ExtCtxt, LintStoreExpand, ResolverExpand};
|
||||
use rustc_hir::def_id::{StableCrateId, LOCAL_CRATE};
|
||||
use rustc_hir::definitions::Definitions;
|
||||
use rustc_hir::Crate;
|
||||
use rustc_lint::{EarlyCheckNode, LintStore};
|
||||
use rustc_metadata::creader::CStore;
|
||||
use rustc_metadata::{encode_metadata, EncodedMetadata};
|
||||
@ -482,37 +481,6 @@ pub fn configure_and_expand(
|
||||
Ok(krate)
|
||||
}
|
||||
|
||||
fn lower_to_hir<'tcx>(
|
||||
sess: &Session,
|
||||
definitions: &mut Definitions,
|
||||
cstore: &CrateStoreDyn,
|
||||
resolutions: &ty::ResolverOutputs,
|
||||
resolver: ty::ResolverAstLowering,
|
||||
krate: Rc<ast::Crate>,
|
||||
arena: &'tcx rustc_ast_lowering::Arena<'tcx>,
|
||||
) -> &'tcx Crate<'tcx> {
|
||||
// Lower AST to HIR.
|
||||
let hir_crate = rustc_ast_lowering::lower_crate(
|
||||
sess,
|
||||
&krate,
|
||||
definitions,
|
||||
cstore,
|
||||
resolutions,
|
||||
resolver,
|
||||
arena,
|
||||
);
|
||||
|
||||
// Drop AST to free memory
|
||||
sess.time("drop_ast", || std::mem::drop(krate));
|
||||
|
||||
// Discard hygiene data, which isn't required after lowering to HIR.
|
||||
if !sess.opts.debugging_opts.keep_hygiene_data {
|
||||
rustc_span::hygiene::clear_syntax_context_map();
|
||||
}
|
||||
|
||||
hir_crate
|
||||
}
|
||||
|
||||
// Returns all the paths that correspond to generated files.
|
||||
fn generated_output_paths(
|
||||
sess: &Session,
|
||||
@ -777,6 +745,7 @@ pub fn prepare_outputs(
|
||||
pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
|
||||
let providers = &mut Providers::default();
|
||||
providers.analysis = analysis;
|
||||
providers.hir_crate = rustc_ast_lowering::lower_to_hir;
|
||||
proc_macro_decls::provide(providers);
|
||||
rustc_const_eval::provide(providers);
|
||||
rustc_middle::hir::provide(providers);
|
||||
@ -823,7 +792,7 @@ impl<'tcx> QueryContext<'tcx> {
|
||||
pub fn create_global_ctxt<'tcx>(
|
||||
compiler: &'tcx Compiler,
|
||||
lint_store: Lrc<LintStore>,
|
||||
krate: Rc<ast::Crate>,
|
||||
krate: Lrc<ast::Crate>,
|
||||
dep_graph: DepGraph,
|
||||
resolver: Rc<RefCell<BoxedResolver>>,
|
||||
outputs: OutputFilenames,
|
||||
@ -831,29 +800,17 @@ pub fn create_global_ctxt<'tcx>(
|
||||
queries: &'tcx OnceCell<TcxQueries<'tcx>>,
|
||||
global_ctxt: &'tcx OnceCell<GlobalCtxt<'tcx>>,
|
||||
arena: &'tcx WorkerLocal<Arena<'tcx>>,
|
||||
hir_arena: &'tcx WorkerLocal<rustc_ast_lowering::Arena<'tcx>>,
|
||||
hir_arena: &'tcx WorkerLocal<rustc_hir::Arena<'tcx>>,
|
||||
) -> QueryContext<'tcx> {
|
||||
// We're constructing the HIR here; we don't care what we will
|
||||
// read, since we haven't even constructed the *input* to
|
||||
// incr. comp. yet.
|
||||
dep_graph.assert_ignored();
|
||||
|
||||
let (mut definitions, cstore, resolver_outputs, resolver_for_lowering) =
|
||||
let (definitions, cstore, resolver_outputs, resolver_for_lowering) =
|
||||
BoxedResolver::to_resolver_outputs(resolver);
|
||||
|
||||
let sess = &compiler.session();
|
||||
|
||||
// Lower AST to HIR.
|
||||
let krate = lower_to_hir(
|
||||
sess,
|
||||
&mut definitions,
|
||||
&*cstore,
|
||||
&resolver_outputs,
|
||||
resolver_for_lowering,
|
||||
krate,
|
||||
hir_arena,
|
||||
);
|
||||
|
||||
let query_result_on_disk_cache = rustc_incremental::load_query_result_cache(sess);
|
||||
|
||||
let codegen_backend = compiler.codegen_backend();
|
||||
@ -877,9 +834,11 @@ pub fn create_global_ctxt<'tcx>(
|
||||
sess,
|
||||
lint_store,
|
||||
arena,
|
||||
hir_arena,
|
||||
definitions,
|
||||
cstore,
|
||||
resolver_outputs,
|
||||
resolver_for_lowering,
|
||||
krate,
|
||||
dep_graph,
|
||||
queries.on_disk_cache.as_ref().map(OnDiskCache::as_dyn),
|
||||
|
@ -72,13 +72,13 @@ pub struct Queries<'tcx> {
|
||||
queries: OnceCell<TcxQueries<'tcx>>,
|
||||
|
||||
arena: WorkerLocal<Arena<'tcx>>,
|
||||
hir_arena: WorkerLocal<rustc_ast_lowering::Arena<'tcx>>,
|
||||
hir_arena: WorkerLocal<rustc_hir::Arena<'tcx>>,
|
||||
|
||||
dep_graph_future: Query<Option<DepGraphFuture>>,
|
||||
parse: Query<ast::Crate>,
|
||||
crate_name: Query<String>,
|
||||
register_plugins: Query<(ast::Crate, Lrc<LintStore>)>,
|
||||
expansion: Query<(Rc<ast::Crate>, Rc<RefCell<BoxedResolver>>, Lrc<LintStore>)>,
|
||||
expansion: Query<(Lrc<ast::Crate>, Rc<RefCell<BoxedResolver>>, Lrc<LintStore>)>,
|
||||
dep_graph: Query<DepGraph>,
|
||||
prepare_outputs: Query<OutputFilenames>,
|
||||
global_ctxt: Query<QueryContext<'tcx>>,
|
||||
@ -92,7 +92,7 @@ impl<'tcx> Queries<'tcx> {
|
||||
gcx: OnceCell::new(),
|
||||
queries: OnceCell::new(),
|
||||
arena: WorkerLocal::new(|_| Arena::default()),
|
||||
hir_arena: WorkerLocal::new(|_| rustc_ast_lowering::Arena::default()),
|
||||
hir_arena: WorkerLocal::new(|_| rustc_hir::Arena::default()),
|
||||
dep_graph_future: Default::default(),
|
||||
parse: Default::default(),
|
||||
crate_name: Default::default(),
|
||||
@ -164,7 +164,7 @@ impl<'tcx> Queries<'tcx> {
|
||||
|
||||
pub fn expansion(
|
||||
&self,
|
||||
) -> Result<&Query<(Rc<ast::Crate>, Rc<RefCell<BoxedResolver>>, Lrc<LintStore>)>> {
|
||||
) -> Result<&Query<(Lrc<ast::Crate>, Rc<RefCell<BoxedResolver>>, Lrc<LintStore>)>> {
|
||||
tracing::trace!("expansion");
|
||||
self.expansion.compute(|| {
|
||||
let crate_name = self.crate_name()?.peek().clone();
|
||||
@ -180,7 +180,7 @@ impl<'tcx> Queries<'tcx> {
|
||||
let krate = resolver.access(|resolver| {
|
||||
passes::configure_and_expand(sess, &lint_store, krate, &crate_name, resolver)
|
||||
})?;
|
||||
Ok((Rc::new(krate), Rc::new(RefCell::new(resolver)), lint_store))
|
||||
Ok((Lrc::new(krate), Rc::new(RefCell::new(resolver)), lint_store))
|
||||
})
|
||||
}
|
||||
|
||||
|
@ -34,7 +34,7 @@ use tracing::debug;
|
||||
|
||||
/// Extract the `LintStore` from the query context.
|
||||
/// This function exists because we've erased `LintStore` as `dyn Any` in the context.
|
||||
pub(crate) fn unerased_lint_store(tcx: TyCtxt<'_>) -> &LintStore {
|
||||
pub fn unerased_lint_store(tcx: TyCtxt<'_>) -> &LintStore {
|
||||
let store: &dyn Any = &*tcx.lint_store;
|
||||
store.downcast_ref().unwrap()
|
||||
}
|
||||
|
@ -99,7 +99,7 @@ pub use builtin::SoftLints;
|
||||
pub use context::{CheckLintNameResult, FindLintError, LintStore};
|
||||
pub use context::{EarlyContext, LateContext, LintContext};
|
||||
pub use early::{check_ast_node, EarlyCheckNode};
|
||||
pub use late::check_crate;
|
||||
pub use late::{check_crate, unerased_lint_store};
|
||||
pub use passes::{EarlyLintPass, LateLintPass};
|
||||
pub use rustc_session::lint::Level::{self, *};
|
||||
pub use rustc_session::lint::{BufferedEarlyLint, FutureIncompatibleInfo, Lint, LintId};
|
||||
|
@ -102,7 +102,6 @@ pub fn provide(providers: &mut Providers) {
|
||||
let hir = tcx.hir();
|
||||
hir.get_module_parent_node(hir.local_def_id_to_hir_id(id))
|
||||
};
|
||||
providers.hir_crate = |tcx, ()| tcx.untracked_crate;
|
||||
providers.hir_crate_items = map::hir_crate_items;
|
||||
providers.crate_hash = map::crate_hash;
|
||||
providers.hir_module_items = map::hir_module_items;
|
||||
|
@ -32,6 +32,12 @@ rustc_queries! {
|
||||
desc { "get the resolver outputs" }
|
||||
}
|
||||
|
||||
query resolver_for_lowering(_: ()) -> &'tcx Steal<ty::ResolverAstLowering> {
|
||||
eval_always
|
||||
no_hash
|
||||
desc { "get the resolver for lowering" }
|
||||
}
|
||||
|
||||
/// Return the span for a definition.
|
||||
/// Contrary to `def_span` below, this query returns the full absolute span of the definition.
|
||||
/// This span is meant for dep-tracking rather than diagnostics. It should not be used outside
|
||||
@ -46,7 +52,8 @@ rustc_queries! {
|
||||
/// This is because the `hir_crate` query gives you access to all other items.
|
||||
/// To avoid this fate, do not call `tcx.hir().krate()`; instead,
|
||||
/// prefer wrappers like `tcx.visit_all_items_in_krate()`.
|
||||
query hir_crate(key: ()) -> &'tcx Crate<'tcx> {
|
||||
query hir_crate(key: ()) -> Crate<'tcx> {
|
||||
storage(ArenaCacheSelector<'tcx>)
|
||||
eval_always
|
||||
desc { "get the crate HIR" }
|
||||
}
|
||||
|
@ -1049,6 +1049,7 @@ impl<'tcx> Deref for TyCtxt<'tcx> {
|
||||
|
||||
pub struct GlobalCtxt<'tcx> {
|
||||
pub arena: &'tcx WorkerLocal<Arena<'tcx>>,
|
||||
pub hir_arena: &'tcx WorkerLocal<hir::Arena<'tcx>>,
|
||||
|
||||
interners: CtxtInterners<'tcx>,
|
||||
|
||||
@ -1078,8 +1079,8 @@ pub struct GlobalCtxt<'tcx> {
|
||||
|
||||
/// Output of the resolver.
|
||||
pub(crate) untracked_resolutions: ty::ResolverOutputs,
|
||||
|
||||
pub(crate) untracked_crate: &'tcx hir::Crate<'tcx>,
|
||||
untracked_resolver_for_lowering: Steal<ty::ResolverAstLowering>,
|
||||
pub untracked_crate: Steal<Lrc<ast::Crate>>,
|
||||
|
||||
/// This provides access to the incremental compilation on-disk cache for query results.
|
||||
/// Do not access this directly. It is only meant to be used by
|
||||
@ -1237,10 +1238,12 @@ impl<'tcx> TyCtxt<'tcx> {
|
||||
s: &'tcx Session,
|
||||
lint_store: Lrc<dyn Any + sync::Send + sync::Sync>,
|
||||
arena: &'tcx WorkerLocal<Arena<'tcx>>,
|
||||
hir_arena: &'tcx WorkerLocal<hir::Arena<'tcx>>,
|
||||
definitions: Definitions,
|
||||
cstore: Box<CrateStoreDyn>,
|
||||
untracked_resolutions: ty::ResolverOutputs,
|
||||
krate: &'tcx hir::Crate<'tcx>,
|
||||
untracked_resolver_for_lowering: ty::ResolverAstLowering,
|
||||
krate: Lrc<ast::Crate>,
|
||||
dep_graph: DepGraph,
|
||||
on_disk_cache: Option<&'tcx dyn OnDiskCache<'tcx>>,
|
||||
queries: &'tcx dyn query::QueryEngine<'tcx>,
|
||||
@ -1267,16 +1270,18 @@ impl<'tcx> TyCtxt<'tcx> {
|
||||
sess: s,
|
||||
lint_store,
|
||||
arena,
|
||||
hir_arena,
|
||||
interners,
|
||||
dep_graph,
|
||||
definitions: RwLock::new(definitions),
|
||||
cstore,
|
||||
untracked_resolutions,
|
||||
prof: s.prof.clone(),
|
||||
types: common_types,
|
||||
lifetimes: common_lifetimes,
|
||||
consts: common_consts,
|
||||
untracked_crate: krate,
|
||||
untracked_resolutions,
|
||||
untracked_resolver_for_lowering: Steal::new(untracked_resolver_for_lowering),
|
||||
untracked_crate: Steal::new(krate),
|
||||
on_disk_cache,
|
||||
queries,
|
||||
query_caches: query::QueryCaches::default(),
|
||||
@ -2996,6 +3001,7 @@ fn ptr_eq<T, U>(t: *const T, u: *const U) -> bool {
|
||||
|
||||
pub fn provide(providers: &mut ty::query::Providers) {
|
||||
providers.resolutions = |tcx, ()| &tcx.untracked_resolutions;
|
||||
providers.resolver_for_lowering = |tcx, ()| &tcx.untracked_resolver_for_lowering;
|
||||
providers.module_reexports =
|
||||
|tcx, id| tcx.resolutions(()).reexport_map.get(&id).map(|v| &v[..]);
|
||||
providers.crate_name = |tcx, id| {
|
||||
|
@ -119,13 +119,13 @@ impl<'a> StableHashingContext<'a> {
|
||||
&mut self,
|
||||
hash_bodies: bool,
|
||||
owner: LocalDefId,
|
||||
bodies: &'a SortedMap<hir::ItemLocalId, &'a hir::Body<'a>>,
|
||||
f: impl FnOnce(&mut Self),
|
||||
bodies: &SortedMap<hir::ItemLocalId, &hir::Body<'_>>,
|
||||
f: impl FnOnce(&mut StableHashingContext<'_>),
|
||||
) {
|
||||
let prev = self.body_resolver;
|
||||
self.body_resolver = BodyResolver::Traverse { hash_bodies, owner, bodies };
|
||||
f(self);
|
||||
self.body_resolver = prev;
|
||||
f(&mut StableHashingContext {
|
||||
body_resolver: BodyResolver::Traverse { hash_bodies, owner, bodies },
|
||||
..self.clone()
|
||||
});
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
Loading…
x
Reference in New Issue
Block a user