nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-01 06:51:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Cache expansion hash.

Browse Source
This commit is contained in:
Camille GILLOT 2021-06-22 19:20:25 +02:00
parent cff0ea5f88
commit 616ce3c5c0
12 changed files with 263 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -48,7 +48,7 @@ use rustc_data_structures::sync::Lrc;
use rustc_errors::{struct_span_err, Applicability};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Namespace, PartialRes, PerNS, Res};
use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, CRATE_DEF_ID};
use rustc_hir::def_id::{DefId, DefIdMap, DefPathHash, LocalDefId, CRATE_DEF_ID};
use rustc_hir::definitions::{DefKey, DefPathData, Definitions};
use rustc_hir::intravisit;
use rustc_hir::{ConstArg, GenericArg, ParamName};
@ -59,7 +59,7 @@ use rustc_session::utils::{FlattenNonterminals, NtToTokenstream};
use rustc_session::Session;
use rustc_span::edition::Edition;
use rustc_span::hygiene::ExpnId;
use rustc_span::source_map::{respan, DesugaringKind};
use rustc_span::source_map::{respan, CachingSourceMapView, DesugaringKind};
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP};
use rustc_target::spec::abi::Abi;
@ -204,6 +204,8 @@ pub trait ResolverAstLowering {
fn local_def_id(&self, node: NodeId) -> LocalDefId;
fn def_path_hash(&self, def_id: DefId) -> DefPathHash;
fn create_def(
&mut self,
parent: LocalDefId,
@ -214,6 +216,32 @@ pub trait ResolverAstLowering {
) -> LocalDefId;
}
struct LoweringHasher<'a> {
source_map: CachingSourceMapView<'a>,
resolver: &'a dyn ResolverAstLowering,
}
impl<'a> rustc_span::HashStableContext for LoweringHasher<'a> {
#[inline]
fn hash_spans(&self) -> bool {
true
}
#[inline]
fn def_path_hash(&self, def_id: DefId) -> DefPathHash {
self.resolver.def_path_hash(def_id)
}
#[inline]
fn span_data_to_lines_and_cols(
&mut self,
span: &rustc_span::SpanData,
) -> Option<(Lrc<rustc_span::SourceFile>, usize, rustc_span::BytePos, usize, rustc_span::BytePos)>
{
self.source_map.span_data_to_lines_and_cols(span)
}
}
/// Context of `impl Trait` in code, which determines whether it is allowed in an HIR subtree,
/// and if so, what meaning it has.
#[derive(Debug)]
@ -565,6 +593,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
lowered
}
fn create_stable_hashing_context(&self) -> LoweringHasher<'_> {
LoweringHasher {
source_map: CachingSourceMapView::new(self.sess.source_map()),
resolver: self.resolver,
}
}
fn lower_node_id_generic(
&mut self,
ast_node_id: NodeId,
@ -684,7 +719,12 @@ 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())
span.mark_with_reason(
allow_internal_unstable,
reason,
self.sess.edition(),
self.create_stable_hashing_context(),
)
}
fn with_anonymous_lifetime_mode<R>(

4
compiler/rustc_expand/src/expand.rs
View File

@ -506,7 +506,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
.map(|(path, item, _exts)| {
// FIXME: Consider using the derive resolutions (`_exts`)
// instead of enqueuing the derives to be resolved again later.
let expn_id = ExpnId::fresh(None);
let expn_id = ExpnId::fresh_empty();
derive_invocations.push((
Invocation {
kind: InvocationKind::Derive { path, item },
@ -989,7 +989,7 @@ struct InvocationCollector<'a, 'b> {
impl<'a, 'b> InvocationCollector<'a, 'b> {
fn collect(&mut self, fragment_kind: AstFragmentKind, kind: InvocationKind) -> AstFragment {
let expn_id = ExpnId::fresh(None);
let expn_id = ExpnId::fresh_empty();
let vis = kind.placeholder_visibility();
self.invocations.push((
Invocation {

11
compiler/rustc_metadata/src/rmeta/decoder.rs
View File

@ -393,12 +393,19 @@ impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for ExpnId {
} else {
local_cdata.cstore.get_crate_data(cnum)
};
Ok(crate_data
let expn_data = crate_data
.root
.expn_data
.get(&crate_data, index)
.unwrap()
.decode((&crate_data, sess)))
.decode((&crate_data, sess));
let expn_hash = crate_data
.root
.expn_hashes
.get(&crate_data, index)
.unwrap()
.decode((&crate_data, sess));
Ok((expn_data, expn_hash))
},
)
}

19
compiler/rustc_metadata/src/rmeta/encoder.rs
View File

@ -653,7 +653,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
// Therefore, we need to encode the hygiene data last to ensure that we encode
// any `SyntaxContext`s that might be used.
i = self.position();
let (syntax_contexts, expn_data) = self.encode_hygiene();
let (syntax_contexts, expn_data, expn_hashes) = self.encode_hygiene();
let hygiene_bytes = self.position() - i;
// Encode source_map. This needs to be done last,
@ -701,6 +701,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
tables,
syntax_contexts,
expn_data,
expn_hashes,
});
let total_bytes = self.position();
@ -1578,23 +1579,29 @@ impl EncodeContext<'a, 'tcx> {
self.lazy(foreign_modules.iter().map(|(_, m)| m).cloned())
}
fn encode_hygiene(&mut self) -> (SyntaxContextTable, ExpnDataTable) {
fn encode_hygiene(&mut self) -> (SyntaxContextTable, ExpnDataTable, ExpnHashTable) {
let mut syntax_contexts: TableBuilder<_, _> = Default::default();
let mut expn_data_table: TableBuilder<_, _> = Default::default();
let mut expn_hash_table: TableBuilder<_, _> = Default::default();
let _: Result<(), !> = self.hygiene_ctxt.encode(
&mut (&mut *self, &mut syntax_contexts, &mut expn_data_table),
|(this, syntax_contexts, _), index, ctxt_data| {
&mut (&mut *self, &mut syntax_contexts, &mut expn_data_table, &mut expn_hash_table),
|(this, syntax_contexts, _, _), index, ctxt_data| {
syntax_contexts.set(index, this.lazy(ctxt_data));
Ok(())
},
|(this, _, expn_data_table), index, expn_data| {
|(this, _, expn_data_table, expn_hash_table), index, expn_data, hash| {
expn_data_table.set(index, this.lazy(expn_data));
expn_hash_table.set(index, this.lazy(hash));
Ok(())
},
);
(syntax_contexts.encode(&mut self.opaque), expn_data_table.encode(&mut self.opaque))
(
syntax_contexts.encode(&mut self.opaque),
expn_data_table.encode(&mut self.opaque),
expn_hash_table.encode(&mut self.opaque),
)
}
fn encode_proc_macros(&mut self) -> Option<ProcMacroData> {

4
compiler/rustc_metadata/src/rmeta/mod.rs
View File

@ -21,7 +21,7 @@ use rustc_session::config::SymbolManglingVersion;
use rustc_span::edition::Edition;
use rustc_span::hygiene::MacroKind;
use rustc_span::symbol::{Ident, Symbol};
use rustc_span::{self, ExpnData, ExpnId, Span};
use rustc_span::{self, ExpnData, ExpnHash, ExpnId, Span};
use rustc_target::spec::{PanicStrategy, TargetTriple};
use std::marker::PhantomData;
@ -171,6 +171,7 @@ macro_rules! Lazy {
type SyntaxContextTable = Lazy<Table<u32, Lazy<SyntaxContextData>>>;
type ExpnDataTable = Lazy<Table<u32, Lazy<ExpnData>>>;
type ExpnHashTable = Lazy<Table<u32, Lazy<ExpnHash>>>;
#[derive(MetadataEncodable, MetadataDecodable)]
crate struct ProcMacroData {
@ -226,6 +227,7 @@ crate struct CrateRoot<'tcx> {
syntax_contexts: SyntaxContextTable,
expn_data: ExpnDataTable,
expn_hashes: ExpnHashTable,
source_map: Lazy<[rustc_span::SourceFile]>,

8
compiler/rustc_middle/src/ich/hcx.rs
View File

@ -16,7 +16,6 @@ use rustc_span::{BytePos, CachingSourceMapView, SourceFile, SpanData};
use smallvec::SmallVec;
use std::cmp::Ord;
use std::thread::LocalKey;
fn compute_ignored_attr_names() -> FxHashSet<Symbol> {
debug_assert!(!ich::IGNORED_ATTRIBUTES.is_empty());
@ -230,13 +229,6 @@ impl<'a> rustc_span::HashStableContext for StableHashingContext<'a> {
self.def_path_hash(def_id)
}
fn expn_id_cache() -> &'static LocalKey<rustc_span::ExpnIdCache> {
thread_local! {
static CACHE: rustc_span::ExpnIdCache = Default::default();
}
&CACHE
}
fn span_data_to_lines_and_cols(
&mut self,
span: &SpanData,

8
compiler/rustc_middle/src/ty/query/on_disk_cache.rs
View File

@ -25,7 +25,7 @@ use rustc_span::hygiene::{
};
use rustc_span::source_map::{SourceMap, StableSourceFileId};
use rustc_span::CachingSourceMapView;
use rustc_span::{BytePos, ExpnData, SourceFile, Span, DUMMY_SP};
use rustc_span::{BytePos, ExpnData, ExpnHash, SourceFile, Span, DUMMY_SP};
use std::collections::hash_map::Entry;
use std::mem;
@ -364,9 +364,9 @@ impl<'sess> OnDiskCache<'sess> {
syntax_contexts.insert(index, pos);
Ok(())
},
|encoder, index, expn_data| -> FileEncodeResult {
|encoder, index, expn_data, hash| -> FileEncodeResult {
let pos = AbsoluteBytePos::new(encoder.position());
encoder.encode_tagged(TAG_EXPN_DATA, expn_data)?;
encoder.encode_tagged(TAG_EXPN_DATA, &(expn_data, hash))?;
expn_ids.insert(index, pos);
Ok(())
},
@ -804,7 +804,7 @@ impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for ExpnId {
.unwrap_or_else(|| panic!("Bad index {:?} (map {:?})", index, expn_data));
this.with_position(pos.to_usize(), |decoder| {
let data: ExpnData = decode_tagged(decoder, TAG_EXPN_DATA)?;
let data: (ExpnData, ExpnHash) = decode_tagged(decoder, TAG_EXPN_DATA)?;
Ok(data)
})
},

3
compiler/rustc_mir/src/transform/inline.rs
View File

@ -839,7 +839,8 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Integrator<'a, 'tcx> {
ExpnData::default(ExpnKind::Inlined, *span, self.tcx.sess.edition(), None, None);
expn_data.def_site = self.body_span;
// Make sure that all spans track the fact that they were inlined.
*span = self.callsite_span.fresh_expansion(expn_data);
*span =
self.callsite_span.fresh_expansion(expn_data, self.tcx.create_stable_hashing_context());
}
fn visit_place(&mut self, place: &mut Place<'tcx>, context: PlaceContext, location: Location) {

44
compiler/rustc_resolve/src/lib.rs
View File

@ -39,7 +39,7 @@ use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder};
use rustc_expand::base::{DeriveResolutions, SyntaxExtension, SyntaxExtensionKind};
use rustc_hir::def::Namespace::*;
use rustc_hir::def::{self, CtorOf, DefKind, NonMacroAttrKind, PartialRes};
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX};
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefPathHash, LocalDefId, CRATE_DEF_INDEX};
use rustc_hir::definitions::{DefKey, DefPathData, Definitions};
use rustc_hir::TraitCandidate;
use rustc_index::vec::IndexVec;
@ -54,7 +54,7 @@ use rustc_session::lint::{BuiltinLintDiagnostics, LintBuffer};
use rustc_session::Session;
use rustc_span::edition::Edition;
use rustc_span::hygiene::{ExpnId, ExpnKind, MacroKind, SyntaxContext, Transparency};
use rustc_span::source_map::Spanned;
use rustc_span::source_map::{CachingSourceMapView, Spanned};
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP};
@ -1149,6 +1149,13 @@ impl ResolverAstLowering for Resolver<'_> {
self.opt_local_def_id(node).unwrap_or_else(|| panic!("no entry for node id: `{:?}`", node))
}
fn def_path_hash(&self, def_id: DefId) -> DefPathHash {
match def_id.as_local() {
Some(def_id) => self.definitions.def_path_hash(def_id),
None => self.cstore().def_path_hash(def_id),
}
}
/// Adds a definition with a parent definition.
fn create_def(
&mut self,
@ -1192,6 +1199,32 @@ impl ResolverAstLowering for Resolver<'_> {
}
}
struct ExpandHasher<'a, 'b> {
source_map: CachingSourceMapView<'a>,
resolver: &'a Resolver<'b>,
}
impl<'a, 'b> rustc_span::HashStableContext for ExpandHasher<'a, 'b> {
#[inline]
fn hash_spans(&self) -> bool {
true
}
#[inline]
fn def_path_hash(&self, def_id: DefId) -> DefPathHash {
self.resolver.def_path_hash(def_id)
}
#[inline]
fn span_data_to_lines_and_cols(
&mut self,
span: &rustc_span::SpanData,
) -> Option<(Lrc<rustc_span::SourceFile>, usize, rustc_span::BytePos, usize, rustc_span::BytePos)>
{
self.source_map.span_data_to_lines_and_cols(span)
}
}
impl<'a> Resolver<'a> {
pub fn new(
session: &'a Session,
@ -1364,6 +1397,13 @@ impl<'a> Resolver<'a> {
resolver
}
fn create_stable_hashing_context(&self) -> ExpandHasher<'_, 'a> {
ExpandHasher {
source_map: CachingSourceMapView::new(self.session.source_map()),
resolver: self,
}
}
pub fn next_node_id(&mut self) -> NodeId {
let next = self
.next_node_id

40
compiler/rustc_resolve/src/macros.rs
View File

@ -218,14 +218,17 @@ impl<'a> ResolverExpand for Resolver<'a> {
parent_module_id: Option<NodeId>,
) -> ExpnId {
let parent_module = parent_module_id.map(|module_id| self.local_def_id(module_id));
let expn_id = ExpnId::fresh(Some(ExpnData::allow_unstable(
ExpnKind::AstPass(pass),
call_site,
self.session.edition(),
features.into(),
None,
parent_module.map(LocalDefId::to_def_id),
)));
let expn_id = ExpnId::fresh(
ExpnData::allow_unstable(
ExpnKind::AstPass(pass),
call_site,
self.session.edition(),
features.into(),
None,
parent_module.map(LocalDefId::to_def_id),
),
self.create_stable_hashing_context(),
);
let parent_scope = parent_module
.map_or(self.empty_module, |parent_def_id| self.module_map[&parent_def_id]);
@ -287,15 +290,18 @@ impl<'a> ResolverExpand for Resolver<'a> {
)?;
let span = invoc.span();
invoc_id.set_expn_data(ext.expn_data(
parent_scope.expansion,
span,
fast_print_path(path),
res.opt_def_id(),
res.opt_def_id().map(|macro_def_id| {
self.macro_def_scope_from_def_id(macro_def_id).nearest_parent_mod
}),
));
invoc_id.set_expn_data(
ext.expn_data(
parent_scope.expansion,
span,
fast_print_path(path),
res.opt_def_id(),
res.opt_def_id().map(|macro_def_id| {
self.macro_def_scope_from_def_id(macro_def_id).nearest_parent_mod
}),
),
self.create_stable_hashing_context(),
);
if let Res::Def(_, _) = res {
// Gate macro attributes in `#[derive]` output.

283
compiler/rustc_span/src/hygiene.rs
View File

@ -27,19 +27,18 @@
use crate::edition::Edition;
use crate::symbol::{kw, sym, Symbol};
use crate::with_session_globals;
use crate::{BytePos, CachingSourceMapView, HashStableContext, SourceFile, Span, DUMMY_SP};
use crate::{HashStableContext, Span, DUMMY_SP};
use crate::def_id::{CrateNum, DefId, DefPathHash, CRATE_DEF_INDEX, LOCAL_CRATE};
use crate::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::sync::{Lock, Lrc};
use rustc_data_structures::unhash::UnhashMap;
use rustc_macros::HashStable_Generic;
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use std::cell::RefCell;
use std::fmt;
use std::hash::Hash;
use std::thread::LocalKey;
use tracing::*;
/// A `SyntaxContext` represents a chain of pairs `(ExpnId, Transparency)` named "marks".
@ -63,6 +62,10 @@ pub struct SyntaxContextData {
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct ExpnId(u32);
/// A unique hash value associated to an expansion.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Encodable, Decodable, HashStable_Generic)]
pub struct ExpnHash(Fingerprint);
/// A property of a macro expansion that determines how identifiers
/// produced by that expansion are resolved.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Hash, Debug, Encodable, Decodable)]
@ -84,12 +87,13 @@ pub enum Transparency {
}
impl ExpnId {
pub fn fresh(expn_data: Option<ExpnData>) -> Self {
let has_data = expn_data.is_some();
let expn_id = HygieneData::with(|data| data.fresh_expn(expn_data));
if has_data {
update_disambiguator(expn_id);
}
pub fn fresh_empty() -> Self {
HygieneData::with(|data| data.fresh_expn(None))
}
pub fn fresh(expn_data: ExpnData, ctx: impl HashStableContext) -> Self {
let expn_id = HygieneData::with(|data| data.fresh_expn(Some(expn_data)));
update_disambiguator(expn_id, ctx);
expn_id
}
@ -109,13 +113,23 @@ impl ExpnId {
ExpnId(raw)
}
#[inline]
pub fn expn_hash(self) -> ExpnHash {
HygieneData::with(|data| data.expn_hash(self))
}
#[inline]
pub fn from_hash(hash: ExpnHash) -> Option<ExpnId> {
HygieneData::with(|data| data.expn_hash_to_expn_id.get(&hash).copied())
}
#[inline]
pub fn expn_data(self) -> ExpnData {
HygieneData::with(|data| data.expn_data(self).clone())
}
#[inline]
pub fn set_expn_data(self, mut expn_data: ExpnData) {
pub fn set_expn_data(self, mut expn_data: ExpnData, ctx: impl HashStableContext) {
HygieneData::with(|data| {
let old_expn_data = &mut data.expn_data[self.0 as usize];
assert!(old_expn_data.is_none(), "expansion data is reset for an expansion ID");
@ -123,7 +137,7 @@ impl ExpnId {
expn_data.orig_id = Some(self.as_u32());
*old_expn_data = Some(expn_data);
});
update_disambiguator(self)
update_disambiguator(self, ctx)
}
pub fn is_descendant_of(self, ancestor: ExpnId) -> bool {
@ -162,6 +176,8 @@ pub struct HygieneData {
/// between creation of an expansion ID and obtaining its data (e.g. macros are collected
/// first and then resolved later), so we use an `Option` here.
expn_data: Vec<Option<ExpnData>>,
expn_hashes: Vec<ExpnHash>,
expn_hash_to_expn_id: UnhashMap<ExpnHash, ExpnId>,
syntax_context_data: Vec<SyntaxContextData>,
syntax_context_map: FxHashMap<(SyntaxContext, ExpnId, Transparency), SyntaxContext>,
/// Maps the `Fingerprint` of an `ExpnData` to the next disambiguator value.
@ -185,6 +201,9 @@ impl HygieneData {
HygieneData {
expn_data: vec![Some(root_data)],
expn_hashes: vec![ExpnHash(Fingerprint::ZERO)],
expn_hash_to_expn_id: std::iter::once((ExpnHash(Fingerprint::ZERO), ExpnId(0)))
.collect(),
syntax_context_data: vec![SyntaxContextData {
outer_expn: ExpnId::root(),
outer_transparency: Transparency::Opaque,
@ -209,9 +228,15 @@ impl HygieneData {
data.orig_id = Some(raw_id);
}
self.expn_data.push(expn_data);
self.expn_hashes.push(ExpnHash(Fingerprint::ZERO));
ExpnId(raw_id)
}
#[inline]
fn expn_hash(&self, expn_id: ExpnId) -> ExpnHash {
self.expn_hashes[expn_id.0 as usize]
}
fn expn_data(&self, expn_id: ExpnId) -> &ExpnData {
self.expn_data[expn_id.0 as usize].as_ref().expect("no expansion data for an expansion ID")
}
@ -661,16 +686,17 @@ impl Span {
/// other compiler-generated code to set per-span properties like allowed unstable features.
/// The returned span belongs to the created expansion and has the new properties,
/// but its location is inherited from the current span.
pub fn fresh_expansion(self, expn_data: ExpnData) -> Span {
self.fresh_expansion_with_transparency(expn_data, Transparency::Transparent)
pub fn fresh_expansion(self, expn_data: ExpnData, ctx: impl HashStableContext) -> Span {
self.fresh_expansion_with_transparency(expn_data, Transparency::Transparent, ctx)
}
pub fn fresh_expansion_with_transparency(
self,
expn_data: ExpnData,
transparency: Transparency,
ctx: impl HashStableContext,
) -> Span {
let expn_id = ExpnId::fresh(Some(expn_data));
let expn_id = ExpnId::fresh(expn_data, ctx);
HygieneData::with(|data| {
self.with_ctxt(data.apply_mark(SyntaxContext::root(), expn_id, transparency))
})
@ -683,11 +709,13 @@ impl Span {
allow_internal_unstable: Option<Lrc<[Symbol]>>,
reason: DesugaringKind,
edition: Edition,
ctx: impl HashStableContext,
) -> Span {
self.fresh_expansion(ExpnData {
let expn_data = ExpnData {
allow_internal_unstable,
..ExpnData::default(ExpnKind::Desugaring(reason), self, edition, None, None)
})
};
self.fresh_expansion(expn_data, ctx)
}
}
@ -839,6 +867,13 @@ impl ExpnData {
pub fn is_root(&self) -> bool {
matches!(self.kind, ExpnKind::Root)
}
#[inline]
fn hash_expn(&self, ctx: &mut impl HashStableContext) -> Fingerprint {
let mut hasher = StableHasher::new();
self.hash_stable(ctx, &mut hasher);
hasher.finish()
}
}
/// Expansion kind.
@ -985,16 +1020,11 @@ pub struct HygieneEncodeContext {
}
impl HygieneEncodeContext {
pub fn encode<
T,
R,
F: FnMut(&mut T, u32, &SyntaxContextData) -> Result<(), R>,
G: FnMut(&mut T, u32, &ExpnData) -> Result<(), R>,
>(
pub fn encode<T, R>(
&self,
encoder: &mut T,
mut encode_ctxt: F,
mut encode_expn: G,
mut encode_ctxt: impl FnMut(&mut T, u32, &SyntaxContextData) -> Result<(), R>,
mut encode_expn: impl FnMut(&mut T, u32, ExpnData, ExpnHash) -> Result<(), R>,
) -> Result<(), R> {
// When we serialize a `SyntaxContextData`, we may end up serializing
// a `SyntaxContext` that we haven't seen before
@ -1012,7 +1042,7 @@ impl HygieneEncodeContext {
// It's fine to iterate over a HashMap, because the serialization
// of the table that we insert data into doesn't depend on insertion
// order
for_all_ctxts_in(latest_ctxts.into_iter(), |(index, ctxt, data)| {
for_all_ctxts_in(latest_ctxts.into_iter(), |index, ctxt, data| {
if self.serialized_ctxts.lock().insert(ctxt) {
encode_ctxt(encoder, index, data)?;
}
@ -1021,9 +1051,9 @@ impl HygieneEncodeContext {
let latest_expns = { std::mem::take(&mut *self.latest_expns.lock()) };
for_all_expns_in(latest_expns.into_iter(), |index, expn, data| {
for_all_expns_in(latest_expns.into_iter(), |index, expn, data, hash| {
if self.serialized_expns.lock().insert(expn) {
encode_expn(encoder, index, data)?;
encode_expn(encoder, index, data, hash)?;
}
Ok(())
})?;
@ -1046,16 +1076,14 @@ pub struct HygieneDecodeContext {
remapped_expns: Lock<Vec<Option<ExpnId>>>,
}
pub fn decode_expn_id<
'a,
D: Decoder,
F: FnOnce(&mut D, u32) -> Result<ExpnData, D::Error>,
G: FnOnce(CrateNum) -> &'a HygieneDecodeContext,
>(
pub fn decode_expn_id<'a, D: Decoder, G>(
d: &mut D,
mode: ExpnDataDecodeMode<'a, G>,
decode_data: F,
) -> Result<ExpnId, D::Error> {
decode_data: impl FnOnce(&mut D, u32) -> Result<(ExpnData, ExpnHash), D::Error>,
) -> Result<ExpnId, D::Error>
where
G: FnOnce(CrateNum) -> &'a HygieneDecodeContext,
{
let index = u32::decode(d)?;
let context = match mode {
ExpnDataDecodeMode::IncrComp(context) => context,
@ -1083,9 +1111,13 @@ pub fn decode_expn_id<
// Don't decode the data inside `HygieneData::with`, since we need to recursively decode
// other ExpnIds
let mut expn_data = decode_data(d, index)?;
let (mut expn_data, hash) = decode_data(d, index)?;
let expn_id = HygieneData::with(|hygiene_data| {
if let Some(&expn_id) = hygiene_data.expn_hash_to_expn_id.get(&hash) {
return expn_id;
}
let expn_id = ExpnId(hygiene_data.expn_data.len() as u32);
// If we just deserialized an `ExpnData` owned by
@ -1098,6 +1130,9 @@ pub fn decode_expn_id<
}
hygiene_data.expn_data.push(Some(expn_data));
hygiene_data.expn_hashes.push(hash);
let _old_id = hygiene_data.expn_hash_to_expn_id.insert(hash, expn_id);
debug_assert!(_old_id.is_none());
let mut expns = outer_expns.lock();
let new_len = index as usize + 1;
@ -1184,7 +1219,7 @@ pub fn decode_syntax_context<
Ok(new_ctxt)
}
fn for_all_ctxts_in<E, F: FnMut((u32, SyntaxContext, &SyntaxContextData)) -> Result<(), E>>(
fn for_all_ctxts_in<E, F: FnMut(u32, SyntaxContext, &SyntaxContextData) -> Result<(), E>>(
ctxts: impl Iterator<Item = SyntaxContext>,
mut f: F,
) -> Result<(), E> {
@ -1192,20 +1227,26 @@ fn for_all_ctxts_in<E, F: FnMut((u32, SyntaxContext, &SyntaxContextData)) -> Res
ctxts.map(|ctxt| (ctxt, data.syntax_context_data[ctxt.0 as usize].clone())).collect()
});
for (ctxt, data) in all_data.into_iter() {
f((ctxt.0, ctxt, &data))?;
f(ctxt.0, ctxt, &data)?;
}
Ok(())
}
fn for_all_expns_in<E, F: FnMut(u32, ExpnId, &ExpnData) -> Result<(), E>>(
fn for_all_expns_in<E>(
expns: impl Iterator<Item = ExpnId>,
mut f: F,
mut f: impl FnMut(u32, ExpnId, ExpnData, ExpnHash) -> Result<(), E>,
) -> Result<(), E> {
let all_data: Vec<_> = HygieneData::with(|data| {
expns.map(|expn| (expn, data.expn_data[expn.0 as usize].clone())).collect()
expns
.map(|expn| {
let idx = expn.0 as usize;
(expn, data.expn_data[idx].clone(), data.expn_hashes[idx].clone())
})
.collect()
});
for (expn, data) in all_data.into_iter() {
f(expn.0, expn, &data.unwrap_or_else(|| panic!("Missing data for {:?}", expn)))?;
for (expn, data, hash) in all_data.into_iter() {
let data = data.unwrap_or_else(|| panic!("Missing data for {:?}", expn));
f(expn.0, expn, data, hash)?;
}
Ok(())
}
@ -1306,107 +1347,51 @@ impl<D: Decoder> Decodable<D> for SyntaxContext {
/// `set_expn_data`). It is *not* called for foreign `ExpnId`s deserialized
/// from another crate's metadata - since `ExpnData` includes a `krate` field,
/// collisions are only possible between `ExpnId`s within the same crate.
fn update_disambiguator(expn_id: ExpnId) {
/// A `HashStableContext` which hashes the raw id values for `DefId`
/// and `CrateNum`, rather than using their computed stable hash.
///
/// This allows us to use the `HashStable` implementation on `ExpnId`
/// early on in compilation, before we've constructed a `TyCtxt`.
/// The `Fingerprint`s created by this context are not 'stable', since
/// the raw `CrateNum` and `DefId` values for an item may change between
/// sessions due to unrelated changes (e.g. adding/removing an different item).
///
/// However, this is fine for our purposes - we only need to detect
/// when two `ExpnData`s have the same `Fingerprint`. Since the hashes produced
/// by this context still obey the properties of `HashStable`, we have
/// that
/// `hash_stable(expn1, DummyHashStableContext) == hash_stable(expn2, DummyHashStableContext)`
/// iff `hash_stable(expn1, StableHashingContext) == hash_stable(expn2, StableHasingContext)`.
///
/// This is sufficient for determining when we need to update the disambiguator.
struct DummyHashStableContext<'a> {
caching_source_map: CachingSourceMapView<'a>,
}
impl<'a> crate::HashStableContext for DummyHashStableContext<'a> {
#[inline]
fn def_path_hash(&self, def_id: DefId) -> DefPathHash {
DefPathHash(Fingerprint::new(
def_id.krate.as_u32().into(),
def_id.index.as_u32().into(),
))
}
fn expn_id_cache() -> &'static LocalKey<ExpnIdCache> {
// This cache is only used by `DummyHashStableContext`,
// so we won't pollute the cache values of the normal `StableHashingContext`
thread_local! {
static CACHE: ExpnIdCache = const { ExpnIdCache::new(Vec::new()) };
}
&CACHE
}
fn hash_spans(&self) -> bool {
true
}
fn span_data_to_lines_and_cols(
&mut self,
span: &crate::SpanData,
) -> Option<(Lrc<SourceFile>, usize, BytePos, usize, BytePos)> {
self.caching_source_map.span_data_to_lines_and_cols(span)
}
}
let source_map = with_session_globals(|session_globals| {
session_globals.source_map.borrow().as_ref().unwrap().clone()
});
let mut ctx =
DummyHashStableContext { caching_source_map: CachingSourceMapView::new(&source_map) };
let mut hasher = StableHasher::new();
let expn_data = expn_id.expn_data();
fn update_disambiguator(expn_id: ExpnId, mut ctx: impl HashStableContext) {
let mut expn_data = expn_id.expn_data();
// This disambiguator should not have been set yet.
assert_eq!(
expn_data.disambiguator, 0,
"Already set disambiguator for ExpnData: {:?}",
expn_data
);
expn_data.hash_stable(&mut ctx, &mut hasher);
let first_hash = hasher.finish();
let mut expn_hash = expn_data.hash_expn(&mut ctx);
let modified = HygieneData::with(|data| {
let disambiguator = HygieneData::with(|data| {
// If this is the first ExpnData with a given hash, then keep our
// disambiguator at 0 (the default u32 value)
let disambig = data.expn_data_disambiguators.entry(first_hash).or_default();
data.expn_data[expn_id.0 as usize].as_mut().unwrap().disambiguator = *disambig;
let disambig = data.expn_data_disambiguators.entry(expn_hash).or_default();
let disambiguator = *disambig;
*disambig += 1;
*disambig != 1
disambiguator
});
if modified {
debug!("Set disambiguator for {:?} (hash {:?})", expn_id, first_hash);
debug!("expn_data = {:?}", expn_id.expn_data());
if disambiguator != 0 {
debug!("Set disambiguator for {:?} (hash {:?})", expn_id, expn_hash);
debug!("expn_data = {:?}", expn_data);
expn_data.disambiguator = disambiguator;
expn_hash = expn_data.hash_expn(&mut ctx);
// Verify that the new disambiguator makes the hash unique
#[cfg(debug_assertions)]
{
hasher = StableHasher::new();
expn_id.expn_data().hash_stable(&mut ctx, &mut hasher);
let new_hash: Fingerprint = hasher.finish();
HygieneData::with(|data| {
assert_eq!(
data.expn_data_disambiguators.get(&new_hash),
None,
"Hash collision after disambiguator update!",
);
});
};
HygieneData::with(|data| {
assert_eq!(
data.expn_data_disambiguators.get(&expn_hash),
None,
"Hash collision after disambiguator update!",
);
});
}
let expn_hash = ExpnHash(expn_hash);
HygieneData::with(|data| {
data.expn_data[expn_id.0 as usize].as_mut().unwrap().disambiguator = disambiguator;
debug_assert_eq!(data.expn_hashes[expn_id.0 as usize].0, Fingerprint::ZERO);
data.expn_hashes[expn_id.0 as usize] = expn_hash;
let _old_id = data.expn_hash_to_expn_id.insert(expn_hash, expn_id);
debug_assert!(_old_id.is_none());
});
}
impl<CTX: HashStableContext> HashStable<CTX> for SyntaxContext {
@ -1425,43 +1410,15 @@ impl<CTX: HashStableContext> HashStable<CTX> for SyntaxContext {
}
}
pub type ExpnIdCache = RefCell<Vec<Option<Fingerprint>>>;
impl<CTX: HashStableContext> HashStable<CTX> for ExpnId {
fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
const TAG_ROOT: u8 = 0;
const TAG_NOT_ROOT: u8 = 1;
if *self == ExpnId::root() {
TAG_ROOT.hash_stable(ctx, hasher);
return;
}
// Since the same expansion context is usually referenced many
// times, we cache a stable hash of it and hash that instead of
// recursing every time.
let index = self.as_u32() as usize;
let res = CTX::expn_id_cache().with(|cache| cache.borrow().get(index).copied().flatten());
if let Some(res) = res {
res.hash_stable(ctx, hasher);
let hash = if *self == ExpnId::root() {
// Avoid fetching TLS storage for a trivial often-used value.
Fingerprint::ZERO
} else {
let new_len = index + 1;
self.expn_hash().0
};
let mut sub_hasher = StableHasher::new();
TAG_NOT_ROOT.hash_stable(ctx, &mut sub_hasher);
self.expn_data().hash_stable(ctx, &mut sub_hasher);
let sub_hash: Fingerprint = sub_hasher.finish();
CTX::expn_id_cache().with(|cache| {
let mut cache = cache.borrow_mut();
if cache.len() < new_len {
cache.resize(new_len, None);
}
let prev = cache[index].replace(sub_hash);
assert_eq!(prev, None, "Cache slot was filled");
});
sub_hash.hash_stable(ctx, hasher);
}
hash.hash_stable(ctx, hasher);
}
}

10
compiler/rustc_span/src/lib.rs
View File

@ -37,8 +37,8 @@ pub mod edition;
use edition::Edition;
pub mod hygiene;
use hygiene::Transparency;
pub use hygiene::{DesugaringKind, ExpnData, ExpnId, ExpnKind, ForLoopLoc, MacroKind};
pub use hygiene::{ExpnIdCache, SyntaxContext};
pub use hygiene::{DesugaringKind, ExpnKind, ForLoopLoc, MacroKind};
pub use hygiene::{ExpnData, ExpnHash, ExpnId, SyntaxContext};
pub mod def_id;
use def_id::{CrateNum, DefId, DefPathHash, LOCAL_CRATE};
pub mod lev_distance;
@ -61,7 +61,6 @@ use std::hash::Hash;
use std::ops::{Add, Range, Sub};
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::thread::LocalKey;
use md5::Md5;
use sha1::Digest;
@ -1956,11 +1955,6 @@ impl InnerSpan {
/// instead of implementing everything in rustc_middle.
pub trait HashStableContext {
fn def_path_hash(&self, def_id: DefId) -> DefPathHash;
/// Obtains a cache for storing the `Fingerprint` of an `ExpnId`.
/// This method allows us to have multiple `HashStableContext` implementations
/// that hash things in a different way, without the results of one polluting
/// the cache of the other.
fn expn_id_cache() -> &'static LocalKey<ExpnIdCache>;
fn hash_spans(&self) -> bool;
fn span_data_to_lines_and_cols(
&mut self,