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};
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())
})
}
}
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);
Opaque,
});
-impl_stable_hash_for!(struct ::syntax_pos::hygiene::ExpnInfo {
+impl_stable_hash_for!(struct ::syntax_pos::hygiene::ExpnData {
kind,
parent -> _,
call_site,
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,
/// 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,
/// 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
// 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(
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;
// 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`.
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),
}
}
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()),
}
}
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()),
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(),
};
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>,
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)
}
}
_ => {
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>,
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)
}
}
}
}
}
Ok(SharedEmitterMessage::InlineAsmError(cookie, msg)) => {
- sess.span_err(ExpnId::from_u32(cookie).expn_info().call_site, &msg)
+ sess.span_err(ExpnId::from_u32(cookie).expn_data().call_site, &msg)
}
Ok(SharedEmitterMessage::AbortIfErrors) => {
sess.abort_if_errors();
// trigger in situations that macro authors shouldn't have to care about, e.g.,
// when a parenthesized token tree matched in one macro expansion is matched as
// an expression in another and used as a fn/method argument (Issue #47775)
- if e.span.ctxt().outer_expn_info().call_site.from_expansion() {
+ if e.span.ctxt().outer_expn_data().call_site.from_expansion() {
return;
}
let msg = format!("{} argument", call_kind);
use syntax::ext::base::{self, Indeterminate, SpecialDerives};
use syntax::ext::base::{MacroKind, SyntaxExtension};
use syntax::ext::expand::{AstFragment, Invocation, InvocationKind};
-use syntax::ext::hygiene::{self, ExpnId, ExpnInfo, ExpnKind};
+use syntax::ext::hygiene::{self, ExpnId, ExpnData, ExpnKind};
use syntax::ext::tt::macro_rules;
use syntax::feature_gate::{emit_feature_err, is_builtin_attr_name};
use syntax::feature_gate::GateIssue;
}
fn get_module_scope(&mut self, id: ast::NodeId) -> ExpnId {
- let expn_id = ExpnId::fresh(Some(ExpnInfo::default(
+ let expn_id = ExpnId::fresh(Some(ExpnData::default(
ExpnKind::Macro(MacroKind::Attr, sym::test_case), DUMMY_SP, self.session.edition()
)));
let module = self.module_map[&self.definitions.local_def_id(id)];
let (ext, res) = self.smart_resolve_macro_path(path, kind, parent_scope, force)?;
let span = invoc.span();
- invoc.expansion_data.id.set_expn_info(
- ext.expn_info(parent_scope.expansion, span, fast_print_path(path))
+ invoc.expansion_data.id.set_expn_data(
+ ext.expn_data(parent_scope.expansion, span, fast_print_path(path))
);
if let Res::Def(_, def_id) = res {
// Possibly apply the macro helper hack
if kind == Some(MacroKind::Bang) && path.len() == 1 &&
- path[0].ident.span.ctxt().outer_expn_info().local_inner_macros {
+ path[0].ident.span.ctxt().outer_expn_data().local_inner_macros {
let root = Ident::new(kw::DollarCrate, path[0].ident.span);
path.insert(0, Segment::from_ident(root));
}
use errors::{DiagnosticBuilder, DiagnosticId};
use smallvec::{smallvec, SmallVec};
use syntax_pos::{FileName, Span, MultiSpan, DUMMY_SP};
-use syntax_pos::hygiene::{ExpnInfo, ExpnKind};
+use syntax_pos::hygiene::{ExpnData, ExpnKind};
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sync::{self, Lrc};
SyntaxExtension::default(SyntaxExtensionKind::NonMacroAttr { mark_used }, edition)
}
- pub fn expn_info(&self, parent: ExpnId, call_site: Span, descr: Symbol) -> ExpnInfo {
- ExpnInfo {
+ pub fn expn_data(&self, parent: ExpnId, call_site: Span, descr: Symbol) -> ExpnData {
+ ExpnData {
kind: ExpnKind::Macro(self.macro_kind(), descr),
parent,
call_site,
/// One of these is made during expansion and incrementally updated as we go;
/// when a macro expansion occurs, the resulting nodes have the `backtrace()
-/// -> expn_info` of their expansion context stored into their span.
+/// -> expn_data` of their expansion context stored into their span.
pub struct ExtCtxt<'a> {
pub parse_sess: &'a parse::ParseSess,
pub ecfg: expand::ExpansionConfig<'a>,
pub fn parse_sess(&self) -> &'a parse::ParseSess { self.parse_sess }
pub fn cfg(&self) -> &ast::CrateConfig { &self.parse_sess.config }
pub fn call_site(&self) -> Span {
- self.current_expansion.id.expn_info().call_site
+ self.current_expansion.id.expn_data().call_site
}
pub fn backtrace(&self) -> SyntaxContext {
SyntaxContext::root().apply_mark(self.current_expansion.id)
let mut ctxt = self.backtrace();
let mut last_macro = None;
loop {
- let expn_info = ctxt.outer_expn_info();
+ let expn_data = ctxt.outer_expn_data();
// Stop going up the backtrace once include! is encountered
- if expn_info.is_root() || expn_info.kind.descr() == sym::include {
+ if expn_data.is_root() || expn_data.kind.descr() == sym::include {
break;
}
- ctxt = expn_info.call_site.ctxt();
- last_macro = Some(expn_info.call_site);
+ ctxt = expn_data.call_site.ctxt();
+ last_macro = Some(expn_data.call_site);
}
last_macro
}
use crate::config::StripUnconfigured;
use crate::ext::base::*;
use crate::ext::proc_macro::collect_derives;
-use crate::ext::hygiene::{ExpnId, SyntaxContext, ExpnInfo, ExpnKind};
+use crate::ext::hygiene::{ExpnId, SyntaxContext, ExpnData, ExpnKind};
use crate::ext::tt::macro_rules::annotate_err_with_kind;
use crate::ext::placeholders::{placeholder, PlaceholderExpander};
use crate::feature_gate::{self, Features, GateIssue, is_builtin_attr, emit_feature_err};
}
if self.cx.current_expansion.depth > self.cx.ecfg.recursion_limit {
- let info = self.cx.current_expansion.id.expn_info();
+ let expn_data = self.cx.current_expansion.id.expn_data();
let suggested_limit = self.cx.ecfg.recursion_limit * 2;
- let mut err = self.cx.struct_span_err(info.call_site,
+ let mut err = self.cx.struct_span_err(expn_data.call_site,
&format!("recursion limit reached while expanding the macro `{}`",
- info.kind.descr()));
+ expn_data.kind.descr()));
err.help(&format!(
"consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate",
suggested_limit));
impl<'a, 'b> InvocationCollector<'a, 'b> {
fn collect(&mut self, fragment_kind: AstFragmentKind, kind: InvocationKind) -> AstFragment {
- // Expansion info for all the collected invocations is set upon their resolution,
+ // Expansion data for all the collected invocations is set upon their resolution,
// with exception of the derive container case which is not resolved and can get
- // its expansion info immediately.
- let expn_info = match &kind {
- InvocationKind::DeriveContainer { item, .. } => Some(ExpnInfo {
+ // its expansion data immediately.
+ let expn_data = match &kind {
+ InvocationKind::DeriveContainer { item, .. } => Some(ExpnData {
parent: self.cx.current_expansion.id,
- ..ExpnInfo::default(
+ ..ExpnData::default(
ExpnKind::Macro(MacroKind::Attr, sym::derive),
item.span(), self.cx.parse_sess.edition,
)
}),
_ => None,
};
- let expn_id = ExpnId::fresh(expn_info);
+ let expn_id = ExpnId::fresh(expn_data);
self.invocations.push(Invocation {
kind,
fragment_kind,
impl<'a> Rustc<'a> {
pub fn new(cx: &'a ExtCtxt<'_>) -> Self {
// No way to determine def location for a proc macro right now, so use call location.
- let location = cx.current_expansion.id.expn_info().call_site;
+ let location = cx.current_expansion.id.expn_data().call_site;
let to_span = |transparency| {
location.with_ctxt(
SyntaxContext::root()
included_mod_stack: Lock::new(vec![]),
source_map,
buffered_lints: Lock::new(vec![]),
- edition: ExpnId::root().expn_info().edition,
+ edition: ExpnId::root().expn_data().edition,
ambiguous_block_expr_parse: Lock::new(FxHashMap::default()),
param_attr_spans: Lock::new(Vec::new()),
let_chains_spans: Lock::new(Vec::new()),
//! information, source code snippets, etc.
pub use syntax_pos::*;
-pub use syntax_pos::hygiene::{ExpnKind, ExpnInfo};
+pub use syntax_pos::hygiene::{ExpnKind, ExpnData};
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stable_hasher::StableHasher;
/// Returns the span itself if it doesn't come from a macro expansion,
/// otherwise return the call site span up to the `enclosing_sp` by
-/// following the `expn_info` chain.
+/// following the `expn_data` chain.
pub fn original_sp(sp: Span, enclosing_sp: Span) -> Span {
- let expn_info1 = sp.ctxt().outer_expn_info();
- let expn_info2 = enclosing_sp.ctxt().outer_expn_info();
- if expn_info1.is_root() ||
- !expn_info2.is_root() && expn_info1.call_site == expn_info2.call_site {
+ let expn_data1 = sp.ctxt().outer_expn_data();
+ let expn_data2 = enclosing_sp.ctxt().outer_expn_data();
+ if expn_data1.is_root() ||
+ !expn_data2.is_root() && expn_data1.call_site == expn_data2.call_site {
sp
} else {
- original_sp(expn_info1.call_site, enclosing_sp)
+ original_sp(expn_data1.call_site, enclosing_sp)
}
}
match annitem.node {
ItemKind::Struct(_, Generics { ref params, .. }) |
ItemKind::Enum(_, Generics { ref params, .. }) => {
- let container_id = cx.current_expansion.id.expn_info().parent;
+ let container_id = cx.current_expansion.id.expn_data().parent;
if cx.resolver.has_derives(container_id, SpecialDerives::COPY) &&
!params.iter().any(|param| match param.kind {
ast::GenericParamKind::Type { .. } => true,
mitem: &MetaItem,
item: &Annotatable,
push: &mut dyn FnMut(Annotatable)) {
- cx.resolver.add_derives(cx.current_expansion.id.expn_info().parent, SpecialDerives::EQ);
+ cx.resolver.add_derives(cx.current_expansion.id.expn_data().parent, SpecialDerives::EQ);
let inline = cx.meta_word(span, sym::inline);
let hidden = cx.meta_list_item_word(span, sym::hidden);
mitem: &MetaItem,
item: &Annotatable,
push: &mut dyn FnMut(Annotatable)) {
- cx.resolver.add_derives(cx.current_expansion.id.expn_info().parent, SpecialDerives::PARTIAL_EQ);
+ cx.resolver.add_derives(cx.current_expansion.id.expn_data().parent, SpecialDerives::PARTIAL_EQ);
// structures are equal if all fields are equal, and non equal, if
// any fields are not equal or if the enum variants are different
return;
}
};
- let container_id = cx.current_expansion.id.expn_info().parent;
+ let container_id = cx.current_expansion.id.expn_data().parent;
let is_always_copy =
cx.resolver.has_derives(container_id, SpecialDerives::COPY) &&
has_no_type_params;
use syntax::symbol::sym;
use syntax::tokenstream::*;
use syntax_pos::{Span, DUMMY_SP};
-use syntax_pos::hygiene::{ExpnInfo, ExpnKind, MacroKind};
+use syntax_pos::hygiene::{ExpnData, ExpnKind, MacroKind};
use std::mem;
) {
if !named_exts.is_empty() {
let mut extra_items = Vec::new();
- let span = DUMMY_SP.fresh_expansion(ExpnInfo::allow_unstable(
+ let span = DUMMY_SP.fresh_expansion(ExpnData::allow_unstable(
ExpnKind::Macro(MacroKind::Attr, sym::plugin), DUMMY_SP, edition,
[sym::rustc_attrs][..].into(),
));
use smallvec::smallvec;
use syntax::ast::{self, Ident};
use syntax::attr;
-use syntax::source_map::{ExpnInfo, ExpnKind, respan};
+use syntax::source_map::{ExpnData, ExpnKind, respan};
use syntax::ext::base::{ExtCtxt, MacroKind};
use syntax::ext::expand::{AstFragment, ExpansionConfig};
use syntax::ext::proc_macro::is_proc_macro_attr;
custom_attrs: &[ProcMacroDef],
custom_macros: &[ProcMacroDef],
) -> P<ast::Item> {
- let span = DUMMY_SP.fresh_expansion(ExpnInfo::allow_unstable(
+ let span = DUMMY_SP.fresh_expansion(ExpnData::allow_unstable(
ExpnKind::Macro(MacroKind::Attr, sym::proc_macro), DUMMY_SP, cx.parse_sess.edition,
[sym::rustc_attrs, sym::proc_macro_internals][..].into(),
));
use syntax::edition::Edition;
use syntax::ext::hygiene::MacroKind;
use syntax::ptr::P;
-use syntax::source_map::{ExpnInfo, ExpnKind, dummy_spanned, respan};
+use syntax::source_map::{ExpnData, ExpnKind, dummy_spanned, respan};
use syntax::symbol::{Ident, Symbol, kw, sym};
use syntax_pos::DUMMY_SP;
// the prelude.
let name = names[0];
- let span = DUMMY_SP.fresh_expansion(ExpnInfo::allow_unstable(
+ let span = DUMMY_SP.fresh_expansion(ExpnData::allow_unstable(
ExpnKind::Macro(MacroKind::Attr, sym::std_inject), DUMMY_SP, edition,
[sym::prelude_import][..].into(),
));
use syntax::mut_visit::{*, ExpectOne};
use syntax::parse::ParseSess;
use syntax::ptr::P;
-use syntax::source_map::{ExpnInfo, ExpnKind, dummy_spanned};
+use syntax::source_map::{ExpnData, ExpnKind, dummy_spanned};
use syntax::symbol::{kw, sym, Symbol};
use syntax_pos::{Span, DUMMY_SP};
// #![main]
// test::test_main_static(&[..tests]);
// }
- let sp = DUMMY_SP.fresh_expansion(ExpnInfo::allow_unstable(
+ let sp = DUMMY_SP.fresh_expansion(ExpnData::allow_unstable(
ExpnKind::Macro(MacroKind::Attr, sym::test_case), DUMMY_SP, cx.ext_cx.parse_sess.edition,
[sym::main, sym::test, sym::rustc_attrs][..].into(),
));
//
// This explains why `HygieneData`, `SyntaxContext` and `ExpnId` have interfaces
// with a certain amount of redundancy in them. For example,
-// `SyntaxContext::outer_expn_info` combines `SyntaxContext::outer` and
-// `ExpnId::expn_info` so that two `HygieneData` accesses can be performed within
+// `SyntaxContext::outer_expn_data` combines `SyntaxContext::outer` and
+// `ExpnId::expn_data` so that two `HygieneData` accesses can be performed within
// a single `HygieneData::with` call.
//
// It also explains why many functions appear in `HygieneData` and again in
}
impl ExpnId {
- pub fn fresh(expn_info: Option<ExpnInfo>) -> Self {
- HygieneData::with(|data| data.fresh_expn(expn_info))
+ pub fn fresh(expn_data: Option<ExpnData>) -> Self {
+ HygieneData::with(|data| data.fresh_expn(expn_data))
}
/// The ID of the theoretical expansion that generates freshly parsed, unexpanded AST.
}
#[inline]
- pub fn expn_info(self) -> ExpnInfo {
- HygieneData::with(|data| data.expn_info(self).clone())
+ pub fn expn_data(self) -> ExpnData {
+ HygieneData::with(|data| data.expn_data(self).clone())
}
#[inline]
- pub fn set_expn_info(self, info: ExpnInfo) {
+ pub fn set_expn_data(self, expn_data: ExpnData) {
HygieneData::with(|data| {
- let old_info = &mut data.expn_data[self.0 as usize];
- assert!(old_info.is_none(), "expansion info is reset for an expansion ID");
- *old_info = Some(info);
+ 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");
+ *old_expn_data = Some(expn_data);
})
}
#[inline]
pub fn looks_like_proc_macro_derive(self) -> bool {
HygieneData::with(|data| {
- let expn_info = data.expn_info(self);
- if let ExpnKind::Macro(MacroKind::Derive, _) = expn_info.kind {
- return expn_info.default_transparency == Transparency::Opaque;
+ let expn_data = data.expn_data(self);
+ if let ExpnKind::Macro(MacroKind::Derive, _) = expn_data.kind {
+ return expn_data.default_transparency == Transparency::Opaque;
}
false
})
#[derive(Debug)]
crate struct HygieneData {
- /// Each expansion should have an associated expansion info, but sometimes there's a delay
- /// between creation of an expansion ID and obtaining its info (e.g. macros are collected
+ /// Each expansion should have an associated expansion data, but sometimes there's a delay
+ /// 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<ExpnInfo>>,
+ expn_data: Vec<Option<ExpnData>>,
syntax_context_data: Vec<SyntaxContextData>,
syntax_context_map: FxHashMap<(SyntaxContext, ExpnId, Transparency), SyntaxContext>,
}
impl HygieneData {
crate fn new(edition: Edition) -> Self {
HygieneData {
- expn_data: vec![Some(ExpnInfo::default(ExpnKind::Root, DUMMY_SP, edition))],
+ expn_data: vec![Some(ExpnData::default(ExpnKind::Root, DUMMY_SP, edition))],
syntax_context_data: vec![SyntaxContextData {
outer_expn: ExpnId::root(),
outer_transparency: Transparency::Opaque,
GLOBALS.with(|globals| f(&mut *globals.hygiene_data.borrow_mut()))
}
- fn fresh_expn(&mut self, expn_info: Option<ExpnInfo>) -> ExpnId {
- self.expn_data.push(expn_info);
+ fn fresh_expn(&mut self, expn_data: Option<ExpnData>) -> ExpnId {
+ self.expn_data.push(expn_data);
ExpnId(self.expn_data.len() as u32 - 1)
}
- fn expn_info(&self, expn_id: ExpnId) -> &ExpnInfo {
+ fn expn_data(&self, expn_id: ExpnId) -> &ExpnData {
self.expn_data[expn_id.0 as usize].as_ref()
- .expect("no expansion info for an expansion ID")
+ .expect("no expansion data for an expansion ID")
}
fn is_descendant_of(&self, mut expn_id: ExpnId, ancestor: ExpnId) -> bool {
if expn_id == ExpnId::root() {
return false;
}
- expn_id = self.expn_info(expn_id).parent;
+ expn_id = self.expn_data(expn_id).parent;
}
true
}
fn walk_chain(&self, mut span: Span, to: SyntaxContext) -> Span {
while span.from_expansion() && span.ctxt() != to {
- span = self.expn_info(self.outer_expn(span.ctxt())).call_site;
+ span = self.expn_data(self.outer_expn(span.ctxt())).call_site;
}
span
}
fn apply_mark(&mut self, ctxt: SyntaxContext, expn_id: ExpnId) -> SyntaxContext {
assert_ne!(expn_id, ExpnId::root());
self.apply_mark_with_transparency(
- ctxt, expn_id, self.expn_info(expn_id).default_transparency
+ ctxt, expn_id, self.expn_data(expn_id).default_transparency
)
}
return self.apply_mark_internal(ctxt, expn_id, transparency);
}
- let call_site_ctxt = self.expn_info(expn_id).call_site.ctxt();
+ let call_site_ctxt = self.expn_data(expn_id).call_site.ctxt();
let mut call_site_ctxt = if transparency == Transparency::SemiTransparent {
self.modern(call_site_ctxt)
} else {
HygieneData::with(|data| data.outer_expn(self))
}
- /// `ctxt.outer_expn_info()` is equivalent to but faster than
- /// `ctxt.outer_expn().expn_info()`.
+ /// `ctxt.outer_expn_data()` is equivalent to but faster than
+ /// `ctxt.outer_expn().expn_data()`.
#[inline]
- pub fn outer_expn_info(self) -> ExpnInfo {
- HygieneData::with(|data| data.expn_info(data.outer_expn(self)).clone())
+ pub fn outer_expn_data(self) -> ExpnData {
+ HygieneData::with(|data| data.expn_data(data.outer_expn(self)).clone())
}
- /// `ctxt.outer_expn_with_info()` is equivalent to but faster than
- /// `{ let outer = ctxt.outer_expn(); (outer, outer.expn_info()) }`.
+ /// `ctxt.outer_expn_with_data()` is equivalent to but faster than
+ /// `{ let outer = ctxt.outer_expn(); (outer, outer.expn_data()) }`.
#[inline]
- pub fn outer_expn_with_info(self) -> (ExpnId, ExpnInfo) {
+ pub fn outer_expn_with_data(self) -> (ExpnId, ExpnData) {
HygieneData::with(|data| {
let outer = data.outer_expn(self);
- (outer, data.expn_info(outer).clone())
+ (outer, data.expn_data(outer).clone())
})
}
/// 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_info: ExpnInfo) -> Span {
+ pub fn fresh_expansion(self, expn_data: ExpnData) -> Span {
HygieneData::with(|data| {
- let expn_id = data.fresh_expn(Some(expn_info));
+ let expn_id = data.fresh_expn(Some(expn_data));
self.with_ctxt(data.apply_mark(SyntaxContext::root(), expn_id))
})
}
/// A subset of properties from both macro definition and macro call available through global data.
/// Avoid using this if you have access to the original definition or call structures.
#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
-pub struct ExpnInfo {
+pub struct ExpnData {
// --- The part unique to each expansion.
/// The kind of this expansion - macro or compiler desugaring.
pub kind: ExpnKind,
/// `foo!()` invoked `bar!()` internally, and there was an
/// expression inside `bar!`; the call_site of the expression in
/// the expansion would point to the `bar!` invocation; that
- /// call_site span would have its own ExpnInfo, with the call_site
+ /// call_site span would have its own ExpnData, with the call_site
/// pointing to the `foo!` invocation.
pub call_site: Span,
/// The span of the macro definition (possibly dummy).
/// This span serves only informational purpose and is not used for resolution.
pub def_site: Span,
- /// Transparency used by `apply_mark` for the expansion with this expansion info by default.
+ /// Transparency used by `apply_mark` for the expansion with this expansion data by default.
pub default_transparency: Transparency,
/// List of #[unstable]/feature-gated features that the macro is allowed to use
/// internally without forcing the whole crate to opt-in
pub edition: Edition,
}
-impl ExpnInfo {
- /// Constructs an expansion info with default properties.
- pub fn default(kind: ExpnKind, call_site: Span, edition: Edition) -> ExpnInfo {
- ExpnInfo {
+impl ExpnData {
+ /// Constructs expansion data with default properties.
+ pub fn default(kind: ExpnKind, call_site: Span, edition: Edition) -> ExpnData {
+ ExpnData {
kind,
parent: ExpnId::root(),
call_site,
}
pub fn allow_unstable(kind: ExpnKind, call_site: Span, edition: Edition,
- allow_internal_unstable: Lrc<[Symbol]>) -> ExpnInfo {
- ExpnInfo {
+ allow_internal_unstable: Lrc<[Symbol]>) -> ExpnData {
+ ExpnData {
allow_internal_unstable: Some(allow_internal_unstable),
- ..ExpnInfo::default(kind, call_site, edition)
+ ..ExpnData::default(kind, call_site, edition)
}
}
pub mod edition;
use edition::Edition;
pub mod hygiene;
-pub use hygiene::{ExpnId, SyntaxContext, ExpnInfo, ExpnKind, MacroKind, DesugaringKind};
+pub use hygiene::{ExpnId, SyntaxContext, ExpnData, ExpnKind, MacroKind, DesugaringKind};
mod span_encoding;
pub use span_encoding::{Span, DUMMY_SP};
/// Returns the source span -- this is either the supplied span, or the span for
/// the macro callsite that expanded to it.
pub fn source_callsite(self) -> Span {
- let expn_info = self.ctxt().outer_expn_info();
- if !expn_info.is_root() { expn_info.call_site.source_callsite() } else { self }
+ let expn_data = self.ctxt().outer_expn_data();
+ if !expn_data.is_root() { expn_data.call_site.source_callsite() } else { self }
}
/// The `Span` for the tokens in the previous macro expansion from which `self` was generated,
/// if any.
pub fn parent(self) -> Option<Span> {
- let expn_info = self.ctxt().outer_expn_info();
- if !expn_info.is_root() { Some(expn_info.call_site) } else { None }
+ let expn_data = self.ctxt().outer_expn_data();
+ if !expn_data.is_root() { Some(expn_data.call_site) } else { None }
}
/// Edition of the crate from which this span came.
pub fn edition(self) -> edition::Edition {
- self.ctxt().outer_expn_info().edition
+ self.ctxt().outer_expn_data().edition
}
#[inline]
/// Returns the source callee.
///
/// Returns `None` if the supplied span has no expansion trace,
- /// else returns the `ExpnInfo` for the macro definition
+ /// else returns the `ExpnData` for the macro definition
/// corresponding to the source callsite.
- pub fn source_callee(self) -> Option<ExpnInfo> {
- fn source_callee(expn_info: ExpnInfo) -> ExpnInfo {
- let next_expn_info = expn_info.call_site.ctxt().outer_expn_info();
- if !next_expn_info.is_root() { source_callee(next_expn_info) } else { expn_info }
+ pub fn source_callee(self) -> Option<ExpnData> {
+ fn source_callee(expn_data: ExpnData) -> ExpnData {
+ let next_expn_data = expn_data.call_site.ctxt().outer_expn_data();
+ if !next_expn_data.is_root() { source_callee(next_expn_data) } else { expn_data }
}
- let expn_info = self.ctxt().outer_expn_info();
- if !expn_info.is_root() { Some(source_callee(expn_info)) } else { None }
+ let expn_data = self.ctxt().outer_expn_data();
+ if !expn_data.is_root() { Some(source_callee(expn_data)) } else { None }
}
/// Checks if a span is "internal" to a macro in which `#[unstable]`
/// items can be used (that is, a macro marked with
/// `#[allow_internal_unstable]`).
pub fn allows_unstable(&self, feature: Symbol) -> bool {
- self.ctxt().outer_expn_info().allow_internal_unstable.map_or(false, |features| {
+ self.ctxt().outer_expn_data().allow_internal_unstable.map_or(false, |features| {
features.iter().any(|&f| {
f == feature || f == sym::allow_internal_unstable_backcompat_hack
})
/// Checks if this span arises from a compiler desugaring of kind `kind`.
pub fn is_desugaring(&self, kind: DesugaringKind) -> bool {
- match self.ctxt().outer_expn_info().kind {
+ match self.ctxt().outer_expn_data().kind {
ExpnKind::Desugaring(k) => k == kind,
_ => false,
}
/// Returns the compiler desugaring that created this span, or `None`
/// if this span is not from a desugaring.
pub fn desugaring_kind(&self) -> Option<DesugaringKind> {
- match self.ctxt().outer_expn_info().kind {
+ match self.ctxt().outer_expn_data().kind {
ExpnKind::Desugaring(k) => Some(k),
_ => None
}
/// can be used without triggering the `unsafe_code` lint
// (that is, a macro marked with `#[allow_internal_unsafe]`).
pub fn allows_unsafe(&self) -> bool {
- self.ctxt().outer_expn_info().allow_internal_unsafe
+ self.ctxt().outer_expn_data().allow_internal_unsafe
}
pub fn macro_backtrace(mut self) -> Vec<MacroBacktrace> {
let mut prev_span = DUMMY_SP;
let mut result = vec![];
loop {
- let info = self.ctxt().outer_expn_info();
- if info.is_root() {
+ let expn_data = self.ctxt().outer_expn_data();
+ if expn_data.is_root() {
break;
}
// Don't print recursive invocations.
- if !info.call_site.source_equal(&prev_span) {
- let (pre, post) = match info.kind {
+ if !expn_data.call_site.source_equal(&prev_span) {
+ let (pre, post) = match expn_data.kind {
ExpnKind::Root => break,
ExpnKind::Desugaring(..) => ("desugaring of ", ""),
ExpnKind::Macro(macro_kind, _) => match macro_kind {
}
};
result.push(MacroBacktrace {
- call_site: info.call_site,
- macro_decl_name: format!("{}{}{}", pre, info.kind.descr(), post),
- def_site_span: info.def_site,
+ call_site: expn_data.call_site,
+ macro_decl_name: format!("{}{}{}", pre, expn_data.kind.descr(), post),
+ def_site_span: expn_data.def_site,
});
}
prev_span = self;
- self = info.call_site;
+ self = expn_data.call_site;
}
result
}
projects / rust.git / commitdiff