Adjust other names after the `Mark` renaming

27 files changed, 196 insertions, 192 deletions

diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs
index 854b09c6dc9..d02aab54127 100644
--- a/src/librustc/hir/map/def_collector.rs
+++ b/src/librustc/hir/map/def_collector.rs
@@ -75,7 +75,7 @@ impl<'a> DefCollector<'a> {
     }
 
     fn visit_macro_invoc(&mut self, id: NodeId) {
-        self.definitions.set_invocation_parent(id.placeholder_to_mark(), self.parent_def);
+        self.definitions.set_invocation_parent(id.placeholder_to_expn_id(), self.parent_def);
     }
 }
 
diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs
index bbaa731abc9..8ee8c6d0e89 100644
--- a/src/librustc/hir/map/definitions.rs
+++ b/src/librustc/hir/map/definitions.rs
@@ -450,7 +450,7 @@ impl Definitions {
                                   parent: DefIndex,
                                   node_id: ast::NodeId,
                                   data: DefPathData,
-                                  expansion: ExpnId,
+                                  expn_id: ExpnId,
                                   span: Span)
                                   -> DefIndex {
         debug!("create_def_with_parent(parent={:?}, node_id={:?}, data={:?})",
@@ -498,8 +498,8 @@ impl Definitions {
             self.node_to_def_index.insert(node_id, index);
         }
 
-        if expansion != ExpnId::root() {
-            self.expansions_that_defined.insert(index, expansion);
+        if expn_id != ExpnId::root() {
+            self.expansions_that_defined.insert(index, expn_id);
         }
 
         // The span is added if it isn't dummy
@@ -523,12 +523,12 @@ impl Definitions {
         self.expansions_that_defined.get(&index).cloned().unwrap_or(ExpnId::root())
     }
 
-    pub fn parent_module_of_macro_def(&self, mark: ExpnId) -> DefId {
-        self.parent_modules_of_macro_defs[&mark]
+    pub fn parent_module_of_macro_def(&self, expn_id: ExpnId) -> DefId {
+        self.parent_modules_of_macro_defs[&expn_id]
     }
 
-    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 add_parent_module_of_macro_def(&mut self, expn_id: ExpnId, module: DefId) {
+        self.parent_modules_of_macro_defs.insert(expn_id, module);
     }
 
     pub fn invocation_parent(&self, invoc_id: ExpnId) -> DefIndex {
diff --git a/src/librustc/ty/query/on_disk_cache.rs b/src/librustc/ty/query/on_disk_cache.rs
index 333964514c1..77a6abd4b77 100644
--- a/src/librustc/ty/query/on_disk_cache.rs
+++ b/src/librustc/ty/query/on_disk_cache.rs
@@ -588,7 +588,7 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for CacheDecoder<'a, 'tcx> {
 
         let expn_info_tag = u8::decode(self)?;
 
-        // FIXME(mw): This method does not restore `MarkData::parent` or
+        // FIXME(mw): This method does not restore `InternalExpnData::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.
diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs
index bb11657d0c4..47a741ca714 100644
--- a/src/librustc_interface/passes.rs
+++ b/src/librustc_interface/passes.rs
@@ -572,7 +572,7 @@ pub fn lower_to_hir(
 
     // Discard hygiene data, which isn't required after lowering to HIR.
     if !sess.opts.debugging_opts.keep_hygiene_data {
-        syntax::ext::hygiene::clear_markings();
+        syntax::ext::hygiene::syntax_context_map();
     }
 
     Ok(hir_forest)
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
index 9ac63996898..ee11228654b 100644
--- a/src/librustc_resolve/build_reduced_graph.rs
+++ b/src/librustc_resolve/build_reduced_graph.rs
@@ -571,13 +571,13 @@ impl<'a> Resolver<'a> {
                                        variant: &Variant,
                                        parent: Module<'a>,
                                        vis: ty::Visibility,
-                                       expansion: ExpnId) {
+                                       expn_id: ExpnId) {
         let ident = variant.node.ident;
 
         // Define a name in the type namespace.
         let def_id = self.definitions.local_def_id(variant.node.id);
         let res = Res::Def(DefKind::Variant, def_id);
-        self.define(parent, ident, TypeNS, (res, vis, variant.span, expansion));
+        self.define(parent, ident, TypeNS, (res, vis, variant.span, expn_id));
 
         // If the variant is marked as non_exhaustive then lower the visibility to within the
         // crate.
@@ -596,11 +596,11 @@ impl<'a> Resolver<'a> {
         let ctor_def_id = self.definitions.local_def_id(ctor_node_id);
         let ctor_kind = CtorKind::from_ast(&variant.node.data);
         let ctor_res = Res::Def(DefKind::Ctor(CtorOf::Variant, ctor_kind), ctor_def_id);
-        self.define(parent, ident, ValueNS, (ctor_res, ctor_vis, variant.span, expansion));
+        self.define(parent, ident, ValueNS, (ctor_res, ctor_vis, variant.span, expn_id));
     }
 
     /// Constructs the reduced graph for one foreign item.
-    fn build_reduced_graph_for_foreign_item(&mut self, item: &ForeignItem, expansion: ExpnId) {
+    fn build_reduced_graph_for_foreign_item(&mut self, item: &ForeignItem, expn_id: ExpnId) {
         let (res, ns) = match item.node {
             ForeignItemKind::Fn(..) => {
                 (Res::Def(DefKind::Fn, self.definitions.local_def_id(item.id)), ValueNS)
@@ -615,16 +615,16 @@ impl<'a> Resolver<'a> {
         };
         let parent = self.current_module;
         let vis = self.resolve_visibility(&item.vis);
-        self.define(parent, item.ident, ns, (res, vis, item.span, expansion));
+        self.define(parent, item.ident, ns, (res, vis, item.span, expn_id));
     }
 
-    fn build_reduced_graph_for_block(&mut self, block: &Block, expansion: ExpnId) {
+    fn build_reduced_graph_for_block(&mut self, block: &Block, expn_id: ExpnId) {
         let parent = self.current_module;
         if self.block_needs_anonymous_module(block) {
             let module = self.new_module(parent,
                                          ModuleKind::Block(block.id),
                                          parent.normal_ancestor_id,
-                                         expansion,
+                                         expn_id,
                                          block.span);
             self.block_map.insert(block.id, module);
             self.current_module = module; // Descend into the block.
@@ -741,8 +741,8 @@ impl<'a> Resolver<'a> {
         module
     }
 
-    pub fn macro_def_scope(&mut self, expansion: ExpnId) -> Module<'a> {
-        let def_id = match self.macro_defs.get(&expansion) {
+    pub fn macro_def_scope(&mut self, expn_id: ExpnId) -> Module<'a> {
+        let def_id = match self.macro_defs.get(&expn_id) {
             Some(def_id) => *def_id,
             None => return self.graph_root,
         };
@@ -924,7 +924,7 @@ pub struct BuildReducedGraphVisitor<'a, 'b> {
 
 impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
     fn visit_invoc(&mut self, id: ast::NodeId) -> &'b InvocationData<'b> {
-        let invoc_id = id.placeholder_to_mark();
+        let invoc_id = id.placeholder_to_expn_id();
 
         self.resolver.current_module.unresolved_invocations.borrow_mut().insert(invoc_id);
 
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index d088197b45d..0dae558c213 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -2095,10 +2095,10 @@ impl<'a> Resolver<'a> {
         parent: Module<'a>,
         kind: ModuleKind,
         normal_ancestor_id: DefId,
-        expansion: ExpnId,
+        expn_id: ExpnId,
         span: Span,
     ) -> Module<'a> {
-        let module = ModuleData::new(Some(parent), kind, normal_ancestor_id, expansion, span);
+        let module = ModuleData::new(Some(parent), kind, normal_ancestor_id, expn_id, span);
         self.arenas.alloc_module(module)
     }
 
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
index 6fa97df5e17..08db285b543 100644
--- a/src/librustc_resolve/macros.rs
+++ b/src/librustc_resolve/macros.rs
@@ -160,15 +160,15 @@ impl<'a> base::Resolver for Resolver<'a> {
         });
     }
 
-    fn visit_ast_fragment_with_placeholders(&mut self, mark: ExpnId, fragment: &AstFragment,
+    fn visit_ast_fragment_with_placeholders(&mut self, expn_id: ExpnId, fragment: &AstFragment,
                                             derives: &[ExpnId]) {
-        fragment.visit_with(&mut DefCollector::new(&mut self.definitions, mark));
+        fragment.visit_with(&mut DefCollector::new(&mut self.definitions, expn_id));
 
-        let invocation = self.invocations[&mark];
+        let invocation = self.invocations[&expn_id];
         self.current_module = invocation.module;
-        self.current_module.unresolved_invocations.borrow_mut().remove(&mark);
+        self.current_module.unresolved_invocations.borrow_mut().remove(&expn_id);
         self.current_module.unresolved_invocations.borrow_mut().extend(derives);
-        let parent_def = self.definitions.invocation_parent(mark);
+        let parent_def = self.definitions.invocation_parent(expn_id);
         for &derive_invoc_id in derives {
             self.definitions.set_invocation_parent(derive_invoc_id, parent_def);
         }
@@ -176,7 +176,7 @@ impl<'a> base::Resolver for Resolver<'a> {
         let mut visitor = BuildReducedGraphVisitor {
             resolver: self,
             current_legacy_scope: invocation.parent_legacy_scope,
-            expansion: mark,
+            expansion: expn_id,
         };
         fragment.visit_with(&mut visitor);
         invocation.output_legacy_scope.set(Some(visitor.current_legacy_scope));
@@ -223,16 +223,16 @@ impl<'a> base::Resolver for Resolver<'a> {
         let (ext, res) = self.smart_resolve_macro_path(path, kind, &parent_scope, force)?;
 
         let span = invoc.span();
-        invoc.expansion_data.mark.set_expn_info(ext.expn_info(span, fast_print_path(path)));
+        invoc.expansion_data.id.set_expn_info(ext.expn_info(span, fast_print_path(path)));
 
         if let Res::Def(_, def_id) = res {
             if after_derive {
                 self.session.span_err(span, "macro attributes must be placed before `#[derive]`");
             }
-            self.macro_defs.insert(invoc.expansion_data.mark, def_id);
+            self.macro_defs.insert(invoc.expansion_data.id, def_id);
             let normal_module_def_id =
-                self.macro_def_scope(invoc.expansion_data.mark).normal_ancestor_id;
-            self.definitions.add_parent_module_of_macro_def(invoc.expansion_data.mark,
+                self.macro_def_scope(invoc.expansion_data.id).normal_ancestor_id;
+            self.definitions.add_parent_module_of_macro_def(invoc.expansion_data.id,
                                                             normal_module_def_id);
         }
 
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index eb67fb94b7d..b9b43c89346 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -251,11 +251,11 @@ mod node_id_inner {
 pub use node_id_inner::NodeId;
 
 impl NodeId {
-    pub fn placeholder_from_mark(mark: ExpnId) -> Self {
-        NodeId::from_u32(mark.as_u32())
+    pub fn placeholder_from_expn_id(expn_id: ExpnId) -> Self {
+        NodeId::from_u32(expn_id.as_u32())
     }
 
-    pub fn placeholder_to_mark(self) -> ExpnId {
+    pub fn placeholder_to_expn_id(self) -> ExpnId {
         ExpnId::from_u32(self.as_u32())
     }
 }
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 00b614d1584..926c9e88efe 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -685,7 +685,7 @@ pub trait Resolver {
     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: ExpnId, fragment: &AstFragment,
+    fn visit_ast_fragment_with_placeholders(&mut self, expn_id: ExpnId, fragment: &AstFragment,
                                             derives: &[ExpnId]);
     fn add_builtin(&mut self, ident: ast::Ident, ext: Lrc<SyntaxExtension>);
 
@@ -705,7 +705,7 @@ pub struct ModuleData {
 
 #[derive(Clone)]
 pub struct ExpansionData {
-    pub mark: ExpnId,
+    pub id: ExpnId,
     pub depth: usize,
     pub module: Rc<ModuleData>,
     pub directory_ownership: DirectoryOwnership,
@@ -735,7 +735,7 @@ impl<'a> ExtCtxt<'a> {
             root_path: PathBuf::new(),
             resolver,
             current_expansion: ExpansionData {
-                mark: ExpnId::root(),
+                id: ExpnId::root(),
                 depth: 0,
                 module: Rc::new(ModuleData { mod_path: Vec::new(), directory: PathBuf::new() }),
                 directory_ownership: DirectoryOwnership::Owned { relative: None },
@@ -763,13 +763,13 @@ impl<'a> ExtCtxt<'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 {
-        match self.current_expansion.mark.expn_info() {
+        match self.current_expansion.id.expn_info() {
             Some(expn_info) => expn_info.call_site,
             None => DUMMY_SP,
         }
     }
     pub fn backtrace(&self) -> SyntaxContext {
-        SyntaxContext::empty().apply_mark(self.current_expansion.mark)
+        SyntaxContext::empty().apply_mark(self.current_expansion.id)
     }
 
     /// Returns span for the macro which originally caused the current expansion to happen.
@@ -877,7 +877,7 @@ impl<'a> ExtCtxt<'a> {
         ast::Ident::from_str(st)
     }
     pub fn std_path(&self, components: &[Symbol]) -> Vec<ast::Ident> {
-        let def_site = DUMMY_SP.apply_mark(self.current_expansion.mark);
+        let def_site = DUMMY_SP.apply_mark(self.current_expansion.id);
         iter::once(Ident::new(kw::DollarCrate, def_site))
             .chain(components.iter().map(|&s| Ident::with_empty_ctxt(s)))
             .collect()
@@ -900,7 +900,7 @@ pub fn expr_to_spanned_string<'a>(
     err_msg: &str,
 ) -> Result<Spanned<(Symbol, ast::StrStyle)>, Option<DiagnosticBuilder<'a>>> {
     // Update `expr.span`'s ctxt now in case expr is an `include!` macro invocation.
-    expr.span = expr.span.apply_mark(cx.current_expansion.mark);
+    expr.span = expr.span.apply_mark(cx.current_expansion.id);
 
     // we want to be able to handle e.g., `concat!("foo", "bar")`
     cx.expander().visit_expr(&mut expr);
diff --git a/src/libsyntax/ext/derive.rs b/src/libsyntax/ext/derive.rs
index 1c15deab373..ff9ad46deec 100644
--- a/src/libsyntax/ext/derive.rs
+++ b/src/libsyntax/ext/derive.rs
@@ -54,7 +54,7 @@ pub fn add_derived_markers<T>(cx: &mut ExtCtxt<'_>, span: Span, traits: &[ast::P
         names.insert(unwrap_or!(path.segments.get(0), continue).ident.name);
     }
 
-    let span = span.fresh_expansion(cx.current_expansion.mark, ExpnInfo::allow_unstable(
+    let span = span.fresh_expansion(cx.current_expansion.id, ExpnInfo::allow_unstable(
         ExpnKind::Macro(MacroKind::Derive, Symbol::intern(&pretty_name)), span,
         cx.parse_sess.edition, cx.allow_derive_markers.clone(),
     ));
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 8eb26ae8d33..ae72f1fd108 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -319,7 +319,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
             };
 
             let scope =
-                if self.monotonic { invoc.expansion_data.mark } else { orig_expansion_data.mark };
+                if self.monotonic { invoc.expansion_data.id } else { orig_expansion_data.id };
             let ext = match self.cx.resolver.resolve_macro_invocation(&invoc, scope, force) {
                 Ok(ext) => ext,
                 Err(Indeterminate) => {
@@ -329,9 +329,9 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
             };
 
             progress = true;
-            let ExpansionData { depth, mark, .. } = invoc.expansion_data;
+            let ExpansionData { depth, id: expn_id, .. } = invoc.expansion_data;
             self.cx.current_expansion = invoc.expansion_data.clone();
-            self.cx.current_expansion.mark = scope;
+            self.cx.current_expansion.id = scope;
 
             // FIXME(jseyfried): Refactor out the following logic
             let (expanded_fragment, new_invocations) = if let Some(ext) = ext {
@@ -362,13 +362,13 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                 item.visit_attrs(|attrs| attrs.retain(|a| a.path != sym::derive));
                 let mut item_with_markers = item.clone();
                 add_derived_markers(&mut self.cx, item.span(), &traits, &mut item_with_markers);
-                let derives = derives.entry(invoc.expansion_data.mark).or_default();
+                let derives = derives.entry(invoc.expansion_data.id).or_default();
 
                 derives.reserve(traits.len());
                 invocations.reserve(traits.len());
                 for path in traits {
-                    let mark = ExpnId::fresh(self.cx.current_expansion.mark, None);
-                    derives.push(mark);
+                    let expn_id = ExpnId::fresh(self.cx.current_expansion.id, None);
+                    derives.push(expn_id);
                     invocations.push(Invocation {
                         kind: InvocationKind::Derive {
                             path,
@@ -377,7 +377,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                         },
                         fragment_kind: invoc.fragment_kind,
                         expansion_data: ExpansionData {
-                            mark,
+                            id: expn_id,
                             ..invoc.expansion_data.clone()
                         },
                     });
@@ -392,7 +392,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
             if expanded_fragments.len() < depth {
                 expanded_fragments.push(Vec::new());
             }
-            expanded_fragments[depth - 1].push((mark, expanded_fragment));
+            expanded_fragments[depth - 1].push((expn_id, expanded_fragment));
             if !self.cx.ecfg.single_step {
                 invocations.extend(new_invocations.into_iter().rev());
             }
@@ -405,7 +405,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
         while let Some(expanded_fragments) = expanded_fragments.pop() {
             for (mark, expanded_fragment) in expanded_fragments.into_iter().rev() {
                 let derives = derives.remove(&mark).unwrap_or_else(Vec::new);
-                placeholder_expander.add(NodeId::placeholder_from_mark(mark),
+                placeholder_expander.add(NodeId::placeholder_from_expn_id(mark),
                                          expanded_fragment, derives);
             }
         }
@@ -444,7 +444,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
 
         if self.monotonic {
             self.cx.resolver.visit_ast_fragment_with_placeholders(
-                self.cx.current_expansion.mark, &fragment, derives);
+                self.cx.current_expansion.id, &fragment, derives);
         }
 
         (fragment, invocations)
@@ -493,7 +493,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
         }
 
         if self.cx.current_expansion.depth > self.cx.ecfg.recursion_limit {
-            let info = self.cx.current_expansion.mark.expn_info().unwrap();
+            let info = self.cx.current_expansion.id.expn_info().unwrap();
             let suggested_limit = self.cx.ecfg.recursion_limit * 2;
             let mut err = self.cx.struct_span_err(info.call_site,
                 &format!("recursion limit reached while expanding the macro `{}`",
@@ -822,17 +822,17 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
             )),
             _ => None,
         };
-        let mark = ExpnId::fresh(self.cx.current_expansion.mark, expn_info);
+        let expn_id = ExpnId::fresh(self.cx.current_expansion.id, expn_info);
         self.invocations.push(Invocation {
             kind,
             fragment_kind,
             expansion_data: ExpansionData {
-                mark,
+                id: expn_id,
                 depth: self.cx.current_expansion.depth + 1,
                 ..self.cx.current_expansion.clone()
             },
         });
-        placeholder(fragment_kind, NodeId::placeholder_from_mark(mark))
+        placeholder(fragment_kind, NodeId::placeholder_from_expn_id(expn_id))
     }
 
     fn collect_bang(&mut self, mac: ast::Mac, span: Span, kind: AstFragmentKind) -> AstFragment {
diff --git a/src/libsyntax/ext/placeholders.rs b/src/libsyntax/ext/placeholders.rs
index 872292bb600..17d8bf3ab17 100644
--- a/src/libsyntax/ext/placeholders.rs
+++ b/src/libsyntax/ext/placeholders.rs
@@ -88,7 +88,7 @@ impl<'a, 'b> PlaceholderExpander<'a, 'b> {
         fragment.mut_visit_with(self);
         if let AstFragment::Items(mut items) = fragment {
             for derive in derives {
-                match self.remove(NodeId::placeholder_from_mark(derive)) {
+                match self.remove(NodeId::placeholder_from_expn_id(derive)) {
                     AstFragment::Items(derived_items) => items.extend(derived_items),
                     _ => unreachable!(),
                 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index e04fd2ddc05..845dac557e8 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -219,7 +219,7 @@ pub fn transcribe(
                         if let NtTT(ref tt) = **nt {
                             result.push(tt.clone().into());
                         } else {
-                            sp = sp.apply_mark(cx.current_expansion.mark);
+                            sp = sp.apply_mark(cx.current_expansion.id);
                             let token = TokenTree::token(token::Interpolated(nt.clone()), sp);
                             result.push(token.into());
                         }
@@ -234,8 +234,8 @@ pub fn transcribe(
                     // If we aren't able to match the meta-var, we push it back into the result but
                     // with modified syntax context. (I believe this supports nested macros).
                     let ident =
-                        Ident::new(ident.name, ident.span.apply_mark(cx.current_expansion.mark));
-                    sp = sp.apply_mark(cx.current_expansion.mark);
+                        Ident::new(ident.name, ident.span.apply_mark(cx.current_expansion.id));
+                    sp = sp.apply_mark(cx.current_expansion.id);
                     result.push(TokenTree::token(token::Dollar, sp).into());
                     result.push(TokenTree::Token(Token::from_ast_ident(ident)).into());
                 }
@@ -247,7 +247,7 @@ pub fn transcribe(
             // jump back out of the Delimited, pop the result_stack and add the new results back to
             // the previous results (from outside the Delimited).
             quoted::TokenTree::Delimited(mut span, delimited) => {
-                span = span.apply_mark(cx.current_expansion.mark);
+                span = span.apply_mark(cx.current_expansion.id);
                 stack.push(Frame::Delimited { forest: delimited, idx: 0, span });
                 result_stack.push(mem::take(&mut result));
             }
@@ -255,7 +255,7 @@ pub fn transcribe(
             // Nothing much to do here. Just push the token to the result, being careful to
             // preserve syntax context.
             quoted::TokenTree::Token(token) => {
-                let mut marker = Marker(cx.current_expansion.mark);
+                let mut marker = Marker(cx.current_expansion.id);
                 let mut tt = TokenTree::Token(token);
                 noop_visit_tt(&mut tt, &mut marker);
                 result.push(tt.into());
diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
index 72d62dbd46b..d82cdce2ce9 100644
--- a/src/libsyntax/test.rs
+++ b/src/libsyntax/test.rs
@@ -232,7 +232,7 @@ fn mk_reexport_mod(cx: &mut TestCtxt<'_>,
 
     let name = Ident::from_str("__test_reexports").gensym();
     let parent = if parent == ast::DUMMY_NODE_ID { ast::CRATE_NODE_ID } else { parent };
-    cx.ext_cx.current_expansion.mark = cx.ext_cx.resolver.get_module_scope(parent);
+    cx.ext_cx.current_expansion.id = cx.ext_cx.resolver.get_module_scope(parent);
     let it = cx.ext_cx.monotonic_expander().flat_map_item(P(ast::Item {
         ident: name,
         attrs: Vec::new(),
diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs
index 1f05be3a519..88142344d79 100644
--- a/src/libsyntax/tokenstream.rs
+++ b/src/libsyntax/tokenstream.rs
@@ -545,10 +545,10 @@ impl DelimSpan {
         self.open.with_hi(self.close.hi())
     }
 
-    pub fn apply_mark(self, mark: ExpnId) -> Self {
+    pub fn apply_mark(self, expn_id: ExpnId) -> Self {
         DelimSpan {
-            open: self.open.apply_mark(mark),
-            close: self.close.apply_mark(mark),
+            open: self.open.apply_mark(expn_id),
+            close: self.close.apply_mark(expn_id),
         }
     }
 }
diff --git a/src/libsyntax_ext/assert.rs b/src/libsyntax_ext/assert.rs
index 637614a18bc..235565314f5 100644
--- a/src/libsyntax_ext/assert.rs
+++ b/src/libsyntax_ext/assert.rs
@@ -25,7 +25,7 @@ pub fn expand_assert<'cx>(
         }
     };
 
-    let sp = sp.apply_mark(cx.current_expansion.mark);
+    let sp = sp.apply_mark(cx.current_expansion.id);
     let panic_call = Mac_ {
         path: Path::from_ident(Ident::new(sym::panic, sp)),
         tts: custom_message.unwrap_or_else(|| {
diff --git a/src/libsyntax_ext/cfg.rs b/src/libsyntax_ext/cfg.rs
index e952515bfe0..2b64f558be0 100644
--- a/src/libsyntax_ext/cfg.rs
+++ b/src/libsyntax_ext/cfg.rs
@@ -17,7 +17,7 @@ pub fn expand_cfg(
     sp: Span,
     tts: &[tokenstream::TokenTree],
 ) -> Box<dyn base::MacResult + 'static> {
-    let sp = sp.apply_mark(cx.current_expansion.mark);
+    let sp = sp.apply_mark(cx.current_expansion.id);
 
     match parse_cfg(cx, sp, tts) {
         Ok(cfg) => {
diff --git a/src/libsyntax_ext/concat.rs b/src/libsyntax_ext/concat.rs
index 68d5178372e..dbc985fd859 100644
--- a/src/libsyntax_ext/concat.rs
+++ b/src/libsyntax_ext/concat.rs
@@ -60,6 +60,6 @@ pub fn expand_syntax_ext(
     } else if has_errors {
         return base::DummyResult::expr(sp);
     }
-    let sp = sp.apply_mark(cx.current_expansion.mark);
+    let sp = sp.apply_mark(cx.current_expansion.id);
     base::MacEager::expr(cx.expr_str(sp, Symbol::intern(&accumulator)))
 }
diff --git a/src/libsyntax_ext/concat_idents.rs b/src/libsyntax_ext/concat_idents.rs
index df919141603..8184fc44267 100644
--- a/src/libsyntax_ext/concat_idents.rs
+++ b/src/libsyntax_ext/concat_idents.rs
@@ -39,7 +39,7 @@ pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt<'_>,
         }
     }
 
-    let ident = ast::Ident::new(Symbol::intern(&res_str), sp.apply_mark(cx.current_expansion.mark));
+    let ident = ast::Ident::new(Symbol::intern(&res_str), sp.apply_mark(cx.current_expansion.id));
 
     struct ConcatIdentsResult { ident: ast::Ident }
 
diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs
index 02b02e9b836..fef1b4eebcf 100644
--- a/src/libsyntax_ext/deriving/generic/ty.rs
+++ b/src/libsyntax_ext/deriving/generic/ty.rs
@@ -85,7 +85,7 @@ impl<'a> Path<'a> {
             PathKind::Global => cx.path_all(span, true, idents, params, Vec::new()),
             PathKind::Local => cx.path_all(span, false, idents, params, Vec::new()),
             PathKind::Std => {
-                let def_site = DUMMY_SP.apply_mark(cx.current_expansion.mark);
+                let def_site = DUMMY_SP.apply_mark(cx.current_expansion.id);
                 idents.insert(0, Ident::new(kw::DollarCrate, def_site));
                 cx.path_all(span, false, idents, params, Vec::new())
             }
diff --git a/src/libsyntax_ext/env.rs b/src/libsyntax_ext/env.rs
index b7f2ecf0f91..03c60e3f11f 100644
--- a/src/libsyntax_ext/env.rs
+++ b/src/libsyntax_ext/env.rs
@@ -21,7 +21,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt<'_>,
         Some(v) => v,
     };
 
-    let sp = sp.apply_mark(cx.current_expansion.mark);
+    let sp = sp.apply_mark(cx.current_expansion.id);
     let e = match env::var(&*var.as_str()) {
         Err(..) => {
             let lt = cx.lifetime(sp, Ident::with_empty_ctxt(kw::StaticLifetime));
diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs
index c3dbd48cc6e..2f0d9950985 100644
--- a/src/libsyntax_ext/format.rs
+++ b/src/libsyntax_ext/format.rs
@@ -575,7 +575,7 @@ impl<'a, 'b> Context<'a, 'b> {
         for (i, e) in self.args.into_iter().enumerate() {
             let name = names_pos[i];
             let span =
-                DUMMY_SP.with_ctxt(e.span.ctxt().apply_mark(self.ecx.current_expansion.mark));
+                DUMMY_SP.with_ctxt(e.span.ctxt().apply_mark(self.ecx.current_expansion.id));
             pats.push(self.ecx.pat_ident(span, name));
             for ref arg_ty in self.arg_unique_types[i].iter() {
                 locals.push(Context::format_arg(self.ecx, self.macsp, e.span, arg_ty, name));
@@ -652,7 +652,7 @@ impl<'a, 'b> Context<'a, 'b> {
                   ty: &ArgumentType,
                   arg: ast::Ident)
                   -> P<ast::Expr> {
-        sp = sp.apply_mark(ecx.current_expansion.mark);
+        sp = sp.apply_mark(ecx.current_expansion.id);
         let arg = ecx.expr_ident(sp, arg);
         let trait_ = match *ty {
             Placeholder(ref tyname) => {
@@ -691,7 +691,7 @@ fn expand_format_args_impl<'cx>(
     tts: &[tokenstream::TokenTree],
     nl: bool,
 ) -> Box<dyn base::MacResult + 'cx> {
-    sp = sp.apply_mark(ecx.current_expansion.mark);
+    sp = sp.apply_mark(ecx.current_expansion.id);
     match parse_args(ecx, sp, tts) {
         Ok((efmt, args, names)) => {
             MacEager::expr(expand_preparsed_format_args(ecx, sp, efmt, args, names, nl))
@@ -734,7 +734,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt<'_>,
     let arg_unique_types: Vec<_> = (0..args.len()).map(|_| Vec::new()).collect();
 
     let mut macsp = ecx.call_site();
-    macsp = macsp.apply_mark(ecx.current_expansion.mark);
+    macsp = macsp.apply_mark(ecx.current_expansion.id);
 
     let msg = "format argument must be a string literal";
     let fmt_sp = efmt.span;
diff --git a/src/libsyntax_ext/proc_macro_server.rs b/src/libsyntax_ext/proc_macro_server.rs
index e5027354527..e94d79a140d 100644
--- a/src/libsyntax_ext/proc_macro_server.rs
+++ b/src/libsyntax_ext/proc_macro_server.rs
@@ -364,11 +364,11 @@ pub(crate) struct Rustc<'a> {
 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.mark.expn_info().unwrap().call_site;
+        let location = cx.current_expansion.id.expn_info().unwrap().call_site;
         let to_span = |transparency| {
             location.with_ctxt(
                 SyntaxContext::empty()
-                    .apply_mark_with_transparency(cx.current_expansion.mark, transparency),
+                    .apply_mark_with_transparency(cx.current_expansion.id, transparency),
             )
         };
         Rustc {
diff --git a/src/libsyntax_ext/test.rs b/src/libsyntax_ext/test.rs
index 4386fe8cfa2..f8755a1d1d7 100644
--- a/src/libsyntax_ext/test.rs
+++ b/src/libsyntax_ext/test.rs
@@ -59,7 +59,7 @@ pub fn expand_test_or_bench(
         return vec![Annotatable::Item(item)];
     }
 
-    let ctxt = SyntaxContext::empty().apply_mark(cx.current_expansion.mark);
+    let ctxt = SyntaxContext::empty().apply_mark(cx.current_expansion.id);
     let (sp, attr_sp) = (item.span.with_ctxt(ctxt), attr_sp.with_ctxt(ctxt));
 
     // Gensym "test" so we can extern crate without conflicting with any local names
diff --git a/src/libsyntax_ext/test_case.rs b/src/libsyntax_ext/test_case.rs
index af2cf42e04b..355f2428e08 100644
--- a/src/libsyntax_ext/test_case.rs
+++ b/src/libsyntax_ext/test_case.rs
@@ -25,7 +25,7 @@ pub fn expand(
 ) -> Vec<Annotatable> {
     if !ecx.ecfg.should_test { return vec![]; }
 
-    let sp = attr_sp.with_ctxt(SyntaxContext::empty().apply_mark(ecx.current_expansion.mark));
+    let sp = attr_sp.with_ctxt(SyntaxContext::empty().apply_mark(ecx.current_expansion.id));
     let mut item = anno_item.expect_item();
     item = item.map(|mut item| {
         item.vis = respan(item.vis.span, ast::VisibilityKind::Public);
diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs
index 731a2d1c121..bea7809e029 100644
--- a/src/libsyntax_pos/hygiene.rs
+++ b/src/libsyntax_pos/hygiene.rs
@@ -35,33 +35,34 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lrc;
 use std::fmt;
 
-/// A SyntaxContext represents a chain of macro expansions (represented by marks).
+/// A `SyntaxContext` represents a chain of pairs `(ExpnId, Transparency)` named "marks".
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct SyntaxContext(u32);
 
 #[derive(Debug)]
 struct SyntaxContextData {
-    outer_mark: ExpnId,
+    outer_expn: ExpnId,
     transparency: Transparency,
     prev_ctxt: SyntaxContext,
-    /// This context, but with all transparent and semi-transparent marks filtered away.
+    /// This context, but with all transparent and semi-transparent expansions filtered away.
     opaque: SyntaxContext,
-    /// This context, but with all transparent marks filtered away.
+    /// This context, but with all transparent expansions filtered away.
     opaque_and_semitransparent: SyntaxContext,
     /// Name of the crate to which `$crate` with this context would resolve.
     dollar_crate_name: Symbol,
 }
 
-/// A mark is a unique ID associated with a macro expansion.
+/// A unique ID associated with a macro invocation and expansion.
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub struct ExpnId(u32);
 
+// FIXME: Find a way to merge this with `ExpnInfo`.
 #[derive(Debug)]
-struct MarkData {
+struct InternalExpnData {
     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.
+    /// 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
+    /// first and then resolved later), so we use an `Option` here.
     expn_info: Option<ExpnInfo>,
 }
 
@@ -86,10 +87,10 @@ pub enum Transparency {
 
 impl ExpnId {
     pub fn fresh(parent: ExpnId, expn_info: Option<ExpnInfo>) -> Self {
-        HygieneData::with(|data| data.fresh_mark(parent, expn_info))
+        HygieneData::with(|data| data.fresh_expn(parent, expn_info))
     }
 
-    /// The mark of the theoretical expansion that generates freshly parsed, unexpanded AST.
+    /// The ID of the theoretical expansion that generates freshly parsed, unexpanded AST.
     #[inline]
     pub fn root() -> Self {
         ExpnId(0)
@@ -107,7 +108,7 @@ impl ExpnId {
 
     #[inline]
     pub fn parent(self) -> ExpnId {
-        HygieneData::with(|data| data.marks[self.0 as usize].parent)
+        HygieneData::with(|data| data.expn_data[self.0 as usize].parent)
     }
 
     #[inline]
@@ -118,8 +119,8 @@ impl ExpnId {
     #[inline]
     pub fn set_expn_info(self, info: ExpnInfo) {
         HygieneData::with(|data| {
-            let old_info = &mut data.marks[self.0 as usize].expn_info;
-            assert!(old_info.is_none(), "expansion info is reset for a mark");
+            let old_info = &mut data.expn_data[self.0 as usize].expn_info;
+            assert!(old_info.is_none(), "expansion info is reset for an expansion ID");
             *old_info = Some(info);
         })
     }
@@ -128,8 +129,8 @@ impl ExpnId {
         HygieneData::with(|data| data.is_descendant_of(self, ancestor))
     }
 
-    /// `mark.outer_is_descendant_of(ctxt)` is equivalent to but faster than
-    /// `mark.is_descendant_of(ctxt.outer())`.
+    /// `expn_id.outer_is_descendant_of(ctxt)` is equivalent to but faster than
+    /// `expn_id.is_descendant_of(ctxt.outer())`.
     pub fn outer_is_descendant_of(self, ctxt: SyntaxContext) -> bool {
         HygieneData::with(|data| data.is_descendant_of(self, data.outer(ctxt)))
     }
@@ -152,27 +153,27 @@ impl ExpnId {
 
 #[derive(Debug)]
 crate struct HygieneData {
-    marks: Vec<MarkData>,
-    syntax_contexts: Vec<SyntaxContextData>,
-    markings: FxHashMap<(SyntaxContext, ExpnId, Transparency), SyntaxContext>,
+    expn_data: Vec<InternalExpnData>,
+    syntax_context_data: Vec<SyntaxContextData>,
+    syntax_context_map: FxHashMap<(SyntaxContext, ExpnId, Transparency), SyntaxContext>,
 }
 
 impl HygieneData {
     crate fn new(edition: Edition) -> Self {
         HygieneData {
-            marks: vec![MarkData {
+            expn_data: vec![InternalExpnData {
                 parent: ExpnId::root(),
                 expn_info: Some(ExpnInfo::default(ExpnKind::Root, DUMMY_SP, edition)),
             }],
-            syntax_contexts: vec![SyntaxContextData {
-                outer_mark: ExpnId::root(),
+            syntax_context_data: vec![SyntaxContextData {
+                outer_expn: ExpnId::root(),
                 transparency: Transparency::Opaque,
                 prev_ctxt: SyntaxContext(0),
                 opaque: SyntaxContext(0),
                 opaque_and_semitransparent: SyntaxContext(0),
                 dollar_crate_name: kw::DollarCrate,
             }],
-            markings: FxHashMap::default(),
+            syntax_context_map: FxHashMap::default(),
         }
     }
 
@@ -180,15 +181,15 @@ impl HygieneData {
         GLOBALS.with(|globals| f(&mut *globals.hygiene_data.borrow_mut()))
     }
 
-    fn fresh_mark(&mut self, parent: ExpnId, expn_info: Option<ExpnInfo>) -> ExpnId {
-        self.marks.push(MarkData { parent, expn_info });
-        ExpnId(self.marks.len() as u32 - 1)
+    fn fresh_expn(&mut self, parent: ExpnId, expn_info: Option<ExpnInfo>) -> ExpnId {
+        self.expn_data.push(InternalExpnData { parent, expn_info });
+        ExpnId(self.expn_data.len() as u32 - 1)
     }
 
-    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"))
+    fn expn_info(&self, expn_id: ExpnId) -> Option<&ExpnInfo> {
+        if expn_id != ExpnId::root() {
+            Some(self.expn_data[expn_id.0 as usize].expn_info.as_ref()
+                     .expect("no expansion info for an expansion ID"))
         } else {
             // FIXME: Some code relies on `expn_info().is_none()` meaning "no expansion".
             // Introduce a method for checking for "no expansion" instead and always return
@@ -197,55 +198,55 @@ impl HygieneData {
         }
     }
 
-    fn is_descendant_of(&self, mut mark: ExpnId, ancestor: ExpnId) -> bool {
-        while mark != ancestor {
-            if mark == ExpnId::root() {
+    fn is_descendant_of(&self, mut expn_id: ExpnId, ancestor: ExpnId) -> bool {
+        while expn_id != ancestor {
+            if expn_id == ExpnId::root() {
                 return false;
             }
-            mark = self.marks[mark.0 as usize].parent;
+            expn_id = self.expn_data[expn_id.0 as usize].parent;
         }
         true
     }
 
-    fn default_transparency(&self, mark: ExpnId) -> Transparency {
-        self.expn_info(mark).map_or(
+    fn default_transparency(&self, expn_id: ExpnId) -> Transparency {
+        self.expn_info(expn_id).map_or(
             Transparency::SemiTransparent, |einfo| einfo.default_transparency
         )
     }
 
     fn modern(&self, ctxt: SyntaxContext) -> SyntaxContext {
-        self.syntax_contexts[ctxt.0 as usize].opaque
+        self.syntax_context_data[ctxt.0 as usize].opaque
     }
 
     fn modern_and_legacy(&self, ctxt: SyntaxContext) -> SyntaxContext {
-        self.syntax_contexts[ctxt.0 as usize].opaque_and_semitransparent
+        self.syntax_context_data[ctxt.0 as usize].opaque_and_semitransparent
     }
 
     fn outer(&self, ctxt: SyntaxContext) -> ExpnId {
-        self.syntax_contexts[ctxt.0 as usize].outer_mark
+        self.syntax_context_data[ctxt.0 as usize].outer_expn
     }
 
     fn transparency(&self, ctxt: SyntaxContext) -> Transparency {
-        self.syntax_contexts[ctxt.0 as usize].transparency
+        self.syntax_context_data[ctxt.0 as usize].transparency
     }
 
     fn prev_ctxt(&self, ctxt: SyntaxContext) -> SyntaxContext {
-        self.syntax_contexts[ctxt.0 as usize].prev_ctxt
+        self.syntax_context_data[ctxt.0 as usize].prev_ctxt
     }
 
     fn remove_mark(&self, ctxt: &mut SyntaxContext) -> ExpnId {
-        let outer_mark = self.syntax_contexts[ctxt.0 as usize].outer_mark;
+        let outer_expn = self.syntax_context_data[ctxt.0 as usize].outer_expn;
         *ctxt = self.prev_ctxt(*ctxt);
-        outer_mark
+        outer_expn
     }
 
     fn marks(&self, mut ctxt: SyntaxContext) -> Vec<(ExpnId, Transparency)> {
         let mut marks = Vec::new();
         while ctxt != SyntaxContext::empty() {
-            let outer_mark = self.outer(ctxt);
+            let outer_expn = self.outer(ctxt);
             let transparency = self.transparency(ctxt);
             let prev_ctxt = self.prev_ctxt(ctxt);
-            marks.push((outer_mark, transparency));
+            marks.push((outer_expn, transparency));
             ctxt = prev_ctxt;
         }
         marks.reverse();
@@ -263,28 +264,28 @@ impl HygieneData {
         span
     }
 
-    fn adjust(&self, ctxt: &mut SyntaxContext, expansion: ExpnId) -> Option<ExpnId> {
+    fn adjust(&self, ctxt: &mut SyntaxContext, expn_id: ExpnId) -> Option<ExpnId> {
         let mut scope = None;
-        while !self.is_descendant_of(expansion, self.outer(*ctxt)) {
+        while !self.is_descendant_of(expn_id, self.outer(*ctxt)) {
             scope = Some(self.remove_mark(ctxt));
         }
         scope
     }
 
-    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(&mut self, ctxt: SyntaxContext, expn_id: ExpnId) -> SyntaxContext {
+        assert_ne!(expn_id, ExpnId::root());
+        self.apply_mark_with_transparency(ctxt, expn_id, self.default_transparency(expn_id))
     }
 
-    fn apply_mark_with_transparency(&mut self, ctxt: SyntaxContext, mark: ExpnId,
+    fn apply_mark_with_transparency(&mut self, ctxt: SyntaxContext, expn_id: ExpnId,
                                     transparency: Transparency) -> SyntaxContext {
-        assert_ne!(mark, ExpnId::root());
+        assert_ne!(expn_id, ExpnId::root());
         if transparency == Transparency::Opaque {
-            return self.apply_mark_internal(ctxt, mark, transparency);
+            return self.apply_mark_internal(ctxt, expn_id, transparency);
         }
 
         let call_site_ctxt =
-            self.expn_info(mark).map_or(SyntaxContext::empty(), |info| info.call_site.ctxt());
+            self.expn_info(expn_id).map_or(SyntaxContext::empty(), |info| info.call_site.ctxt());
         let mut call_site_ctxt = if transparency == Transparency::SemiTransparent {
             self.modern(call_site_ctxt)
         } else {
@@ -292,10 +293,10 @@ impl HygieneData {
         };
 
         if call_site_ctxt == SyntaxContext::empty() {
-            return self.apply_mark_internal(ctxt, mark, transparency);
+            return self.apply_mark_internal(ctxt, expn_id, transparency);
         }
 
-        // Otherwise, `mark` is a macros 1.0 definition and the call site is in a
+        // Otherwise, `expn_id` is a macros 1.0 definition and the call site is in a
         // macros 2.0 expansion, i.e., a macros 1.0 invocation is in a macros 2.0 definition.
         //
         // In this case, the tokens from the macros 1.0 definition inherit the hygiene
@@ -304,25 +305,27 @@ impl HygieneData {
         // so that the macros 2.0 definition remains hygienic.
         //
         // See the example at `test/run-pass/hygiene/legacy_interaction.rs`.
-        for (mark, transparency) in self.marks(ctxt) {
-            call_site_ctxt = self.apply_mark_internal(call_site_ctxt, mark, transparency);
+        for (expn_id, transparency) in self.marks(ctxt) {
+            call_site_ctxt = self.apply_mark_internal(call_site_ctxt, expn_id, transparency);
         }
-        self.apply_mark_internal(call_site_ctxt, mark, transparency)
+        self.apply_mark_internal(call_site_ctxt, expn_id, 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;
+    fn apply_mark_internal(
+        &mut self, ctxt: SyntaxContext, expn_id: ExpnId, transparency: Transparency
+    ) -> SyntaxContext {
+        let syntax_context_data = &mut self.syntax_context_data;
+        let mut opaque = syntax_context_data[ctxt.0 as usize].opaque;
         let mut opaque_and_semitransparent =
-            syntax_contexts[ctxt.0 as usize].opaque_and_semitransparent;
+            syntax_context_data[ctxt.0 as usize].opaque_and_semitransparent;
 
         if transparency >= Transparency::Opaque {
             let prev_ctxt = opaque;
-            opaque = *self.markings.entry((prev_ctxt, mark, transparency)).or_insert_with(|| {
-                let new_opaque = SyntaxContext(syntax_contexts.len() as u32);
-                syntax_contexts.push(SyntaxContextData {
-                    outer_mark: mark,
+            opaque = *self.syntax_context_map.entry((prev_ctxt, expn_id, transparency))
+                                             .or_insert_with(|| {
+                let new_opaque = SyntaxContext(syntax_context_data.len() as u32);
+                syntax_context_data.push(SyntaxContextData {
+                    outer_expn: expn_id,
                     transparency,
                     prev_ctxt,
                     opaque: new_opaque,
@@ -336,11 +339,12 @@ impl HygieneData {
         if transparency >= Transparency::SemiTransparent {
             let prev_ctxt = opaque_and_semitransparent;
             opaque_and_semitransparent =
-                    *self.markings.entry((prev_ctxt, mark, transparency)).or_insert_with(|| {
+                    *self.syntax_context_map.entry((prev_ctxt, expn_id, transparency))
+                                            .or_insert_with(|| {
                 let new_opaque_and_semitransparent =
-                    SyntaxContext(syntax_contexts.len() as u32);
-                syntax_contexts.push(SyntaxContextData {
-                    outer_mark: mark,
+                    SyntaxContext(syntax_context_data.len() as u32);
+                syntax_context_data.push(SyntaxContextData {
+                    outer_expn: expn_id,
                     transparency,
                     prev_ctxt,
                     opaque,
@@ -352,11 +356,11 @@ impl HygieneData {
         }
 
         let prev_ctxt = ctxt;
-        *self.markings.entry((prev_ctxt, mark, transparency)).or_insert_with(|| {
+        *self.syntax_context_map.entry((prev_ctxt, expn_id, transparency)).or_insert_with(|| {
             let new_opaque_and_semitransparent_and_transparent =
-                SyntaxContext(syntax_contexts.len() as u32);
-            syntax_contexts.push(SyntaxContextData {
-                outer_mark: mark,
+                SyntaxContext(syntax_context_data.len() as u32);
+            syntax_context_data.push(SyntaxContextData {
+                outer_expn: expn_id,
                 transparency,
                 prev_ctxt,
                 opaque,
@@ -368,8 +372,8 @@ impl HygieneData {
     }
 }
 
-pub fn clear_markings() {
-    HygieneData::with(|data| data.markings = FxHashMap::default());
+pub fn syntax_context_map() {
+    HygieneData::with(|data| data.syntax_context_map = FxHashMap::default());
 }
 
 pub fn walk_chain(span: Span, to: SyntaxContext) -> Span {
@@ -379,8 +383,8 @@ pub fn walk_chain(span: Span, to: SyntaxContext) -> Span {
 pub fn update_dollar_crate_names(mut get_name: impl FnMut(SyntaxContext) -> Symbol) {
     // The new contexts that need updating are at the end of the list and have `$crate` as a name.
     let (len, to_update) = HygieneData::with(|data| (
-        data.syntax_contexts.len(),
-        data.syntax_contexts.iter().rev()
+        data.syntax_context_data.len(),
+        data.syntax_context_data.iter().rev()
             .take_while(|scdata| scdata.dollar_crate_name == kw::DollarCrate).count()
     ));
     // The callback must be called from outside of the `HygieneData` lock,
@@ -389,7 +393,7 @@ pub fn update_dollar_crate_names(mut get_name: impl FnMut(SyntaxContext) -> Symb
     let names: Vec<_> =
         range_to_update.clone().map(|idx| get_name(SyntaxContext::from_u32(idx as u32))).collect();
     HygieneData::with(|data| range_to_update.zip(names.into_iter()).for_each(|(idx, name)| {
-        data.syntax_contexts[idx].dollar_crate_name = name;
+        data.syntax_context_data[idx].dollar_crate_name = name;
     }))
 }
 
@@ -409,15 +413,15 @@ impl SyntaxContext {
         SyntaxContext(raw)
     }
 
-    /// Extend a syntax context with a given mark and default transparency for that mark.
-    pub fn apply_mark(self, mark: ExpnId) -> SyntaxContext {
-        HygieneData::with(|data| data.apply_mark(self, mark))
+    /// Extend a syntax context with a given expansion and default transparency for that expansion.
+    pub fn apply_mark(self, expn_id: ExpnId) -> SyntaxContext {
+        HygieneData::with(|data| data.apply_mark(self, expn_id))
     }
 
-    /// Extend a syntax context with a given mark and transparency
-    pub fn apply_mark_with_transparency(self, mark: ExpnId, transparency: Transparency)
+    /// Extend a syntax context with a given expansion and transparency.
+    pub fn apply_mark_with_transparency(self, expn_id: ExpnId, transparency: Transparency)
                                         -> SyntaxContext {
-        HygieneData::with(|data| data.apply_mark_with_transparency(self, mark, transparency))
+        HygieneData::with(|data| data.apply_mark_with_transparency(self, expn_id, transparency))
     }
 
     /// Pulls a single mark off of the syntax context. This effectively moves the
@@ -468,15 +472,15 @@ impl SyntaxContext {
     /// ```
     /// 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: ExpnId) -> Option<ExpnId> {
-        HygieneData::with(|data| data.adjust(self, expansion))
+    pub fn adjust(&mut self, expn_id: ExpnId) -> Option<ExpnId> {
+        HygieneData::with(|data| data.adjust(self, expn_id))
     }
 
     /// Like `SyntaxContext::adjust`, but also modernizes `self`.
-    pub fn modernize_and_adjust(&mut self, expansion: ExpnId) -> Option<ExpnId> {
+    pub fn modernize_and_adjust(&mut self, expn_id: ExpnId) -> Option<ExpnId> {
         HygieneData::with(|data| {
             *self = data.modern(*self);
-            data.adjust(self, expansion)
+            data.adjust(self, expn_id)
         })
     }
 
@@ -505,17 +509,17 @@ impl SyntaxContext {
     /// ```
     /// 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: ExpnId, glob_span: Span) -> Option<Option<ExpnId>> {
+    pub fn glob_adjust(&mut self, expn_id: ExpnId, glob_span: Span) -> Option<Option<ExpnId>> {
         HygieneData::with(|data| {
             let mut scope = None;
             let mut glob_ctxt = data.modern(glob_span.ctxt());
-            while !data.is_descendant_of(expansion, data.outer(glob_ctxt)) {
+            while !data.is_descendant_of(expn_id, data.outer(glob_ctxt)) {
                 scope = Some(data.remove_mark(&mut glob_ctxt));
                 if data.remove_mark(self) != scope.unwrap() {
                     return None;
                 }
             }
-            if data.adjust(self, expansion).is_some() {
+            if data.adjust(self, expn_id).is_some() {
                 return None;
             }
             Some(scope)
@@ -529,16 +533,16 @@ impl SyntaxContext {
     ///     assert!(self.glob_adjust(expansion, glob_ctxt) == Some(privacy_checking_scope));
     /// }
     /// ```
-    pub fn reverse_glob_adjust(&mut self, expansion: ExpnId, glob_span: Span)
+    pub fn reverse_glob_adjust(&mut self, expn_id: ExpnId, glob_span: Span)
                                -> Option<Option<ExpnId>> {
         HygieneData::with(|data| {
-            if data.adjust(self, expansion).is_some() {
+            if data.adjust(self, expn_id).is_some() {
                 return None;
             }
 
             let mut glob_ctxt = data.modern(glob_span.ctxt());
             let mut marks = Vec::new();
-            while !data.is_descendant_of(expansion, data.outer(glob_ctxt)) {
+            while !data.is_descendant_of(expn_id, data.outer(glob_ctxt)) {
                 marks.push(data.remove_mark(&mut glob_ctxt));
             }
 
@@ -550,10 +554,10 @@ impl SyntaxContext {
         })
     }
 
-    pub fn hygienic_eq(self, other: SyntaxContext, mark: ExpnId) -> bool {
+    pub fn hygienic_eq(self, other: SyntaxContext, expn_id: ExpnId) -> bool {
         HygieneData::with(|data| {
             let mut self_modern = data.modern(self);
-            data.adjust(&mut self_modern, mark);
+            data.adjust(&mut self_modern, expn_id);
             self_modern == data.modern(other)
         })
     }
@@ -591,7 +595,7 @@ impl SyntaxContext {
     }
 
     pub fn dollar_crate_name(self) -> Symbol {
-        HygieneData::with(|data| data.syntax_contexts[self.0 as usize].dollar_crate_name)
+        HygieneData::with(|data| data.syntax_context_data[self.0 as usize].dollar_crate_name)
     }
 }
 
@@ -609,8 +613,8 @@ impl Span {
     /// but its location is inherited from the current 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))
+            let expn_id = data.fresh_expn_id(parent, Some(expn_info));
+            self.with_ctxt(data.apply_mark(SyntaxContext::empty(), expn_id))
         })
     }
 }
@@ -638,7 +642,7 @@ pub struct ExpnInfo {
     /// 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 mark with this expansion info by default.
+    /// Transparency used by `apply_mark` for the expansion with this expansion info 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
diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs
index a4c7c4bf287..b9a062c0765 100644
--- a/src/libsyntax_pos/lib.rs
+++ b/src/libsyntax_pos/lib.rs
@@ -530,34 +530,34 @@ impl Span {
     }
 
     #[inline]
-    pub fn adjust(&mut self, expansion: ExpnId) -> Option<ExpnId> {
+    pub fn adjust(&mut self, expn_id: ExpnId) -> Option<ExpnId> {
         let mut span = self.data();
-        let mark = span.ctxt.adjust(expansion);
+        let mark = span.ctxt.adjust(expn_id);
         *self = Span::new(span.lo, span.hi, span.ctxt);
         mark
     }
 
     #[inline]
-    pub fn modernize_and_adjust(&mut self, expansion: ExpnId) -> Option<ExpnId> {
+    pub fn modernize_and_adjust(&mut self, expn_id: ExpnId) -> Option<ExpnId> {
         let mut span = self.data();
-        let mark = span.ctxt.modernize_and_adjust(expansion);
+        let mark = span.ctxt.modernize_and_adjust(expn_id);
         *self = Span::new(span.lo, span.hi, span.ctxt);
         mark
     }
 
     #[inline]
-    pub fn glob_adjust(&mut self, expansion: ExpnId, glob_span: Span) -> Option<Option<ExpnId>> {
+    pub fn glob_adjust(&mut self, expn_id: ExpnId, glob_span: Span) -> Option<Option<ExpnId>> {
         let mut span = self.data();
-        let mark = span.ctxt.glob_adjust(expansion, glob_span);
+        let mark = span.ctxt.glob_adjust(expn_id, glob_span);
         *self = Span::new(span.lo, span.hi, span.ctxt);
         mark
     }
 
     #[inline]
-    pub fn reverse_glob_adjust(&mut self, expansion: ExpnId, glob_span: Span)
+    pub fn reverse_glob_adjust(&mut self, expn_id: ExpnId, glob_span: Span)
                                -> Option<Option<ExpnId>> {
         let mut span = self.data();
-        let mark = span.ctxt.reverse_glob_adjust(expansion, glob_span);
+        let mark = span.ctxt.reverse_glob_adjust(expn_id, glob_span);
         *self = Span::new(span.lo, span.hi, span.ctxt);
         mark
     }