use syntax::ast;
use syntax::ast::*;
use syntax::errors;
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax::print::pprust;
use syntax::source_map::{respan, ExpnInfo, ExpnKind, DesugaringKind, Spanned};
use syntax::std_inject;
owner,
id,
DefPathData::Misc,
- Mark::root(),
+ ExpnId::root(),
tree.prefix.span,
);
self.lctx.allocate_hir_id_counter(id);
span: Span,
allow_internal_unstable: Option<Lrc<[Symbol]>>,
) -> Span {
- span.fresh_expansion(Mark::root(), ExpnInfo {
+ span.fresh_expansion(ExpnId::root(), ExpnInfo {
def_site: span,
allow_internal_unstable,
..ExpnInfo::default(ExpnKind::Desugaring(reason), span, self.sess.edition())
parent_index,
node_id,
DefPathData::LifetimeNs(str_name),
- Mark::root(),
+ ExpnId::root(),
span,
);
parent_def_index,
impl_trait_node_id,
DefPathData::ImplTrait,
- Mark::root(),
+ ExpnId::root(),
DUMMY_SP
);
self.parent,
def_node_id,
DefPathData::LifetimeNs(name.ident().as_interned_str()),
- Mark::root(),
+ ExpnId::root(),
lifetime.span);
let (name, kind) = match name {
use crate::hir::def_id::DefIndex;
use syntax::ast::*;
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax::visit;
use syntax::symbol::{kw, sym};
use syntax::parse::token::{self, Token};
pub struct DefCollector<'a> {
definitions: &'a mut Definitions,
parent_def: DefIndex,
- expansion: Mark,
+ expansion: ExpnId,
}
impl<'a> DefCollector<'a> {
- pub fn new(definitions: &'a mut Definitions, expansion: Mark) -> Self {
+ pub fn new(definitions: &'a mut Definitions, expansion: ExpnId) -> Self {
let parent_def = definitions.invocation_parent(expansion);
DefCollector { definitions, parent_def, expansion }
}
use std::fmt::Write;
use std::hash::Hash;
use syntax::ast;
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax::symbol::{Symbol, sym, InternedString};
use syntax_pos::{Span, DUMMY_SP};
use crate::util::nodemap::NodeMap;
node_to_def_index: NodeMap<DefIndex>,
def_index_to_node: Vec<ast::NodeId>,
pub(super) node_to_hir_id: IndexVec<ast::NodeId, hir::HirId>,
- /// If `Mark` is an ID of some macro expansion,
+ /// If `ExpnId` is an ID of some macro expansion,
/// then `DefId` is the normal module (`mod`) in which the expanded macro was defined.
- parent_modules_of_macro_defs: FxHashMap<Mark, DefId>,
- /// Item with a given `DefIndex` was defined during macro expansion with ID `Mark`.
- expansions_that_defined: FxHashMap<DefIndex, Mark>,
+ parent_modules_of_macro_defs: FxHashMap<ExpnId, DefId>,
+ /// Item with a given `DefIndex` was defined during macro expansion with ID `ExpnId`.
+ expansions_that_defined: FxHashMap<DefIndex, ExpnId>,
next_disambiguator: FxHashMap<(DefIndex, DefPathData), u32>,
def_index_to_span: FxHashMap<DefIndex, Span>,
- /// When collecting definitions from an AST fragment produced by a macro invocation `Mark`
+ /// When collecting definitions from an AST fragment produced by a macro invocation `ExpnId`
/// we know what parent node that fragment should be attached to thanks to this table.
- invocation_parents: FxHashMap<Mark, DefIndex>,
+ invocation_parents: FxHashMap<ExpnId, DefIndex>,
}
/// A unique identifier that we can use to lookup a definition
assert!(self.def_index_to_node.is_empty());
self.def_index_to_node.push(ast::CRATE_NODE_ID);
self.node_to_def_index.insert(ast::CRATE_NODE_ID, root_index);
- self.set_invocation_parent(Mark::root(), root_index);
+ self.set_invocation_parent(ExpnId::root(), root_index);
// Allocate some other DefIndices that always must exist.
GlobalMetaDataKind::allocate_def_indices(self);
parent: DefIndex,
node_id: ast::NodeId,
data: DefPathData,
- expansion: Mark,
+ expansion: ExpnId,
span: Span)
-> DefIndex {
debug!("create_def_with_parent(parent={:?}, node_id={:?}, data={:?})",
self.node_to_def_index.insert(node_id, index);
}
- if expansion != Mark::root() {
+ if expansion != ExpnId::root() {
self.expansions_that_defined.insert(index, expansion);
}
self.node_to_hir_id = mapping;
}
- pub fn expansion_that_defined(&self, index: DefIndex) -> Mark {
- self.expansions_that_defined.get(&index).cloned().unwrap_or(Mark::root())
+ pub fn expansion_that_defined(&self, index: DefIndex) -> ExpnId {
+ self.expansions_that_defined.get(&index).cloned().unwrap_or(ExpnId::root())
}
- pub fn parent_module_of_macro_def(&self, mark: Mark) -> DefId {
+ pub fn parent_module_of_macro_def(&self, mark: ExpnId) -> DefId {
self.parent_modules_of_macro_defs[&mark]
}
- pub fn add_parent_module_of_macro_def(&mut self, mark: Mark, module: DefId) {
+ pub fn add_parent_module_of_macro_def(&mut self, mark: ExpnId, module: DefId) {
self.parent_modules_of_macro_defs.insert(mark, module);
}
- pub fn invocation_parent(&self, invoc_id: Mark) -> DefIndex {
+ pub fn invocation_parent(&self, invoc_id: ExpnId) -> DefIndex {
self.invocation_parents[&invoc_id]
}
- pub fn set_invocation_parent(&mut self, invoc_id: Mark, parent: DefIndex) {
+ pub fn set_invocation_parent(&mut self, invoc_id: ExpnId, parent: DefIndex) {
let old_parent = self.invocation_parents.insert(invoc_id, parent);
assert!(old_parent.is_none(), "parent def-index is reset for an invocation");
}
CRATE_DEF_INDEX,
ast::DUMMY_NODE_ID,
DefPathData::GlobalMetaData(instance.name().as_interned_str()),
- Mark::root(),
+ ExpnId::root(),
DUMMY_SP
);
// times, we cache a stable hash of it and hash that instead of
// recursing every time.
thread_local! {
- static CACHE: RefCell<FxHashMap<hygiene::Mark, u64>> = Default::default();
+ static CACHE: RefCell<FxHashMap<hygiene::ExpnId, u64>> = Default::default();
}
let sub_hash: u64 = CACHE.with(|cache| {
use std::ops::Range;
use syntax::ast::{self, Name, Ident, NodeId};
use syntax::attr;
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax::symbol::{kw, sym, Symbol, LocalInternedString, InternedString};
use syntax_pos::Span;
self.expansion_that_defined(def_parent_def_id))
}
- fn expansion_that_defined(self, scope: DefId) -> Mark {
+ fn expansion_that_defined(self, scope: DefId) -> ExpnId {
match scope.krate {
LOCAL_CRATE => self.hir().definitions().expansion_that_defined(scope.index),
- _ => Mark::root(),
+ _ => ExpnId::root(),
}
}
use syntax::ast::NodeId;
use syntax::source_map::{SourceMap, StableSourceFileId};
use syntax_pos::{BytePos, Span, DUMMY_SP, SourceFile};
-use syntax_pos::hygiene::{Mark, SyntaxContext, ExpnInfo};
+use syntax_pos::hygiene::{ExpnId, SyntaxContext, ExpnInfo};
const TAG_FILE_FOOTER: u128 = 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
// as long as incremental compilation does not kick in before that.
let location = || Span::new(lo, hi, SyntaxContext::empty());
let recover_from_expn_info = |this: &Self, expn_info, pos| {
- let span = location().fresh_expansion(Mark::root(), expn_info);
+ let span = location().fresh_expansion(ExpnId::root(), expn_info);
this.synthetic_expansion_infos.borrow_mut().insert(pos, span.ctxt());
span
};
encoder: &'a mut E,
type_shorthands: FxHashMap<Ty<'tcx>, usize>,
predicate_shorthands: FxHashMap<ty::Predicate<'tcx>, usize>,
- expn_info_shorthands: FxHashMap<Mark, AbsoluteBytePos>,
+ expn_info_shorthands: FxHashMap<ExpnId, AbsoluteBytePos>,
interpret_allocs: FxHashMap<interpret::AllocId, usize>,
interpret_allocs_inverse: Vec<interpret::AllocId>,
source_map: CachingSourceMapView<'tcx>,
base::{ExtCtxt, MacroKind, Resolver},
build::AstBuilder,
expand::ExpansionConfig,
- hygiene::Mark,
+ hygiene::ExpnId,
},
mut_visit::{self, MutVisitor},
parse::ParseSess,
self.found = true;
// Create a new expansion for the generated allocator code.
- let span = item.span.fresh_expansion(Mark::root(), ExpnInfo::allow_unstable(
+ let span = item.span.fresh_expansion(ExpnId::root(), ExpnInfo::allow_unstable(
ExpnKind::Macro(MacroKind::Attr, sym::global_allocator), item.span, self.sess.edition,
[sym::rustc_attrs][..].into(),
));
use rustc_errors::emitter::{Emitter};
use rustc_target::spec::MergeFunctions;
use syntax::attr;
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax_pos::MultiSpan;
use syntax_pos::symbol::{Symbol, sym};
use jobserver::{Client, Acquired};
}
}
Ok(SharedEmitterMessage::InlineAsmError(cookie, msg)) => {
- match Mark::from_u32(cookie).expn_info() {
+ match ExpnId::from_u32(cookie).expn_info() {
Some(ei) => sess.span_err(ei.call_site, &msg),
None => sess.err(&msg),
}
use syntax::source_map;
use syntax::symbol::{Symbol, sym};
use syntax::ext::base::{MacroKind, SyntaxExtension};
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, NO_EXPANSION};
use log::debug;
crate_root,
ast::DUMMY_NODE_ID,
DefPathData::MacroNs(name.as_interned_str()),
- Mark::root(),
+ ExpnId::root(),
DUMMY_SP);
debug!("definition for {:?} is {:?}", name, def_index);
assert_eq!(def_index, DefIndex::from_proc_macro_index(index));
use syntax::ast::{self, Block, ForeignItem, ForeignItemKind, Item, ItemKind, NodeId};
use syntax::ast::{MetaItemKind, StmtKind, TraitItem, TraitItemKind, Variant};
use syntax::ext::base::SyntaxExtension;
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax::ext::tt::macro_rules;
use syntax::feature_gate::is_builtin_attr;
use syntax::parse::token::{self, Token};
type Res = def::Res<NodeId>;
-impl<'a> ToNameBinding<'a> for (Module<'a>, ty::Visibility, Span, Mark) {
+impl<'a> ToNameBinding<'a> for (Module<'a>, ty::Visibility, Span, ExpnId) {
fn to_name_binding(self, arenas: &'a ResolverArenas<'a>) -> &'a NameBinding<'a> {
arenas.alloc_name_binding(NameBinding {
kind: NameBindingKind::Module(self.0),
}
}
-impl<'a> ToNameBinding<'a> for (Res, ty::Visibility, Span, Mark) {
+impl<'a> ToNameBinding<'a> for (Res, ty::Visibility, Span, ExpnId) {
fn to_name_binding(self, arenas: &'a ResolverArenas<'a>) -> &'a NameBinding<'a> {
arenas.alloc_name_binding(NameBinding {
kind: NameBindingKind::Res(self.0, false),
pub(crate) struct IsMacroExport;
-impl<'a> ToNameBinding<'a> for (Res, ty::Visibility, Span, Mark, IsMacroExport) {
+impl<'a> ToNameBinding<'a> for (Res, ty::Visibility, Span, ExpnId, IsMacroExport) {
fn to_name_binding(self, arenas: &'a ResolverArenas<'a>) -> &'a NameBinding<'a> {
arenas.alloc_name_binding(NameBinding {
kind: NameBindingKind::Res(self.0, true),
let imported_binding = self.import(binding, directive);
if ptr::eq(self.current_module, self.graph_root) {
if let Some(entry) = self.extern_prelude.get(&ident.modern()) {
- if expansion != Mark::root() && orig_name.is_some() &&
+ if expansion != ExpnId::root() && orig_name.is_some() &&
entry.extern_crate_item.is_none() {
self.session.span_err(item.span, "macro-expanded `extern crate` items \
cannot shadow names passed with \
variant: &Variant,
parent: Module<'a>,
vis: ty::Visibility,
- expansion: Mark) {
+ expansion: ExpnId) {
let ident = variant.node.ident;
// Define a name in the type namespace.
}
/// Constructs the reduced graph for one foreign item.
- fn build_reduced_graph_for_foreign_item(&mut self, item: &ForeignItem, expansion: Mark) {
+ fn build_reduced_graph_for_foreign_item(&mut self, item: &ForeignItem, expansion: ExpnId) {
let (res, ns) = match item.node {
ForeignItemKind::Fn(..) => {
(Res::Def(DefKind::Fn, self.definitions.local_def_id(item.id)), ValueNS)
self.define(parent, item.ident, ns, (res, vis, item.span, expansion));
}
- fn build_reduced_graph_for_block(&mut self, block: &Block, expansion: Mark) {
+ fn build_reduced_graph_for_block(&mut self, block: &Block, expansion: ExpnId) {
let parent = self.current_module;
if self.block_needs_anonymous_module(block) {
let module = self.new_module(parent,
// but metadata cannot encode gensyms currently, so we create it here.
// This is only a guess, two equivalent idents may incorrectly get different gensyms here.
let ident = ident.gensym_if_underscore();
- let expansion = Mark::root(); // FIXME(jseyfried) intercrate hygiene
+ let expansion = ExpnId::root(); // FIXME(jseyfried) intercrate hygiene
match res {
Res::Def(kind @ DefKind::Mod, def_id)
| Res::Def(kind @ DefKind::Enum, def_id) => {
};
let kind = ModuleKind::Def(DefKind::Mod, def_id, name.as_symbol());
- let module =
- self.arenas.alloc_module(ModuleData::new(parent, kind, def_id, Mark::root(), DUMMY_SP));
+ let module = self.arenas.alloc_module(ModuleData::new(
+ parent, kind, def_id, ExpnId::root(), DUMMY_SP
+ ));
self.extern_module_map.insert((def_id, macros_only), module);
module
}
- pub fn macro_def_scope(&mut self, expansion: Mark) -> Module<'a> {
+ pub fn macro_def_scope(&mut self, expansion: ExpnId) -> Module<'a> {
let def_id = match self.macro_defs.get(&expansion) {
Some(def_id) => *def_id,
None => return self.graph_root,
used: Cell::new(false),
});
- let allow_shadowing = parent_scope.expansion == Mark::root();
+ let allow_shadowing = parent_scope.expansion == ExpnId::root();
if let Some(span) = import_all {
let directive = macro_use_directive(span);
self.potentially_unused_imports.push(directive);
pub struct BuildReducedGraphVisitor<'a, 'b> {
pub resolver: &'a mut Resolver<'b>,
pub current_legacy_scope: LegacyScope<'b>,
- pub expansion: Mark,
+ pub expansion: ExpnId,
}
impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
use rustc_metadata::cstore::CStore;
use syntax::source_map::SourceMap;
-use syntax::ext::hygiene::{Mark, Transparency, SyntaxContext};
+use syntax::ext::hygiene::{ExpnId, Transparency, SyntaxContext};
use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy};
use syntax::ext::base::SyntaxExtension;
use syntax::ext::base::MacroKind;
#[derive(Clone, Debug)]
pub struct ParentScope<'a> {
module: Module<'a>,
- expansion: Mark,
+ expansion: ExpnId,
legacy: LegacyScope<'a>,
derives: Vec<ast::Path>,
}
builtin_attrs: RefCell<Vec<(Ident, ParentScope<'a>)>>,
// Macro invocations that can expand into items in this module.
- unresolved_invocations: RefCell<FxHashSet<Mark>>,
+ unresolved_invocations: RefCell<FxHashSet<ExpnId>>,
no_implicit_prelude: bool,
/// Span of the module itself. Used for error reporting.
span: Span,
- expansion: Mark,
+ expansion: ExpnId,
}
type Module<'a> = &'a ModuleData<'a>;
fn new(parent: Option<Module<'a>>,
kind: ModuleKind,
normal_ancestor_id: DefId,
- expansion: Mark,
+ expansion: ExpnId,
span: Span) -> Self {
ModuleData {
parent,
pub struct NameBinding<'a> {
kind: NameBindingKind<'a>,
ambiguity: Option<(&'a NameBinding<'a>, AmbiguityKind)>,
- expansion: Mark,
+ expansion: ExpnId,
span: Span,
vis: ty::Visibility,
}
// in some later round and screw up our previously found resolution.
// See more detailed explanation in
// https://github.com/rust-lang/rust/pull/53778#issuecomment-419224049
- fn may_appear_after(&self, invoc_parent_expansion: Mark, binding: &NameBinding<'_>) -> bool {
+ fn may_appear_after(&self, invoc_parent_expansion: ExpnId, binding: &NameBinding<'_>) -> bool {
// self > max(invoc, binding) => !(self <= invoc || self <= binding)
// Expansions are partially ordered, so "may appear after" is an inversion of
// "certainly appears before or simultaneously" and includes unordered cases.
dummy_ext_bang: Lrc<SyntaxExtension>,
dummy_ext_derive: Lrc<SyntaxExtension>,
non_macro_attrs: [Lrc<SyntaxExtension>; 2],
- macro_defs: FxHashMap<Mark, DefId>,
+ macro_defs: FxHashMap<ExpnId, DefId>,
local_macro_def_scopes: FxHashMap<NodeId, Module<'a>>,
unused_macros: NodeMap<Span>,
proc_macro_stubs: NodeSet,
- /// Maps the `Mark` of an expansion to its containing module or block.
- invocations: FxHashMap<Mark, &'a InvocationData<'a>>,
+ /// Maps the `ExpnId` of an expansion to its containing module or block.
+ invocations: FxHashMap<ExpnId, &'a InvocationData<'a>>,
/// Avoid duplicated errors for "name already defined".
name_already_seen: FxHashMap<Name, Span>,
);
let graph_root = arenas.alloc_module(ModuleData {
no_implicit_prelude: attr::contains_name(&krate.attrs, sym::no_implicit_prelude),
- ..ModuleData::new(None, root_module_kind, root_def_id, Mark::root(), krate.span)
+ ..ModuleData::new(None, root_module_kind, root_def_id, ExpnId::root(), krate.span)
});
let mut module_map = FxHashMap::default();
module_map.insert(DefId::local(CRATE_DEF_INDEX), graph_root);
}
let mut invocations = FxHashMap::default();
- invocations.insert(Mark::root(),
+ invocations.insert(ExpnId::root(),
arenas.alloc_invocation_data(InvocationData::root(graph_root)));
let mut macro_defs = FxHashMap::default();
- macro_defs.insert(Mark::root(), root_def_id);
+ macro_defs.insert(ExpnId::root(), root_def_id);
let features = session.features_untracked();
let non_macro_attr =
dummy_binding: arenas.alloc_name_binding(NameBinding {
kind: NameBindingKind::Res(Res::Err, false),
ambiguity: None,
- expansion: Mark::root(),
+ expansion: ExpnId::root(),
span: DUMMY_SP,
vis: ty::Visibility::Public,
}),
parent: Module<'a>,
kind: ModuleKind,
normal_ancestor_id: DefId,
- expansion: Mark,
+ expansion: ExpnId,
span: Span,
) -> Module<'a> {
let module = ModuleData::new(Some(parent), kind, normal_ancestor_id, expansion, span);
}
Scope::CrateRoot => match ns {
TypeNS => {
- ident.span.adjust(Mark::root());
+ ident.span.adjust(ExpnId::root());
Scope::ExternPrelude
}
ValueNS | MacroNS => break,
match self.hygienic_lexical_parent(module, &mut ident.span) {
Some(parent_module) => Scope::Module(parent_module),
None => {
- ident.span.adjust(Mark::root());
+ ident.span.adjust(ExpnId::root());
match ns {
TypeNS => Scope::ExternPrelude,
ValueNS => Scope::StdLibPrelude,
}
if !module.no_implicit_prelude {
- ident.span.adjust(Mark::root());
+ ident.span.adjust(ExpnId::root());
if ns == TypeNS {
if let Some(binding) = self.extern_prelude_get(ident, !record_used) {
return Some(LexicalScopeBinding::Item(binding));
}
if ns == TypeNS && KNOWN_TOOLS.contains(&ident.name) {
let binding = (Res::ToolMod, ty::Visibility::Public,
- DUMMY_SP, Mark::root()).to_name_binding(self.arenas);
+ DUMMY_SP, ExpnId::root()).to_name_binding(self.arenas);
return Some(LexicalScopeBinding::Item(binding));
}
if let Some(prelude) = self.prelude {
}
}
ModuleOrUniformRoot::ExternPrelude => {
- ident.span.modernize_and_adjust(Mark::root());
+ ident.span.modernize_and_adjust(ExpnId::root());
}
ModuleOrUniformRoot::CrateRootAndExternPrelude |
ModuleOrUniformRoot::CurrentScope => {
result
} else {
ctxt = ctxt.modern();
- ctxt.adjust(Mark::root())
+ ctxt.adjust(ExpnId::root())
};
let module = match mark {
Some(def) => self.macro_def_scope(def),
};
let crate_root = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX });
self.populate_module_if_necessary(&crate_root);
- Some((crate_root, ty::Visibility::Public, DUMMY_SP, Mark::root())
+ Some((crate_root, ty::Visibility::Public, DUMMY_SP, ExpnId::root())
.to_name_binding(self.arenas))
}
})
use syntax::ext::base::{self, Indeterminate};
use syntax::ext::base::{MacroKind, SyntaxExtension};
use syntax::ext::expand::{AstFragment, Invocation, InvocationKind};
-use syntax::ext::hygiene::{self, Mark, ExpnInfo, ExpnKind};
+use syntax::ext::hygiene::{self, ExpnId, ExpnInfo, ExpnKind};
use syntax::ext::tt::macro_rules;
use syntax::feature_gate::{emit_feature_err, is_builtin_attr_name};
use syntax::feature_gate::GateIssue;
self.session.next_node_id()
}
- fn get_module_scope(&mut self, id: ast::NodeId) -> Mark {
- let span = DUMMY_SP.fresh_expansion(Mark::root(), ExpnInfo::default(
+ fn get_module_scope(&mut self, id: ast::NodeId) -> ExpnId {
+ let span = DUMMY_SP.fresh_expansion(ExpnId::root(), ExpnInfo::default(
ExpnKind::Macro(MacroKind::Attr, sym::test_case), DUMMY_SP, self.session.edition()
));
let mark = span.ctxt().outer();
});
}
- fn visit_ast_fragment_with_placeholders(&mut self, mark: Mark, fragment: &AstFragment,
- derives: &[Mark]) {
+ fn visit_ast_fragment_with_placeholders(&mut self, mark: ExpnId, fragment: &AstFragment,
+ derives: &[ExpnId]) {
fragment.visit_with(&mut DefCollector::new(&mut self.definitions, mark));
let invocation = self.invocations[&mark];
ambiguity: None,
span: DUMMY_SP,
vis: ty::Visibility::Public,
- expansion: Mark::root(),
+ expansion: ExpnId::root(),
});
if self.builtin_macros.insert(ident.name, binding).is_some() {
self.session.span_err(ident.span,
ImportResolver { resolver: self }.resolve_imports()
}
- fn resolve_macro_invocation(&mut self, invoc: &Invocation, invoc_id: Mark, force: bool)
+ fn resolve_macro_invocation(&mut self, invoc: &Invocation, invoc_id: ExpnId, force: bool)
-> Result<Option<Lrc<SyntaxExtension>>, Indeterminate> {
let (path, kind, derives_in_scope, after_derive) = match invoc.kind {
InvocationKind::Attr { ref attr, ref derives, after_derive, .. } =>
impl<'a> Resolver<'a> {
pub fn dummy_parent_scope(&self) -> ParentScope<'a> {
- self.invoc_parent_scope(Mark::root(), Vec::new())
+ self.invoc_parent_scope(ExpnId::root(), Vec::new())
}
- fn invoc_parent_scope(&self, invoc_id:
Mark, derives: Vec<ast::Path>) -> ParentScope<'a> {
+ fn invoc_parent_scope(&self, invoc_id:
ExpnId, derives: Vec<ast::Path>) -> ParentScope<'a> {
let invoc = self.invocations[&invoc_id];
ParentScope {
module: invoc.module.nearest_item_scope(),
&parent_scope, true, force) {
Ok((Some(ext), _)) => if ext.helper_attrs.contains(&ident.name) {
let binding = (Res::NonMacroAttr(NonMacroAttrKind::DeriveHelper),
- ty::Visibility::Public, derive.span, Mark::root())
+ ty::Visibility::Public, derive.span, ExpnId::root())
.to_name_binding(this.arenas);
result = Ok((binding, Flags::empty()));
break;
}
Scope::BuiltinAttrs => if is_builtin_attr_name(ident.name) {
let binding = (Res::NonMacroAttr(NonMacroAttrKind::Builtin),
- ty::Visibility::Public, DUMMY_SP, Mark::root())
+ ty::Visibility::Public, DUMMY_SP, ExpnId::root())
.to_name_binding(this.arenas);
Ok((binding, Flags::PRELUDE))
} else {
Scope::LegacyPluginHelpers => if this.session.plugin_attributes.borrow().iter()
.any(|(name, _)| ident.name == *name) {
let binding = (Res::NonMacroAttr(NonMacroAttrKind::LegacyPluginHelper),
- ty::Visibility::Public, DUMMY_SP, Mark::root())
+ ty::Visibility::Public, DUMMY_SP, ExpnId::root())
.to_name_binding(this.arenas);
Ok((binding, Flags::PRELUDE))
} else {
)),
}
Scope::ToolPrelude => if KNOWN_TOOLS.contains(&ident.name) {
- let binding = (Res::ToolMod, ty::Visibility::Public, DUMMY_SP, Mark::root())
+ let binding = (Res::ToolMod, ty::Visibility::Public, DUMMY_SP, ExpnId::root())
.to_name_binding(this.arenas);
Ok((binding, Flags::PRELUDE))
} else {
.get(&ident.name).cloned() {
Some(prim_ty) => {
let binding = (Res::PrimTy(prim_ty), ty::Visibility::Public,
- DUMMY_SP, Mark::root()).to_name_binding(this.arenas);
+ DUMMY_SP, ExpnId::root()).to_name_binding(this.arenas);
Ok((binding, Flags::PRELUDE))
}
None => Err(Determinacy::Determined)
// the last segment, so we are certainly working with a single-segment attribute here.)
assert!(ns == MacroNS);
let binding = (Res::NonMacroAttr(NonMacroAttrKind::Custom),
- ty::Visibility::Public, orig_ident.span, Mark::root())
+ ty::Visibility::Public, orig_ident.span, ExpnId::root())
.to_name_binding(self.arenas);
Ok(binding)
} else {
pub fn define_macro(&mut self,
item: &ast::Item,
- expansion: Mark,
+ expansion: ExpnId,
current_legacy_scope: &mut LegacyScope<'a>) {
let (ext, ident, span, is_legacy) = match &item.node {
ItemKind::MacroDef(def) => {
use rustc::{bug, span_bug};
use syntax::ast::{self, Ident, Name, NodeId, CRATE_NODE_ID};
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax::symbol::kw;
use syntax::util::lev_distance::find_best_match_for_name;
use syntax::{struct_span_err, unwrap_or};
ident.name == kw::DollarCrate {
let module = self.resolve_crate_root(ident);
let binding = (module, ty::Visibility::Public,
- module.span, Mark::root())
+ module.span, ExpnId::root())
.to_name_binding(self.arenas);
return Ok(binding);
} else if ident.name == kw::Super ||
.map_err(|_| (Determined, Weak::No))?; // This happens when there is a cycle of imports.
if let Some(binding) = resolution.binding {
- if !restricted_shadowing && binding.expansion != Mark::root() {
+ if !restricted_shadowing && binding.expansion != ExpnId::root() {
if let NameBindingKind::Res(_, true) = binding.kind {
self.macro_expanded_macro_export_errors.insert((path_span, binding.span));
}
if let Some(shadowed_glob) = resolution.shadowed_glob {
// Forbid expanded shadowing to avoid time travel.
if restricted_shadowing &&
- binding.expansion != Mark::root() &&
+ binding.expansion != ExpnId::root() &&
binding.res() != shadowed_glob.res() {
self.ambiguity_errors.push(AmbiguityError {
kind: AmbiguityKind::GlobVsExpanded,
(binding, old_binding)
};
if glob_binding.res() != nonglob_binding.res() &&
- ns == MacroNS && nonglob_binding.expansion != Mark::root() {
+ ns == MacroNS && nonglob_binding.expansion != ExpnId::root() {
resolution.binding = Some(this.ambiguity(AmbiguityKind::GlobVsExpanded,
nonglob_binding, glob_binding));
} else {
target: Ident,
) {
// Skip if the import was produced by a macro.
- if directive.parent_scope.expansion != Mark::root() {
+ if directive.parent_scope.expansion != ExpnId::root() {
return;
}
pub use crate::symbol::{Ident, Symbol as Name};
pub use crate::util::parser::ExprPrecedence;
-use crate::ext::hygiene::{Mark, SyntaxContext};
+use crate::ext::hygiene::{ExpnId, SyntaxContext};
use crate::parse::token::{self, DelimToken};
use crate::print::pprust;
use crate::ptr::P;
pub use node_id_inner::NodeId;
impl NodeId {
- pub fn placeholder_from_mark(mark: Mark) -> Self {
+ pub fn placeholder_from_mark(mark: ExpnId) -> Self {
NodeId::from_u32(mark.as_u32())
}
- pub fn placeholder_to_mark(self) -> Mark {
- Mark::from_u32(self.as_u32())
+ pub fn placeholder_to_mark(self) -> ExpnId {
+ ExpnId::from_u32(self.as_u32())
}
}
use crate::source_map::{SourceMap, Spanned, respan};
use crate::edition::Edition;
use crate::ext::expand::{self, AstFragment, Invocation};
-use crate::ext::hygiene::{Mark, SyntaxContext, Transparency};
+use crate::ext::hygiene::{ExpnId, SyntaxContext, Transparency};
use crate::mut_visit::{self, MutVisitor};
use crate::parse::{self, parser, DirectoryOwnership};
use crate::parse::token;
pub trait Resolver {
fn next_node_id(&mut self) -> ast::NodeId;
- fn get_module_scope(&mut self, id: ast::NodeId) -> Mark;
+ fn get_module_scope(&mut self, id: ast::NodeId) -> ExpnId;
fn resolve_dollar_crates(&mut self);
- fn visit_ast_fragment_with_placeholders(&mut self, mark: Mark, fragment: &AstFragment,
- derives: &[Mark]);
+ fn visit_ast_fragment_with_placeholders(&mut self, mark: ExpnId, fragment: &AstFragment,
+ derives: &[ExpnId]);
fn add_builtin(&mut self, ident: ast::Ident, ext: Lrc<SyntaxExtension>);
fn resolve_imports(&mut self);
- fn resolve_macro_invocation(&mut self, invoc: &Invocation, invoc_id: Mark, force: bool)
+ fn resolve_macro_invocation(&mut self, invoc: &Invocation, invoc_id: ExpnId, force: bool)
-> Result<Option<Lrc<SyntaxExtension>>, Indeterminate>;
fn check_unused_macros(&self);
#[derive(Clone)]
pub struct ExpansionData {
- pub mark: Mark,
+ pub mark: ExpnId,
pub depth: usize,
pub module: Rc<ModuleData>,
pub directory_ownership: DirectoryOwnership,
root_path: PathBuf::new(),
resolver,
current_expansion: ExpansionData {
- mark: Mark::root(),
+ mark: ExpnId::root(),
depth: 0,
module: Rc::new(ModuleData { mod_path: Vec::new(), directory: PathBuf::new() }),
directory_ownership: DirectoryOwnership::Owned { relative: None },
use crate::config::StripUnconfigured;
use crate::ext::base::*;
use crate::ext::derive::{add_derived_markers, collect_derives};
-use crate::ext::hygiene::{Mark, SyntaxContext, ExpnInfo, ExpnKind};
+use crate::ext::hygiene::{ExpnId, SyntaxContext, ExpnInfo, ExpnKind};
use crate::ext::placeholders::{placeholder, PlaceholderExpander};
use crate::feature_gate::{self, Features, GateIssue, is_builtin_attr, emit_feature_err};
use crate::mut_visit::*;
// Unresolved macros produce dummy outputs as a recovery measure.
invocations.reverse();
let mut expanded_fragments = Vec::new();
- let mut derives: FxHashMap<Mark, Vec<_>> = FxHashMap::default();
+ let mut derives: FxHashMap<ExpnId, Vec<_>> = FxHashMap::default();
let mut undetermined_invocations = Vec::new();
let (mut progress, mut force) = (false, !self.monotonic);
loop {
derives.reserve(traits.len());
invocations.reserve(traits.len());
for path in traits {
- let mark = Mark::fresh(self.cx.current_expansion.mark, None);
+ let mark = ExpnId::fresh(self.cx.current_expansion.mark, None);
derives.push(mark);
invocations.push(Invocation {
kind: InvocationKind::Derive {
/// them with "placeholders" - dummy macro invocations with specially crafted `NodeId`s.
/// Then call into resolver that builds a skeleton ("reduced graph") of the fragment and
/// prepares data for resolving paths of macro invocations.
- fn collect_invocations(&mut self, mut fragment: AstFragment, derives: &[Mark])
+ fn collect_invocations(&mut self, mut fragment: AstFragment, derives: &[ExpnId])
-> (AstFragment, Vec<Invocation>) {
// Resolve `$crate`s in the fragment for pretty-printing.
self.cx.resolver.resolve_dollar_crates();
)),
_ => None,
};
- let mark = Mark::fresh(self.cx.current_expansion.mark, expn_info);
+ let mark = ExpnId::fresh(self.cx.current_expansion.mark, expn_info);
self.invocations.push(Invocation {
kind,
fragment_kind,
// A Marker adds the given mark to the syntax context.
#[derive(Debug)]
-pub struct Marker(pub Mark);
+pub struct Marker(pub ExpnId);
impl MutVisitor for Marker {
fn visit_span(&mut self, span: &mut Span) {
use crate::source_map::{DUMMY_SP, dummy_spanned};
use crate::ext::base::ExtCtxt;
use crate::ext::expand::{AstFragment, AstFragmentKind};
-use crate::ext::hygiene::Mark;
+use crate::ext::hygiene::ExpnId;
use crate::tokenstream::TokenStream;
use crate::mut_visit::*;
use crate::ptr::P;
}
}
- pub fn add(&mut self, id: ast::NodeId, mut fragment: AstFragment, derives: Vec<Mark>) {
+ pub fn add(&mut self, id: ast::NodeId, mut fragment: AstFragment, derives: Vec<ExpnId>) {
fragment.mut_visit_with(self);
if let AstFragment::Items(mut items) = fragment {
for derive in derives {
use crate::ast;
use crate::attr;
use crate::edition::Edition;
-use crate::ext::hygiene::{Mark, MacroKind};
+use crate::ext::hygiene::{ExpnId, MacroKind};
use crate::symbol::{Ident, Symbol, kw, sym};
use crate::source_map::{ExpnInfo, ExpnKind, dummy_spanned, respan};
use crate::ptr::P;
INJECTED_CRATE_NAME.with(|opt_name| opt_name.set(Some(name)));
- let span = DUMMY_SP.fresh_expansion(Mark::root(), ExpnInfo::allow_unstable(
+ let span = DUMMY_SP.fresh_expansion(ExpnId::root(), ExpnInfo::allow_unstable(
ExpnKind::Macro(MacroKind::Attr, sym::std_inject), DUMMY_SP, edition,
[sym::prelude_import][..].into(),
));
use crate::ext::base::{ExtCtxt, Resolver};
use crate::ext::build::AstBuilder;
use crate::ext::expand::ExpansionConfig;
-use crate::ext::hygiene::{self, Mark, SyntaxContext, MacroKind};
+use crate::ext::hygiene::{self, ExpnId, SyntaxContext, MacroKind};
use crate::mut_visit::{*, ExpectOne};
use crate::feature_gate::Features;
use crate::util::map_in_place::MapInPlace;
// #![main]
// test::test_main_static(&[..tests]);
// }
- let sp = DUMMY_SP.fresh_expansion(Mark::root(), ExpnInfo::allow_unstable(
+ let sp = DUMMY_SP.fresh_expansion(ExpnId::root(), ExpnInfo::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(),
));
use crate::parse::token::{self, DelimToken, Token, TokenKind};
use crate::print::pprust;
-use syntax_pos::{BytePos, Mark, Span, DUMMY_SP};
+use syntax_pos::{BytePos, ExpnId, Span, DUMMY_SP};
#[cfg(target_arch = "x86_64")]
use rustc_data_structures::static_assert_size;
use rustc_data_structures::sync::Lrc;
self.open.with_hi(self.close.hi())
}
- pub fn apply_mark(self, mark: Mark) -> Self {
+ pub fn apply_mark(self, mark: ExpnId) -> Self {
DelimSpan {
open: self.open.apply_mark(mark),
close: self.close.apply_mark(mark),
use syntax::ext::base::{ExtCtxt, MacroKind};
use syntax::ext::build::AstBuilder;
use syntax::ext::expand::ExpansionConfig;
-use syntax::ext::hygiene::Mark;
+use syntax::ext::hygiene::ExpnId;
use syntax::mut_visit::MutVisitor;
use syntax::parse::ParseSess;
use syntax::ptr::P;
custom_attrs: &[ProcMacroDef],
custom_macros: &[ProcMacroDef],
) -> P<ast::Item> {
- let span = DUMMY_SP.fresh_expansion(Mark::root(), ExpnInfo::allow_unstable(
+ let span = DUMMY_SP.fresh_expansion(ExpnId::root(), ExpnInfo::allow_unstable(
ExpnKind::Macro(MacroKind::Attr, sym::proc_macro), DUMMY_SP, cx.parse_sess.edition,
[sym::rustc_attrs, sym::proc_macro_internals][..].into(),
));
// ensuring that multiple HygieneData accesses are combined into a single
// `HygieneData::with`.
//
-// This explains why `HygieneData`, `SyntaxContext` and `Mark` have interfaces
+// 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
-// `Mark::expn_info` so that two `HygieneData` accesses can be performed within
+// `ExpnId::expn_info` 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
-// `SyntaxContext` or `Mark`. For example, `HygieneData::outer` and
+// `SyntaxContext` or `ExpnId`. For example, `HygieneData::outer` and
// `SyntaxContext::outer` do the same thing, but the former is for use within a
// `HygieneData::with` call while the latter is for use outside such a call.
// When modifying this file it is important to understand this distinction,
#[derive(Debug)]
struct SyntaxContextData {
- outer_mark: Mark,
+ outer_mark: ExpnId,
transparency: Transparency,
prev_ctxt: SyntaxContext,
/// This context, but with all transparent and semi-transparent marks filtered away.
/// A mark is a unique ID associated with a macro expansion.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub struct Mark(u32);
+pub struct ExpnId(u32);
#[derive(Debug)]
struct MarkData {
- parent: Mark,
+ parent: ExpnId,
/// Each mark should have an associated expansion info, but sometimes there's a delay between
/// creation of a mark and obtaining its info (e.g. macros are collected first and then
/// resolved later), so we use an `Option` here.
Opaque,
}
-impl Mark {
- pub fn fresh(parent: Mark, expn_info: Option<ExpnInfo>) -> Self {
+impl ExpnId {
+ pub fn fresh(parent: ExpnId, expn_info: Option<ExpnInfo>) -> Self {
HygieneData::with(|data| data.fresh_mark(parent, expn_info))
}
/// The mark of the theoretical expansion that generates freshly parsed, unexpanded AST.
#[inline]
pub fn root() -> Self {
- Mark(0)
+ ExpnId(0)
}
#[inline]
}
#[inline]
- pub fn from_u32(raw: u32) -> Mark {
- Mark(raw)
+ pub fn from_u32(raw: u32) -> ExpnId {
+ ExpnId(raw)
}
#[inline]
- pub fn parent(self) -> Mark {
+ pub fn parent(self) -> ExpnId {
HygieneData::with(|data| data.marks[self.0 as usize].parent)
}
})
}
- pub fn is_descendant_of(self, ancestor: Mark) -> bool {
+ pub fn is_descendant_of(self, ancestor: ExpnId) -> bool {
HygieneData::with(|data| data.is_descendant_of(self, ancestor))
}
crate struct HygieneData {
marks: Vec<MarkData>,
syntax_contexts: Vec<SyntaxContextData>,
- markings: FxHashMap<(SyntaxContext, Mark, Transparency), SyntaxContext>,
+ markings: FxHashMap<(SyntaxContext, ExpnId, Transparency), SyntaxContext>,
}
impl HygieneData {
crate fn new(edition: Edition) -> Self {
HygieneData {
marks: vec![MarkData {
- parent: Mark::root(),
+ parent: ExpnId::root(),
expn_info: Some(ExpnInfo::default(ExpnKind::Root, DUMMY_SP, edition)),
}],
syntax_contexts: vec![SyntaxContextData {
- outer_mark: Mark::root(),
+ outer_mark: ExpnId::root(),
transparency: Transparency::Opaque,
prev_ctxt: SyntaxContext(0),
opaque: SyntaxContext(0),
GLOBALS.with(|globals| f(&mut *globals.hygiene_data.borrow_mut()))
}
- fn fresh_mark(&mut self, parent: Mark, expn_info: Option<ExpnInfo>) -> Mark {
+ fn fresh_mark(&mut self, parent: ExpnId, expn_info: Option<ExpnInfo>) -> ExpnId {
self.marks.push(MarkData { parent, expn_info });
- Mark(self.marks.len() as u32 - 1)
+ ExpnId(self.marks.len() as u32 - 1)
}
- fn expn_info(&self, mark: Mark) -> Option<&ExpnInfo> {
- if mark != Mark::root() {
+ fn expn_info(&self, mark: ExpnId) -> Option<&ExpnInfo> {
+ if mark != ExpnId::root() {
Some(self.marks[mark.0 as usize].expn_info.as_ref()
.expect("no expansion info for a mark"))
} else {
}
}
- fn is_descendant_of(&self, mut mark: Mark, ancestor: Mark) -> bool {
+ fn is_descendant_of(&self, mut mark: ExpnId, ancestor: ExpnId) -> bool {
while mark != ancestor {
- if mark == Mark::root() {
+ if mark == ExpnId::root() {
return false;
}
mark = self.marks[mark.0 as usize].parent;
true
}
- fn default_transparency(&self, mark: Mark) -> Transparency {
+ fn default_transparency(&self, mark: ExpnId) -> Transparency {
self.expn_info(mark).map_or(
Transparency::SemiTransparent, |einfo| einfo.default_transparency
)
self.syntax_contexts[ctxt.0 as usize].opaque_and_semitransparent
}
- fn outer(&self, ctxt: SyntaxContext) -> Mark {
+ fn outer(&self, ctxt: SyntaxContext) -> ExpnId {
self.syntax_contexts[ctxt.0 as usize].outer_mark
}
self.syntax_contexts[ctxt.0 as usize].prev_ctxt
}
- fn remove_mark(&self, ctxt: &mut SyntaxContext) -> Mark {
+ fn remove_mark(&self, ctxt: &mut SyntaxContext) -> ExpnId {
let outer_mark = self.syntax_contexts[ctxt.0 as usize].outer_mark;
*ctxt = self.prev_ctxt(*ctxt);
outer_mark
}
- fn marks(&self, mut ctxt: SyntaxContext) -> Vec<(Mark, Transparency)> {
+ fn marks(&self, mut ctxt: SyntaxContext) -> Vec<(ExpnId, Transparency)> {
let mut marks = Vec::new();
while ctxt != SyntaxContext::empty() {
let outer_mark = self.outer(ctxt);
span
}
- fn adjust(&self, ctxt: &mut SyntaxContext, expansion: Mark) -> Option<Mark> {
+ fn adjust(&self, ctxt: &mut SyntaxContext, expansion: ExpnId) -> Option<ExpnId> {
let mut scope = None;
while !self.is_descendant_of(expansion, self.outer(*ctxt)) {
scope = Some(self.remove_mark(ctxt));
scope
}
- fn apply_mark(&mut self, ctxt: SyntaxContext, mark: Mark) -> SyntaxContext {
- assert_ne!(mark, Mark::root());
+ fn apply_mark(&mut self, ctxt: SyntaxContext, mark: ExpnId) -> SyntaxContext {
+ assert_ne!(mark, ExpnId::root());
self.apply_mark_with_transparency(ctxt, mark, self.default_transparency(mark))
}
- fn apply_mark_with_transparency(&mut self, ctxt: SyntaxContext, mark: Mark,
+ fn apply_mark_with_transparency(&mut self, ctxt: SyntaxContext, mark: ExpnId,
transparency: Transparency) -> SyntaxContext {
- assert_ne!(mark, Mark::root());
+ assert_ne!(mark, ExpnId::root());
if transparency == Transparency::Opaque {
return self.apply_mark_internal(ctxt, mark, transparency);
}
self.apply_mark_internal(call_site_ctxt, mark, transparency)
}
- fn apply_mark_internal(&mut self, ctxt: SyntaxContext, mark: Mark, transparency: Transparency)
+ fn apply_mark_internal(&mut self, ctxt: SyntaxContext, mark: ExpnId, transparency: Transparency)
-> SyntaxContext {
let syntax_contexts = &mut self.syntax_contexts;
let mut opaque = syntax_contexts[ctxt.0 as usize].opaque;
}
/// Extend a syntax context with a given mark and default transparency for that mark.
- pub fn apply_mark(self, mark: Mark) -> SyntaxContext {
+ pub fn apply_mark(self, mark: ExpnId) -> SyntaxContext {
HygieneData::with(|data| data.apply_mark(self, mark))
}
/// Extend a syntax context with a given mark and transparency
- pub fn apply_mark_with_transparency(self, mark: Mark, transparency: Transparency)
+ pub fn apply_mark_with_transparency(self, mark: ExpnId, transparency: Transparency)
-> SyntaxContext {
HygieneData::with(|data| data.apply_mark_with_transparency(self, mark, transparency))
}
/// of g (call it g1), calling remove_mark will result in the SyntaxContext for the
/// invocation of f that created g1.
/// Returns the mark that was removed.
- pub fn remove_mark(&mut self) -> Mark {
+ pub fn remove_mark(&mut self) -> ExpnId {
HygieneData::with(|data| data.remove_mark(self))
}
- pub fn marks(self) -> Vec<(Mark, Transparency)> {
+ pub fn marks(self) -> Vec<(ExpnId, Transparency)> {
HygieneData::with(|data| data.marks(self))
}
/// m!(f);
/// macro m($f:ident) {
/// mod bar {
- /// pub fn f() {} // `f`'s `SyntaxContext` has a single `Mark` from `m`.
+ /// pub fn f() {} // `f`'s `SyntaxContext` has a single `ExpnId` from `m`.
/// pub fn $f() {} // `$f`'s `SyntaxContext` is empty.
/// }
- /// foo::f(); // `f`'s `SyntaxContext` has a single `Mark` from `m`
+ /// foo::f(); // `f`'s `SyntaxContext` has a single `ExpnId` from `m`
/// //^ Since `mod foo` is outside this expansion, `adjust` removes the mark from `f`,
/// //| and it resolves to `::foo::f`.
- /// bar::f(); // `f`'s `SyntaxContext` has a single `Mark` from `m`
+ /// bar::f(); // `f`'s `SyntaxContext` has a single `ExpnId` from `m`
/// //^ Since `mod bar` not outside this expansion, `adjust` does not change `f`,
/// //| and it resolves to `::bar::f`.
/// bar::$f(); // `f`'s `SyntaxContext` is empty.
/// ```
/// This returns the expansion whose definition scope we use to privacy check the resolution,
/// or `None` if we privacy check as usual (i.e., not w.r.t. a macro definition scope).
- pub fn adjust(&mut self, expansion: Mark) -> Option<Mark> {
+ pub fn adjust(&mut self, expansion: ExpnId) -> Option<ExpnId> {
HygieneData::with(|data| data.adjust(self, expansion))
}
/// Like `SyntaxContext::adjust`, but also modernizes `self`.
- pub fn modernize_and_adjust(&mut self, expansion: Mark) -> Option<Mark> {
+ pub fn modernize_and_adjust(&mut self, expansion: ExpnId) -> Option<ExpnId> {
HygieneData::with(|data| {
*self = data.modern(*self);
data.adjust(self, expansion)
/// m!(f);
/// macro m($i:ident) {
/// mod foo {
- /// pub fn f() {} // `f`'s `SyntaxContext` has a single `Mark` from `m`.
+ /// pub fn f() {} // `f`'s `SyntaxContext` has a single `ExpnId` from `m`.
/// pub fn $i() {} // `$i`'s `SyntaxContext` is empty.
/// }
/// n(f);
/// ```
/// This returns `None` if the context cannot be glob-adjusted.
/// Otherwise, it returns the scope to use when privacy checking (see `adjust` for details).
- pub fn glob_adjust(&mut self, expansion: Mark, glob_span: Span) -> Option<Option<Mark>> {
+ pub fn glob_adjust(&mut self, expansion: ExpnId, glob_span: Span) -> Option<Option<ExpnId>> {
HygieneData::with(|data| {
let mut scope = None;
let mut glob_ctxt = data.modern(glob_span.ctxt());
/// assert!(self.glob_adjust(expansion, glob_ctxt) == Some(privacy_checking_scope));
/// }
/// ```
- pub fn reverse_glob_adjust(&mut self, expansion: Mark, glob_span: Span)
- -> Option<Option<Mark>> {
+ pub fn reverse_glob_adjust(&mut self, expansion: ExpnId, glob_span: Span)
+ -> Option<Option<ExpnId>> {
HygieneData::with(|data| {
if data.adjust(self, expansion).is_some() {
return None;
})
}
- pub fn hygienic_eq(self, other: SyntaxContext, mark: Mark) -> bool {
+ pub fn hygienic_eq(self, other: SyntaxContext, mark: ExpnId) -> bool {
HygieneData::with(|data| {
let mut self_modern = data.modern(self);
data.adjust(&mut self_modern, mark);
}
#[inline]
- pub fn outer(self) -> Mark {
+ pub fn outer(self) -> ExpnId {
HygieneData::with(|data| data.outer(self))
}
/// `ctxt.outer_and_expn_info()` is equivalent to but faster than
/// `{ let outer = ctxt.outer(); (outer, outer.expn_info()) }`.
#[inline]
- pub fn outer_and_expn_info(self) -> (Mark, Option<ExpnInfo>) {
+ pub fn outer_and_expn_info(self) -> (ExpnId, Option<ExpnInfo>) {
HygieneData::with(|data| {
let outer = data.outer(self);
(outer, data.expn_info(outer).cloned())
/// 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, parent: Mark, expn_info: ExpnInfo) -> Span {
+ pub fn fresh_expansion(self, parent: ExpnId, expn_info: ExpnInfo) -> Span {
HygieneData::with(|data| {
let mark = data.fresh_mark(parent, Some(expn_info));
self.with_ctxt(data.apply_mark(SyntaxContext::empty(), mark))
/// Expansion kind.
#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
pub enum ExpnKind {
- /// No expansion, aka root expansion. Only `Mark::root()` has this kind.
+ /// No expansion, aka root expansion. Only `ExpnId::root()` has this kind.
Root,
/// Expansion produced by a macro.
/// FIXME: Some code injected by the compiler before HIR lowering also gets this kind.
pub mod edition;
use edition::Edition;
pub mod hygiene;
-pub use hygiene::{Mark, SyntaxContext, ExpnInfo, ExpnKind, MacroKind, DesugaringKind};
+pub use hygiene::{ExpnId, SyntaxContext, ExpnInfo, ExpnKind, MacroKind, DesugaringKind};
mod span_encoding;
pub use span_encoding::{Span, DUMMY_SP};
}
#[inline]
- pub fn apply_mark(self, mark: Mark) -> Span {
+ pub fn apply_mark(self, mark: ExpnId) -> Span {
let span = self.data();
span.with_ctxt(span.ctxt.apply_mark(mark))
}
#[inline]
- pub fn remove_mark(&mut self) -> Mark {
+ pub fn remove_mark(&mut self) -> ExpnId {
let mut span = self.data();
let mark = span.ctxt.remove_mark();
*self = Span::new(span.lo, span.hi, span.ctxt);
}
#[inline]
- pub fn adjust(&mut self, expansion: Mark) -> Option<Mark> {
+ pub fn adjust(&mut self, expansion: ExpnId) -> Option<ExpnId> {
let mut span = self.data();
let mark = span.ctxt.adjust(expansion);
*self = Span::new(span.lo, span.hi, span.ctxt);
}
#[inline]
- pub fn modernize_and_adjust(&mut self, expansion: Mark) -> Option<Mark> {
+ pub fn modernize_and_adjust(&mut self, expansion: ExpnId) -> Option<ExpnId> {
let mut span = self.data();
let mark = span.ctxt.modernize_and_adjust(expansion);
*self = Span::new(span.lo, span.hi, span.ctxt);
}
#[inline]
- pub fn glob_adjust(&mut self, expansion: Mark, glob_span: Span) -> Option<Option<Mark>> {
+ pub fn glob_adjust(&mut self, expansion: ExpnId, glob_span: Span) -> Option<Option<ExpnId>> {
let mut span = self.data();
let mark = span.ctxt.glob_adjust(expansion, glob_span);
*self = Span::new(span.lo, span.hi, span.ctxt);
}
#[inline]
- pub fn reverse_glob_adjust(&mut self, expansion: Mark, glob_span: Span)
- -> Option<Option<Mark>> {
+ pub fn reverse_glob_adjust(&mut self, expansion: ExpnId, glob_span: Span)
+ -> Option<Option<ExpnId>> {
let mut span = self.data();
let mark = span.ctxt.reverse_glob_adjust(expansion, glob_span);
*self = Span::new(span.lo, span.hi, span.ctxt);
projects / rust.git / commitdiff