hygiene: Merge NameAndSpan into ExpnInfo

src/librustc/hir/lowering.rs

@@ -612,13 +612,11 @@ impl<'a> LoweringContext<'a> {
         let mark = Mark::fresh(Mark::root());
         mark.set_expn_info(codemap::ExpnInfo {
             call_site: span,
-            callee: codemap::NameAndSpan {
+            def_site: Some(span),
-                format: codemap::CompilerDesugaring(reason),
+            format: codemap::CompilerDesugaring(reason),
-                span: Some(span),
+            allow_internal_unstable: true,
-                allow_internal_unstable: true,
+            allow_internal_unsafe: false,
-                allow_internal_unsafe: false,
+            edition: codemap::hygiene::default_edition(),
-                edition: codemap::hygiene::default_edition(),
-            },
         });
         span.with_ctxt(SyntaxContext::empty().apply_mark(mark))
     }

src/librustc/ich/impls_syntax.rs

@@ -391,15 +391,11 @@ impl_stable_hash_for!(enum ::syntax::ast::MetaItemKind {
 
 impl_stable_hash_for!(struct ::syntax_pos::hygiene::ExpnInfo {
     call_site,
-    callee
+    def_site,
-});
-
-impl_stable_hash_for!(struct ::syntax_pos::hygiene::NameAndSpan {
     format,
     allow_internal_unstable,
     allow_internal_unsafe,
-    edition,
+    edition
-    span
 });
 
 impl_stable_hash_for!(enum ::syntax_pos::hygiene::ExpnFormat {

src/librustc/traits/error_reporting.rs

@@ -366,9 +366,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         }
 
         if let Some(k) = obligation.cause.span.compiler_desugaring_kind() {
-            let desugaring = k.as_symbol().as_str();
             flags.push(("from_desugaring".to_string(), None));
-            flags.push(("from_desugaring".to_string(), Some(desugaring.to_string())));
+            flags.push(("from_desugaring".to_string(), Some(k.name().to_string())));
         }
         let generics = self.tcx.generics_of(def_id);
         let self_ty = trait_ref.self_ty();

src/librustc_allocator/expand.rs

@@ -15,7 +15,7 @@ use syntax::ast::{Arg, FnHeader, Generics, Mac, Mutability, Ty, Unsafety};
 use syntax::ast::{self, Expr, Ident, Item, ItemKind, TyKind, VisibilityKind};
 use syntax::attr;
 use syntax::codemap::respan;
-use syntax::codemap::{ExpnInfo, MacroAttribute, NameAndSpan};
+use syntax::codemap::{ExpnInfo, MacroAttribute};
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::base::Resolver;
 use syntax::ext::build::AstBuilder;
@@ -80,13 +80,11 @@ impl<'a> Folder for ExpandAllocatorDirectives<'a> {
         let mark = Mark::fresh(Mark::root());
         mark.set_expn_info(ExpnInfo {
             call_site: DUMMY_SP,
-            callee: NameAndSpan {
+            def_site: None,
-                format: MacroAttribute(Symbol::intern(name)),
+            format: MacroAttribute(Symbol::intern(name)),
-                span: None,
+            allow_internal_unstable: true,
-                allow_internal_unstable: true,
+            allow_internal_unsafe: false,
-                allow_internal_unsafe: false,
+            edition: hygiene::default_edition(),
-                edition: hygiene::default_edition(),
-            },
         });
         let span = item.span.with_ctxt(SyntaxContext::empty().apply_mark(mark));
         let ecfg = ExpansionConfig::default(name.to_string());

src/librustc_save_analysis/lib.rs

@@ -844,7 +844,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
         let callsite = span.source_callsite();
         let callsite_span = self.span_from_span(callsite);
         let callee = span.source_callee()?;
-        let callee_span = callee.span?;
+        let callee_span = callee.def_site?;
 
         // Ignore attribute macros, their spans are usually mangled
         if let MacroAttribute(_) = callee.format {
@@ -872,7 +872,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
         let callee_span = self.span_from_span(callee_span);
         Some(MacroRef {
             span: callsite_span,
-            qualname: callee.name().to_string(), // FIXME: generate the real qualname
+            qualname: callee.format.name().to_string(), // FIXME: generate the real qualname
             callee_span,
         })
     }

src/libsyntax/codemap.rs

@@ -19,7 +19,7 @@
 
 
 pub use syntax_pos::*;
-pub use syntax_pos::hygiene::{ExpnFormat, ExpnInfo, NameAndSpan};
+pub use syntax_pos::hygiene::{ExpnFormat, ExpnInfo};
 pub use self::ExpnFormat::*;
 
 use rustc_data_structures::fx::FxHashMap;

src/libsyntax/ext/base.rs

@@ -834,7 +834,7 @@ impl<'a> ExtCtxt<'a> {
         let mut last_macro = None;
         loop {
             if ctxt.outer().expn_info().map_or(None, |info| {
-                if info.callee.name() == "include" {
+                if info.format.name() == "include" {
                     // Stop going up the backtrace once include! is encountered
                     return None;
                 }

src/libsyntax/ext/derive.rs

@@ -10,7 +10,7 @@
 
 use attr::HasAttrs;
 use ast;
-use codemap::{hygiene, ExpnInfo, NameAndSpan, ExpnFormat};
+use codemap::{hygiene, ExpnInfo, ExpnFormat};
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use parse::parser::PathStyle;
@@ -60,13 +60,11 @@ pub fn add_derived_markers<T>(cx: &mut ExtCtxt, span: Span, traits: &[ast::Path]
 
     cx.current_expansion.mark.set_expn_info(ExpnInfo {
         call_site: span,
-        callee: NameAndSpan {
+        def_site: None,
-            format: ExpnFormat::MacroAttribute(Symbol::intern(&pretty_name)),
+        format: ExpnFormat::MacroAttribute(Symbol::intern(&pretty_name)),
-            span: None,
+        allow_internal_unstable: true,
-            allow_internal_unstable: true,
+        allow_internal_unsafe: false,
-            allow_internal_unsafe: false,
+        edition: hygiene::default_edition(),
-            edition: hygiene::default_edition(),
-        },
     });
 
     let span = span.with_ctxt(cx.backtrace());

src/libsyntax/ext/expand.rs

@@ -11,7 +11,7 @@
 use ast::{self, Block, Ident, NodeId, PatKind, Path};
 use ast::{MacStmtStyle, StmtKind, ItemKind};
 use attr::{self, HasAttrs};
-use codemap::{ExpnInfo, NameAndSpan, MacroBang, MacroAttribute, dummy_spanned, respan};
+use codemap::{ExpnInfo, MacroBang, MacroAttribute, dummy_spanned, respan};
 use config::{is_test_or_bench, StripUnconfigured};
 use errors::{Applicability, FatalError};
 use ext::base::*;
@@ -514,7 +514,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
             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 `{}`",
-                         info.callee.name()));
+                         info.format.name()));
             err.help(&format!(
                 "consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate",
                 suggested_limit));
@@ -538,13 +538,11 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
         attr::mark_used(&attr);
         invoc.expansion_data.mark.set_expn_info(ExpnInfo {
             call_site: attr.span,
-            callee: NameAndSpan {
+            def_site: None,
-                format: MacroAttribute(Symbol::intern(&format!("{}", attr.path))),
+            format: MacroAttribute(Symbol::intern(&format!("{}", attr.path))),
-                span: None,
+            allow_internal_unstable: false,
-                allow_internal_unstable: false,
+            allow_internal_unsafe: false,
-                allow_internal_unsafe: false,
+            edition: ext.edition(),
-                edition: ext.edition(),
-            }
         });
 
         match *ext {
@@ -727,13 +725,11 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
             }
             mark.set_expn_info(ExpnInfo {
                 call_site: span,
-                callee: NameAndSpan {
+                def_site: def_site_span,
-                    format: macro_bang_format(path),
+                format: macro_bang_format(path),
-                    span: def_site_span,
+                allow_internal_unstable,
-                    allow_internal_unstable,
+                allow_internal_unsafe,
-                    allow_internal_unsafe,
+                edition,
-                    edition,
-                },
             });
             Ok(())
         };
@@ -777,13 +773,11 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                 } else {
                     invoc.expansion_data.mark.set_expn_info(ExpnInfo {
                         call_site: span,
-                        callee: NameAndSpan {
+                        def_site: tt_span,
-                            format: macro_bang_format(path),
+                        format: macro_bang_format(path),
-                            span: tt_span,
+                        allow_internal_unstable,
-                            allow_internal_unstable,
+                        allow_internal_unsafe: false,
-                            allow_internal_unsafe: false,
+                        edition: hygiene::default_edition(),
-                            edition: hygiene::default_edition(),
-                        }
                     });
 
                     let input: Vec<_> = mac.node.stream().into_trees().collect();
@@ -815,16 +809,14 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                     self.gate_proc_macro_expansion_kind(span, kind);
                     invoc.expansion_data.mark.set_expn_info(ExpnInfo {
                         call_site: span,
-                        callee: NameAndSpan {
+                        // FIXME procedural macros do not have proper span info
-                            format: macro_bang_format(path),
+                        // yet, when they do, we should use it here.
-                            // FIXME procedural macros do not have proper span info
+                        def_site: None,
-                            // yet, when they do, we should use it here.
+                        format: macro_bang_format(path),
-                            span: None,
+                        // FIXME probably want to follow macro_rules macros here.
-                            // FIXME probably want to follow macro_rules macros here.
+                        allow_internal_unstable,
-                            allow_internal_unstable,
+                        allow_internal_unsafe: false,
-                            allow_internal_unsafe: false,
+                        edition,
-                            edition,
-                        },
                     });
 
                     let tok_result = expandfun.expand(self.cx, span, mac.node.stream());
@@ -894,13 +886,11 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
 
         let mut expn_info = ExpnInfo {
             call_site: span,
-            callee: NameAndSpan {
+            def_site: None,
-                format: MacroAttribute(pretty_name),
+            format: MacroAttribute(pretty_name),
-                span: None,
+            allow_internal_unstable: false,
-                allow_internal_unstable: false,
+            allow_internal_unsafe: false,
-                allow_internal_unsafe: false,
+            edition: ext.edition(),
-                edition: ext.edition(),
-            }
         };
 
         match *ext {
@@ -916,7 +906,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                 Some(invoc.fragment_kind.expect_from_annotatables(items))
             }
             BuiltinDerive(func) => {
-                expn_info.callee.allow_internal_unstable = true;
+                expn_info.allow_internal_unstable = true;
                 invoc.expansion_data.mark.set_expn_info(expn_info);
                 let span = span.with_ctxt(self.cx.backtrace());
                 let mut items = Vec::new();

src/libsyntax/std_inject.rs

@@ -14,7 +14,7 @@ use std::cell::Cell;
 use ext::hygiene::{Mark, SyntaxContext};
 use symbol::{Symbol, keywords};
 use syntax_pos::{DUMMY_SP, Span};
-use codemap::{ExpnInfo, NameAndSpan, MacroAttribute, dummy_spanned, hygiene, respan};
+use codemap::{ExpnInfo, MacroAttribute, dummy_spanned, hygiene, respan};
 use ptr::P;
 use tokenstream::TokenStream;
 
@@ -25,13 +25,11 @@ fn ignored_span(sp: Span) -> Span {
     let mark = Mark::fresh(Mark::root());
     mark.set_expn_info(ExpnInfo {
         call_site: DUMMY_SP,
-        callee: NameAndSpan {
+        def_site: None,
-            format: MacroAttribute(Symbol::intern("std_inject")),
+        format: MacroAttribute(Symbol::intern("std_inject")),
-            span: None,
+        allow_internal_unstable: true,
-            allow_internal_unstable: true,
+        allow_internal_unsafe: false,
-            allow_internal_unsafe: false,
+        edition: hygiene::default_edition(),
-            edition: hygiene::default_edition(),
-        }
     });
     sp.with_ctxt(SyntaxContext::empty().apply_mark(mark))
 }

src/libsyntax/test.rs

@@ -22,7 +22,7 @@ use std::vec;
 use attr::{self, HasAttrs};
 use syntax_pos::{self, DUMMY_SP, NO_EXPANSION, Span, FileMap, BytePos};
 
-use codemap::{self, CodeMap, ExpnInfo, NameAndSpan, MacroAttribute, dummy_spanned};
+use codemap::{self, CodeMap, ExpnInfo, MacroAttribute, dummy_spanned};
 use errors;
 use config;
 use entry::{self, EntryPointType};
@@ -307,13 +307,11 @@ fn generate_test_harness(sess: &ParseSess,
 
     mark.set_expn_info(ExpnInfo {
         call_site: DUMMY_SP,
-        callee: NameAndSpan {
+        def_site: None,
-            format: MacroAttribute(Symbol::intern("test")),
+        format: MacroAttribute(Symbol::intern("test")),
-            span: None,
+        allow_internal_unstable: true,
-            allow_internal_unstable: true,
+        allow_internal_unsafe: false,
-            allow_internal_unsafe: false,
+        edition: hygiene::default_edition(),
-            edition: hygiene::default_edition(),
-        }
     });
 
     TestHarnessGenerator {

src/libsyntax_ext/deriving/mod.rs

@@ -157,11 +157,11 @@ fn call_intrinsic(cx: &ExtCtxt,
                   intrinsic: &str,
                   args: Vec<P<ast::Expr>>)
                   -> P<ast::Expr> {
-    if cx.current_expansion.mark.expn_info().unwrap().callee.allow_internal_unstable {
+    if cx.current_expansion.mark.expn_info().unwrap().allow_internal_unstable {
         span = span.with_ctxt(cx.backtrace());
     } else { // Avoid instability errors with user defined curstom derives, cc #36316
         let mut info = cx.current_expansion.mark.expn_info().unwrap();
-        info.callee.allow_internal_unstable = true;
+        info.allow_internal_unstable = true;
         let mark = Mark::fresh(Mark::root());
         mark.set_expn_info(info);
         span = span.with_ctxt(SyntaxContext::empty().apply_mark(mark));

src/libsyntax_ext/proc_macro_registrar.rs

@@ -14,7 +14,7 @@ use errors;
 
 use syntax::ast::{self, Ident, NodeId};
 use syntax::attr;
-use syntax::codemap::{ExpnInfo, NameAndSpan, MacroAttribute, hygiene, respan};
+use syntax::codemap::{ExpnInfo, MacroAttribute, hygiene, respan};
 use syntax::ext::base::ExtCtxt;
 use syntax::ext::build::AstBuilder;
 use syntax::ext::expand::ExpansionConfig;
@@ -364,13 +364,11 @@ fn mk_registrar(cx: &mut ExtCtxt,
     let mark = Mark::fresh(Mark::root());
     mark.set_expn_info(ExpnInfo {
         call_site: DUMMY_SP,
-        callee: NameAndSpan {
+        def_site: None,
-            format: MacroAttribute(Symbol::intern("proc_macro")),
+        format: MacroAttribute(Symbol::intern("proc_macro")),
-            span: None,
+        allow_internal_unstable: true,
-            allow_internal_unstable: true,
+        allow_internal_unsafe: false,
-            allow_internal_unsafe: false,
+        edition: hygiene::default_edition(),
-            edition: hygiene::default_edition(),
-        }
     });
     let span = DUMMY_SP.apply_mark(mark);
 

src/libsyntax_pos/hygiene.rs

@@ -482,12 +482,11 @@ pub struct ExpnInfo {
     /// call_site span would have its own ExpnInfo, with the call_site
     /// pointing to the `foo!` invocation.
     pub call_site: Span,
-    /// Information about the expansion.
+    /// The span of the macro definition itself. The macro may not
-    pub callee: NameAndSpan
+    /// have a sensible definition span (e.g. something defined
-}
+    /// completely inside libsyntax) in which case this is None.
-
+    /// This span serves only informational purpose and is not used for resolution.
-#[derive(Clone, Hash, Debug, RustcEncodable, RustcDecodable)]
+    pub def_site: Option<Span>,
-pub struct NameAndSpan {
     /// The format with which the macro was invoked.
     pub format: ExpnFormat,
     /// Whether the macro is allowed to use #[unstable]/feature-gated
@@ -499,20 +498,6 @@ pub struct NameAndSpan {
     pub allow_internal_unsafe: bool,
     /// Edition of the crate in which the macro is defined.
     pub edition: Edition,
-    /// The span of the macro definition itself. The macro may not
-    /// have a sensible definition span (e.g. something defined
-    /// completely inside libsyntax) in which case this is None.
-    pub span: Option<Span>
-}
-
-impl NameAndSpan {
-    pub fn name(&self) -> Symbol {
-        match self.format {
-            ExpnFormat::MacroAttribute(s) |
-            ExpnFormat::MacroBang(s) => s,
-            ExpnFormat::CompilerDesugaring(ref kind) => kind.as_symbol(),
-        }
-    }
 }
 
 /// The source of expansion.
@@ -526,8 +511,17 @@ pub enum ExpnFormat {
     CompilerDesugaring(CompilerDesugaringKind)
 }
 
+impl ExpnFormat {
+    pub fn name(&self) -> Symbol {
+        match *self {
+            ExpnFormat::MacroBang(name) | ExpnFormat::MacroAttribute(name) => name,
+            ExpnFormat::CompilerDesugaring(kind) => kind.name(),
+        }
+    }
+}
+
 /// The kind of compiler desugaring.
-#[derive(Clone, Hash, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
+#[derive(Clone, Copy, Hash, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 pub enum CompilerDesugaringKind {
     DotFill,
     QuestionMark,
@@ -540,16 +534,14 @@ pub enum CompilerDesugaringKind {
 }
 
 impl CompilerDesugaringKind {
-    pub fn as_symbol(&self) -> Symbol {
+    pub fn name(self) -> Symbol {
-        use CompilerDesugaringKind::*;
+        Symbol::intern(match self {
-        let s = match *self {
+            CompilerDesugaringKind::Async => "async",
-            Async => "async",
+            CompilerDesugaringKind::DotFill => "...",
-            DotFill => "...",
+            CompilerDesugaringKind::QuestionMark => "?",
-            QuestionMark => "?",
+            CompilerDesugaringKind::Catch => "do catch",
-            Catch => "do catch",
+            CompilerDesugaringKind::ExistentialReturnType => "existental type",
-            ExistentialReturnType => "existental type",
+        })
-        };
-        Symbol::intern(s)
     }
 }
 

src/libsyntax_pos/lib.rs

@@ -51,7 +51,7 @@ extern crate unicode_width;
 
 pub mod edition;
 pub mod hygiene;
-pub use hygiene::{Mark, SyntaxContext, ExpnInfo, ExpnFormat, NameAndSpan, CompilerDesugaringKind};
+pub use hygiene::{Mark, SyntaxContext, ExpnInfo, ExpnFormat, CompilerDesugaringKind};
 
 mod span_encoding;
 pub use span_encoding::{Span, DUMMY_SP};
@@ -303,19 +303,19 @@ impl Span {
     /// Edition of the crate from which this span came.
     pub fn edition(self) -> edition::Edition {
         self.ctxt().outer().expn_info().map_or_else(|| hygiene::default_edition(),
-                                                    |einfo| einfo.callee.edition)
+                                                    |einfo| einfo.edition)
     }
 
     /// Return the source callee.
     ///
-    /// Returns None if the supplied span has no expansion trace,
+    /// Returns `None` if the supplied span has no expansion trace,
-    /// else returns the NameAndSpan for the macro definition
+    /// else returns the `ExpnInfo` for the macro definition
     /// corresponding to the source callsite.
-    pub fn source_callee(self) -> Option<NameAndSpan> {
+    pub fn source_callee(self) -> Option<ExpnInfo> {
-        fn source_callee(info: ExpnInfo) -> NameAndSpan {
+        fn source_callee(info: ExpnInfo) -> ExpnInfo {
             match info.call_site.ctxt().outer().expn_info() {
                 Some(info) => source_callee(info),
-                None => info.callee,
+                None => info,
             }
         }
         self.ctxt().outer().expn_info().map(source_callee)
@@ -326,7 +326,7 @@ impl Span {
     /// `#[allow_internal_unstable]`).
     pub fn allows_unstable(&self) -> bool {
         match self.ctxt().outer().expn_info() {
-            Some(info) => info.callee.allow_internal_unstable,
+            Some(info) => info.allow_internal_unstable,
             None => false,
         }
     }
@@ -334,7 +334,7 @@ impl Span {
     /// Check if this span arises from a compiler desugaring of kind `kind`.
     pub fn is_compiler_desugaring(&self, kind: CompilerDesugaringKind) -> bool {
         match self.ctxt().outer().expn_info() {
-            Some(info) => match info.callee.format {
+            Some(info) => match info.format {
                 ExpnFormat::CompilerDesugaring(k) => k == kind,
                 _ => false,
             },
@@ -346,7 +346,7 @@ impl Span {
     /// if this span is not from a desugaring.
     pub fn compiler_desugaring_kind(&self) -> Option<CompilerDesugaringKind> {
         match self.ctxt().outer().expn_info() {
-            Some(info) => match info.callee.format {
+            Some(info) => match info.format {
                 ExpnFormat::CompilerDesugaring(k) => Some(k),
                 _ => None
             },
@@ -359,7 +359,7 @@ impl Span {
     //  (that is, a macro marked with `#[allow_internal_unsafe]`).
     pub fn allows_unsafe(&self) -> bool {
         match self.ctxt().outer().expn_info() {
-            Some(info) => info.callee.allow_internal_unsafe,
+            Some(info) => info.allow_internal_unsafe,
             None => false,
         }
     }
@@ -368,20 +368,17 @@ impl Span {
         let mut prev_span = DUMMY_SP;
         let mut result = vec![];
         while let Some(info) = self.ctxt().outer().expn_info() {
-            let (pre, post) = match info.callee.format {
-                ExpnFormat::MacroAttribute(..) => ("#[", "]"),
-                ExpnFormat::MacroBang(..) => ("", "!"),
-                ExpnFormat::CompilerDesugaring(..) => ("desugaring of `", "`"),
-            };
-            let macro_decl_name = format!("{}{}{}", pre, info.callee.name(), post);
-            let def_site_span = info.callee.span;
-
             // Don't print recursive invocations
             if !info.call_site.source_equal(&prev_span) {
+                let (pre, post) = match info.format {
+                    ExpnFormat::MacroAttribute(..) => ("#[", "]"),
+                    ExpnFormat::MacroBang(..) => ("", "!"),
+                    ExpnFormat::CompilerDesugaring(..) => ("desugaring of `", "`"),
+                };
                 result.push(MacroBacktrace {
                     call_site: info.call_site,
-                    macro_decl_name,
+                    macro_decl_name: format!("{}{}{}", pre, info.format.name(), post),
-                    def_site_span,
+                    def_site_span: info.def_site,
                 });
             }