Add with_{def_site,call_site,legacy}_ctxt, methods to Span

petrochenkov · matthewjasper · commit c8cf9f5a025b · 2019-09-05T15:07:17.000+01:00
Use these to create call-site spans for AST passes when needed.
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
@@ -17,7 +17,7 @@ use syntax::edition::Edition;
 use syntax::ext::base::{self, Indeterminate, SpecialDerives};
 use syntax::ext::base::{MacroKind, SyntaxExtension};
 use syntax::ext::expand::{AstFragment, Invocation, InvocationKind};
-use syntax::ext::hygiene::{self, ExpnId, ExpnData, ExpnKind, Transparency};
+use syntax::ext::hygiene::{self, ExpnId, ExpnData, ExpnKind};
 use syntax::ext::tt::macro_rules;
 use syntax::feature_gate::{emit_feature_err, is_builtin_attr_name};
 use syntax::feature_gate::GateIssue;
@@ -131,23 +131,20 @@ impl<'a> base::Resolver for Resolver<'a> {
     // Create a Span with modern hygiene with a definition site of the provided
     // module, or a fake empty `#[no_implicit_prelude]` module if no module is
     // provided.
-    fn span_for_ast_pass(
+    fn expansion_for_ast_pass(
         &mut self,
-        base_span: Span,
+        call_site: Span,
         pass: AstPass,
         features: &[Symbol],
         parent_module_id: Option<NodeId>,
-    ) -> Span {
-        let span = base_span.fresh_expansion_with_transparency(
-            ExpnData::allow_unstable(
-                ExpnKind::AstPass(pass),
-                base_span,
-                self.session.edition(),
-                features.into(),
-            ),
-            Transparency::Opaque,
-        );
-        let expn_id = span.ctxt().outer_expn();
+    ) -> ExpnId {
+        let expn_id = ExpnId::fresh(Some(ExpnData::allow_unstable(
+            ExpnKind::AstPass(pass),
+            call_site,
+            self.session.edition(),
+            features.into(),
+        )));
+
         let parent_scope = if let Some(module_id) = parent_module_id {
             let parent_def_id = self.definitions.local_def_id(module_id);
             self.definitions.add_parent_module_of_macro_def(expn_id, parent_def_id);
@@ -160,7 +157,7 @@ impl<'a> base::Resolver for Resolver<'a> {
             self.empty_module
         };
         self.ast_transform_scopes.insert(expn_id, parent_scope);
-        span
+        expn_id
     }
 
     fn resolve_imports(&mut self) {
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
@@ -3,7 +3,7 @@ use crate::attr::{HasAttrs, Stability, Deprecation};
 use crate::source_map::SourceMap;
 use crate::edition::Edition;
 use crate::ext::expand::{self, AstFragment, Invocation};
-use crate::ext::hygiene::{ExpnId, Transparency};
+use crate::ext::hygiene::ExpnId;
 use crate::mut_visit::{self, MutVisitor};
 use crate::parse::{self, parser, DirectoryOwnership};
 use crate::parse::token;
@@ -658,13 +658,13 @@ pub trait Resolver {
                                             extra_placeholders: &[NodeId]);
     fn register_builtin_macro(&mut self, ident: ast::Ident, ext: SyntaxExtension);
 
-    fn span_for_ast_pass(
+    fn expansion_for_ast_pass(
         &mut self,
-        span: Span,
+        call_site: Span,
         pass: AstPass,
         features: &[Symbol],
         parent_module_id: Option<NodeId>,
-    ) -> Span;
+    ) -> ExpnId;
 
     fn resolve_imports(&mut self);
 
@@ -750,20 +750,20 @@ impl<'a> ExtCtxt<'a> {
     /// Equivalent of `Span::def_site` from the proc macro API,
     /// except that the location is taken from the span passed as an argument.
     pub fn with_def_site_ctxt(&self, span: Span) -> Span {
-        span.with_ctxt_from_mark(self.current_expansion.id, Transparency::Opaque)
+        span.with_def_site_ctxt(self.current_expansion.id)
     }
 
     /// Equivalent of `Span::call_site` from the proc macro API,
     /// except that the location is taken from the span passed as an argument.
     pub fn with_call_site_ctxt(&self, span: Span) -> Span {
-        span.with_ctxt_from_mark(self.current_expansion.id, Transparency::Transparent)
+        span.with_call_site_ctxt(self.current_expansion.id)
     }
 
     /// Span with a context reproducing `macro_rules` hygiene (hygienic locals, unhygienic items).
     /// FIXME: This should be eventually replaced either with `with_def_site_ctxt` (preferably),
     /// or with `with_call_site_ctxt` (where necessary).
     pub fn with_legacy_ctxt(&self, span: Span) -> Span {
-        span.with_ctxt_from_mark(self.current_expansion.id, Transparency::SemiTransparent)
+        span.with_legacy_ctxt(self.current_expansion.id)
     }
 
     /// Returns span for the macro which originally caused the current expansion to happen.
diff --git a/src/libsyntax_ext/proc_macro_harness.rs b/src/libsyntax_ext/proc_macro_harness.rs
@@ -326,12 +326,13 @@ fn mk_decls(
     custom_attrs: &[ProcMacroDef],
     custom_macros: &[ProcMacroDef],
 ) -> P<ast::Item> {
-    let span = cx.resolver.span_for_ast_pass(
+    let expn_id = cx.resolver.expansion_for_ast_pass(
         DUMMY_SP,
         AstPass::ProcMacroHarness,
         &[sym::rustc_attrs, sym::proc_macro_internals],
         None,
     );
+    let span = DUMMY_SP.with_def_site_ctxt(expn_id);
 
     let proc_macro = Ident::new(sym::proc_macro, span);
     let krate = cx.item(span,
diff --git a/src/libsyntax_ext/standard_library_imports.rs b/src/libsyntax_ext/standard_library_imports.rs
@@ -28,19 +28,21 @@ pub fn inject(
         &[sym::std]
     };
 
-    let span = resolver.span_for_ast_pass(
+    let expn_id = resolver.expansion_for_ast_pass(
         DUMMY_SP,
         AstPass::StdImports,
         &[sym::prelude_import],
         None,
     );
+    let span = DUMMY_SP.with_def_site_ctxt(expn_id);
+    let call_site = DUMMY_SP.with_call_site_ctxt(expn_id);
 
     // .rev() to preserve ordering above in combination with insert(0, ...)
     for &orig_name_sym in names.iter().rev() {
         let (rename, orig_name) = if rust_2018 {
             (Ident::new(kw::Underscore, span), Some(orig_name_sym))
         } else {
-            (Ident::with_dummy_span(orig_name_sym), None)
+            (Ident::new(orig_name_sym, call_site), None)
         };
         krate.module.items.insert(0, P(ast::Item {
             attrs: vec![attr::mk_attr_outer(
@@ -65,7 +67,7 @@ pub fn inject(
             .collect()
     } else {
         [kw::PathRoot, name, sym::prelude, sym::v1].iter()
-            .map(|symbol| ast::PathSegment::from_ident(ast::Ident::with_dummy_span(*symbol)))
+            .map(|symbol| ast::PathSegment::from_ident(ast::Ident::new(*symbol, call_site)))
             .collect()
     };
 
diff --git a/src/libsyntax_ext/test_harness.rs b/src/libsyntax_ext/test_harness.rs
@@ -97,15 +97,16 @@ impl<'a> MutVisitor for TestHarnessGenerator<'a> {
                 };
                 // Create an identifier that will hygienically resolve the test
                 // case name, even in another module.
-                let sp = self.cx.ext_cx.resolver.span_for_ast_pass(
+                let expn_id = self.cx.ext_cx.resolver.expansion_for_ast_pass(
                     module.inner,
                     AstPass::TestHarness,
                     &[],
                     Some(parent),
                 );
-                let expn = sp.ctxt().outer_expn();
                 for test in &mut tests {
-                    test.ident.span = test.ident.span.apply_mark(expn, Transparency::Opaque);
+                    // See the comment on `mk_main` for why we're using
+                    // `apply_mark` directly.
+                    test.ident.span = test.ident.span.apply_mark(expn_id, Transparency::Opaque);
                 }
                 self.cx.test_cases.extend(tests);
             }
@@ -207,12 +208,13 @@ fn mk_main(cx: &mut TestCtxt<'_>) -> P<ast::Item> {
     //            #![main]
     //            test::test_main_static(&[..tests]);
     //        }
-    let sp = cx.ext_cx.resolver.span_for_ast_pass(
+    let expn_id = cx.ext_cx.resolver.expansion_for_ast_pass(
         DUMMY_SP,
         AstPass::TestHarness,
         &[sym::main, sym::test, sym::rustc_attrs],
         None,
     );
+    let sp = DUMMY_SP.with_def_site_ctxt(expn_id);
     let ecx = &cx.ext_cx;
     let test_id = Ident::new(sym::test, sp);
 
diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs
@@ -360,7 +360,7 @@ impl SyntaxContext {
     }
 
     /// Extend a syntax context with a given expansion and transparency.
-    pub fn apply_mark(self, expn_id: ExpnId, transparency: Transparency) -> SyntaxContext {
+    crate fn apply_mark(self, expn_id: ExpnId, transparency: Transparency) -> SyntaxContext {
         HygieneData::with(|data| data.apply_mark(self, expn_id, transparency))
     }
 
diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs
@@ -514,6 +514,25 @@ impl Span {
                   span.ctxt)
     }
 
+    /// Equivalent of `Span::def_site` from the proc macro API,
+    /// except that the location is taken from the `self` span.
+    pub fn with_def_site_ctxt(self, expn_id: ExpnId) -> Span {
+        self.with_ctxt_from_mark(expn_id, Transparency::Opaque)
+    }
+
+    /// Equivalent of `Span::call_site` from the proc macro API,
+    /// except that the location is taken from the `self` span.
+    pub fn with_call_site_ctxt(&self, expn_id: ExpnId) -> Span {
+        self.with_ctxt_from_mark(expn_id, Transparency::Transparent)
+    }
+
+    /// Span with a context reproducing `macro_rules` hygiene (hygienic locals, unhygienic items).
+    /// FIXME: This should be eventually replaced either with `with_def_site_ctxt` (preferably),
+    /// or with `with_call_site_ctxt` (where necessary).
+    pub fn with_legacy_ctxt(&self, expn_id: ExpnId) -> Span {
+        self.with_ctxt_from_mark(expn_id, Transparency::SemiTransparent)
+    }
+
     /// Produces a span with the same location as `self` and context produced by a macro with the
     /// given ID and transparency, assuming that macro was defined directly and not produced by
     /// some other macro (which is the case for built-in and procedural macros).
diff --git a/src/test/ui/proc-macro/dollar-crate-issue-57089.stdout b/src/test/ui/proc-macro/dollar-crate-issue-57089.stdout
@@ -2,80 +2,80 @@ PRINT-BANG INPUT (DISPLAY): struct M ($crate :: S) ;
 PRINT-BANG INPUT (DEBUG): TokenStream [
     Ident {
         ident: "struct",
-        span: #2 bytes(LO..HI),
+        span: #3 bytes(LO..HI),
     },
     Ident {
         ident: "M",
-        span: #2 bytes(LO..HI),
+        span: #3 bytes(LO..HI),
     },
     Group {
         delimiter: Parenthesis,
         stream: TokenStream [
             Ident {
                 ident: "$crate",
-                span: #2 bytes(LO..HI),
+                span: #3 bytes(LO..HI),
             },
             Punct {
                 ch: ':',
                 spacing: Joint,
-                span: #2 bytes(LO..HI),
+                span: #3 bytes(LO..HI),
             },
             Punct {
                 ch: ':',
                 spacing: Alone,
-                span: #2 bytes(LO..HI),
+                span: #3 bytes(LO..HI),
             },
             Ident {
                 ident: "S",
-                span: #2 bytes(LO..HI),
+                span: #3 bytes(LO..HI),
             },
         ],
-        span: #2 bytes(LO..HI),
+        span: #3 bytes(LO..HI),
     },
     Punct {
         ch: ';',
         spacing: Alone,
-        span: #2 bytes(LO..HI),
+        span: #3 bytes(LO..HI),
     },
 ]
 PRINT-ATTR INPUT (DISPLAY): struct A(crate::S);
 PRINT-ATTR RE-COLLECTED (DISPLAY): struct A ($crate :: S) ;
 PRINT-ATTR INPUT (DEBUG): TokenStream [
     Ident {
         ident: "struct",
-        span: #2 bytes(LO..HI),
+        span: #3 bytes(LO..HI),
     },
     Ident {
         ident: "A",
-        span: #2 bytes(LO..HI),
+        span: #3 bytes(LO..HI),
     },
     Group {
         delimiter: Parenthesis,
         stream: TokenStream [
             Ident {
                 ident: "$crate",
-                span: #2 bytes(LO..HI),
+                span: #3 bytes(LO..HI),
             },
             Punct {
                 ch: ':',
                 spacing: Joint,
-                span: #2 bytes(LO..HI),
+                span: #3 bytes(LO..HI),
             },
             Punct {
                 ch: ':',
                 spacing: Alone,
-                span: #2 bytes(LO..HI),
+                span: #3 bytes(LO..HI),
             },
             Ident {
                 ident: "S",
-                span: #2 bytes(LO..HI),
+                span: #3 bytes(LO..HI),
             },
         ],
-        span: #2 bytes(LO..HI),
+        span: #3 bytes(LO..HI),
     },
     Punct {
         ch: ';',
         spacing: Alone,
-        span: #2 bytes(LO..HI),
+        span: #3 bytes(LO..HI),
     },
 ]
diff --git a/src/test/ui/proc-macro/dollar-crate-issue-62325.stdout b/src/test/ui/proc-macro/dollar-crate-issue-62325.stdout
diff --git a/src/test/ui/proc-macro/dollar-crate.stdout b/src/test/ui/proc-macro/dollar-crate.stdout

Original file line number	Diff line number	Diff line change
`@@ -360,7 +360,7 @@ impl SyntaxContext {`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	`/// Extend a syntax context with a given expansion and transparency.`
`363`		`- pub fn apply_mark(self, expn_id: ExpnId, transparency: Transparency) -> SyntaxContext {`
	`363`	`+ crate fn apply_mark(self, expn_id: ExpnId, transparency: Transparency) -> SyntaxContext {`
`364`	`364`	`HygieneData::with(\|data\| data.apply_mark(self, expn_id, transparency))`
`365`	`365`	`}`
`366`	`366`