user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

hygiene: ExpnInfo -> ExpnData

Browse source 
For naming consistency with everything else in this area
This commit is contained in:
Vadim Petrochenkov 2019-08-13 23:56:42 +03:00
parent 650f19aeae
commit 136db2235a
25 changed files with 168 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/librustc/hir/lowering.rs
View file

@ -67,7 +67,7 @@ use syntax::errors;
use syntax::ext::base::SpecialDerives;
use syntax::ext::hygiene::ExpnId;
use syntax::print::pprust;
use syntax::source_map::{respan, ExpnInfo, ExpnKind, DesugaringKind, Spanned};
use syntax::source_map::{respan, ExpnData, ExpnKind, DesugaringKind, Spanned};
use syntax::symbol::{kw, sym, Symbol};
use syntax::tokenstream::{TokenStream, TokenTree};
use syntax::parse::token::{self, Token};
@ -704,9 +704,9 @@ impl<'a> LoweringContext<'a> {
span: Span,
allow_internal_unstable: Option<Lrc<[Symbol]>>,
) -> Span {
span.fresh_expansion(ExpnInfo {
span.fresh_expansion(ExpnData {
allow_internal_unstable,
..ExpnInfo::default(ExpnKind::Desugaring(reason), span, self.sess.edition())
..ExpnData::default(ExpnKind::Desugaring(reason), span, self.sess.edition())
})
}

2
src/librustc/ich/hcx.rs
View file

@ -370,7 +370,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for Span {
}
let mut hasher = StableHasher::new();
expn_id.expn_info().hash_stable(hcx, &mut hasher);
expn_id.expn_data().hash_stable(hcx, &mut hasher);
let sub_hash: Fingerprint = hasher.finish();
let sub_hash = sub_hash.to_smaller_hash();
cache.borrow_mut().insert(expn_id, sub_hash);

2
src/librustc/ich/impls_syntax.rs
View file

@ -397,7 +397,7 @@ impl_stable_hash_for!(enum ::syntax_pos::hygiene::Transparency {
Opaque,
});
impl_stable_hash_for!(struct ::syntax_pos::hygiene::ExpnInfo {
impl_stable_hash_for!(struct ::syntax_pos::hygiene::ExpnData {
kind,
parent -> _,
call_site,

8
src/librustc/lint/internal.rs
View file

@ -227,10 +227,10 @@ impl EarlyLintPass for LintPassImpl {
if let ItemKind::Impl(_, _, _, _, Some(lint_pass), _, _) = &item.node {
if let Some(last) = lint_pass.path.segments.last() {
if last.ident.name == sym::LintPass {
let expn_info = lint_pass.path.span.ctxt().outer_expn_info();
let call_site = expn_info.call_site;
if expn_info.kind.descr() != sym::impl_lint_pass &&
call_site.ctxt().outer_expn_info().kind.descr() != sym::declare_lint_pass {
let expn_data = lint_pass.path.span.ctxt().outer_expn_data();
let call_site = expn_data.call_site;
if expn_data.kind.descr() != sym::impl_lint_pass &&
call_site.ctxt().outer_expn_data().kind.descr() != sym::declare_lint_pass {
cx.struct_span_lint(
LINT_PASS_IMPL_WITHOUT_MACRO,
lint_pass.path.span,

10
src/librustc/lint/mod.rs
View file

@ -885,16 +885,16 @@ pub fn provide(providers: &mut Providers<'_>) {
/// This is used to test whether a lint should not even begin to figure out whether it should
/// be reported on the current node.
pub fn in_external_macro(sess: &Session, span: Span) -> bool {
let expn_info = span.ctxt().outer_expn_info();
match expn_info.kind {
let expn_data = span.ctxt().outer_expn_data();
match expn_data.kind {
ExpnKind::Root | ExpnKind::Desugaring(DesugaringKind::ForLoop) => false,
ExpnKind::Desugaring(_) => true, // well, it's "external"
ExpnKind::Macro(MacroKind::Bang, _) => {
if expn_info.def_site.is_dummy() {
if expn_data.def_site.is_dummy() {
// dummy span for the def_site means it's an external macro
return true;
}
match sess.source_map().span_to_snippet(expn_info.def_site) {
match sess.source_map().span_to_snippet(expn_data.def_site) {
Ok(code) => !code.starts_with("macro_rules"),
// no snippet = external macro or compiler-builtin expansion
Err(_) => true,
@ -906,7 +906,7 @@ pub fn in_external_macro(sess: &Session, span: Span) -> bool {
/// Returns whether `span` originates in a derive macro's expansion
pub fn in_derive_expansion(span: Span) -> bool {
if let ExpnKind::Macro(MacroKind::Derive, _) = span.ctxt().outer_expn_info().kind {
if let ExpnKind::Macro(MacroKind::Derive, _) = span.ctxt().outer_expn_data().kind {
return true;
}
false

6
src/librustc/traits/error_reporting.rs
View file

@ -61,9 +61,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
// We want to ignore desugarings here: spans are equivalent even
// if one is the result of a desugaring and the other is not.
let mut span = error.obligation.cause.span;
let expn_info = span.ctxt().outer_expn_info();
if let ExpnKind::Desugaring(_) = expn_info.kind {
span = expn_info.call_site;
let expn_data = span.ctxt().outer_expn_data();
if let ExpnKind::Desugaring(_) = expn_data.kind {
span = expn_data.call_site;
}
error_map.entry(span).or_default().push(

68
src/librustc/ty/query/on_disk_cache.rs
View file

@ -23,16 +23,16 @@ use std::mem;
use syntax::ast::NodeId;
use syntax::source_map::{SourceMap, StableSourceFileId};
use syntax_pos::{BytePos, Span, DUMMY_SP, SourceFile};
use syntax_pos::hygiene::{ExpnId, SyntaxContext, ExpnInfo};
use syntax_pos::hygiene::{ExpnId, SyntaxContext, ExpnData};
const TAG_FILE_FOOTER: u128 = 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
const TAG_CLEAR_CROSS_CRATE_CLEAR: u8 = 0;
const TAG_CLEAR_CROSS_CRATE_SET: u8 = 1;
const TAG_NO_EXPANSION_INFO: u8 = 0;
const TAG_EXPANSION_INFO_SHORTHAND: u8 = 1;
const TAG_EXPANSION_INFO_INLINE: u8 = 2;
const TAG_NO_EXPN_DATA: u8 = 0;
const TAG_EXPN_DATA_SHORTHAND: u8 = 1;
const TAG_EXPN_DATA_INLINE: u8 = 2;
const TAG_VALID_SPAN: u8 = 0;
const TAG_INVALID_SPAN: u8 = 1;
@ -58,7 +58,7 @@ pub struct OnDiskCache<'sess> {
// These two fields caches that are populated lazily during decoding.
file_index_to_file: Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
synthetic_expansion_infos: Lock<FxHashMap<AbsoluteBytePos, SyntaxContext>>,
synthetic_syntax_contexts: Lock<FxHashMap<AbsoluteBytePos, SyntaxContext>>,
// A map from dep-node to the position of the cached query result in
// `serialized_data`.
@ -135,7 +135,7 @@ impl<'sess> OnDiskCache<'sess> {
current_diagnostics: Default::default(),
query_result_index: footer.query_result_index.into_iter().collect(),
prev_diagnostics_index: footer.diagnostics_index.into_iter().collect(),
synthetic_expansion_infos: Default::default(),
synthetic_syntax_contexts: Default::default(),
alloc_decoding_state: AllocDecodingState::new(footer.interpret_alloc_index),
}
}
@ -151,7 +151,7 @@ impl<'sess> OnDiskCache<'sess> {
current_diagnostics: Default::default(),
query_result_index: Default::default(),
prev_diagnostics_index: Default::default(),
synthetic_expansion_infos: Default::default(),
synthetic_syntax_contexts: Default::default(),
alloc_decoding_state: AllocDecodingState::new(Vec::new()),
}
}
@ -185,7 +185,7 @@ impl<'sess> OnDiskCache<'sess> {
encoder,
type_shorthands: Default::default(),
predicate_shorthands: Default::default(),
expn_info_shorthands: Default::default(),
expn_data_shorthands: Default::default(),
interpret_allocs: Default::default(),
interpret_allocs_inverse: Vec::new(),
source_map: CachingSourceMapView::new(tcx.sess.source_map()),
@ -383,7 +383,7 @@ impl<'sess> OnDiskCache<'sess> {
cnum_map: self.cnum_map.get(),
file_index_to_file: &self.file_index_to_file,
file_index_to_stable_id: &self.file_index_to_stable_id,
synthetic_expansion_infos: &self.synthetic_expansion_infos,
synthetic_syntax_contexts: &self.synthetic_syntax_contexts,
alloc_decoding_session: self.alloc_decoding_state.new_decoding_session(),
};
@ -440,7 +440,7 @@ struct CacheDecoder<'a, 'tcx> {
opaque: opaque::Decoder<'a>,
source_map: &'a SourceMap,
cnum_map: &'a IndexVec<CrateNum, Option<CrateNum>>,
synthetic_expansion_infos: &'a Lock<FxHashMap<AbsoluteBytePos, SyntaxContext>>,
synthetic_syntax_contexts: &'a Lock<FxHashMap<AbsoluteBytePos, SyntaxContext>>,
file_index_to_file: &'a Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, StableSourceFileId>,
alloc_decoding_session: AllocDecodingSession<'a>,
@ -586,37 +586,37 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for CacheDecoder<'a, 'tcx> {
let lo = file_lo.lines[line_lo - 1] + col_lo;
let hi = lo + len;
let expn_info_tag = u8::decode(self)?;
let expn_data_tag = u8::decode(self)?;
// FIXME(mw): This method does not restore `ExpnInfo::parent` or
// FIXME(mw): This method does not restore `ExpnData::parent` or
// `SyntaxContextData::prev_ctxt` or `SyntaxContextData::opaque`. These things
// don't seem to be used after HIR lowering, so everything should be fine
// as long as incremental compilation does not kick in before that.
let location = || Span::with_root_ctxt(lo, hi);
let recover_from_expn_info = |this: &Self, expn_info, pos| {
let span = location().fresh_expansion(expn_info);
this.synthetic_expansion_infos.borrow_mut().insert(pos, span.ctxt());
let recover_from_expn_data = |this: &Self, expn_data, pos| {
let span = location().fresh_expansion(expn_data);
this.synthetic_syntax_contexts.borrow_mut().insert(pos, span.ctxt());
span
};
Ok(match expn_info_tag {
TAG_NO_EXPANSION_INFO => {
Ok(match expn_data_tag {
TAG_NO_EXPN_DATA => {
location()
}
TAG_EXPANSION_INFO_INLINE => {
let expn_info = Decodable::decode(self)?;
recover_from_expn_info(
self, expn_info, AbsoluteBytePos::new(self.opaque.position())
TAG_EXPN_DATA_INLINE => {
let expn_data = Decodable::decode(self)?;
recover_from_expn_data(
self, expn_data, AbsoluteBytePos::new(self.opaque.position())
)
}
TAG_EXPANSION_INFO_SHORTHAND => {
TAG_EXPN_DATA_SHORTHAND => {
let pos = AbsoluteBytePos::decode(self)?;
let cached_ctxt = self.synthetic_expansion_infos.borrow().get(&pos).cloned();
let cached_ctxt = self.synthetic_syntax_contexts.borrow().get(&pos).cloned();
if let Some(ctxt) = cached_ctxt {
Span::new(lo, hi, ctxt)
} else {
let expn_info =
self.with_position(pos.to_usize(), |this| ExpnInfo::decode(this))?;
recover_from_expn_info(self, expn_info, pos)
let expn_data =
self.with_position(pos.to_usize(), |this| ExpnData::decode(this))?;
recover_from_expn_data(self, expn_data, pos)
}
}
_ => {
@ -725,7 +725,7 @@ struct CacheEncoder<'a, 'tcx, E: ty_codec::TyEncoder> {
encoder: &'a mut E,
type_shorthands: FxHashMap<Ty<'tcx>, usize>,
predicate_shorthands: FxHashMap<ty::Predicate<'tcx>, usize>,
expn_info_shorthands: FxHashMap<ExpnId, AbsoluteBytePos>,
expn_data_shorthands: FxHashMap<ExpnId, AbsoluteBytePos>,
interpret_allocs: FxHashMap<interpret::AllocId, usize>,
interpret_allocs_inverse: Vec<interpret::AllocId>,
source_map: CachingSourceMapView<'tcx>,
@ -817,17 +817,17 @@ where
len.encode(self)?;
if span_data.ctxt == SyntaxContext::root() {
TAG_NO_EXPANSION_INFO.encode(self)
TAG_NO_EXPN_DATA.encode(self)
} else {
let (expn_id, expn_info) = span_data.ctxt.outer_expn_with_info();
if let Some(pos) = self.expn_info_shorthands.get(&expn_id).cloned() {
TAG_EXPANSION_INFO_SHORTHAND.encode(self)?;
let (expn_id, expn_data) = span_data.ctxt.outer_expn_with_data();
if let Some(pos) = self.expn_data_shorthands.get(&expn_id).cloned() {
TAG_EXPN_DATA_SHORTHAND.encode(self)?;
pos.encode(self)
} else {
TAG_EXPANSION_INFO_INLINE.encode(self)?;
TAG_EXPN_DATA_INLINE.encode(self)?;
let pos = AbsoluteBytePos::new(self.position());
self.expn_info_shorthands.insert(expn_id, pos);
expn_info.encode(self)
self.expn_data_shorthands.insert(expn_id, pos);
expn_data.encode(self)
}
}
}