From 20ce91076af125eda82bb36e446e67b1c7af4218 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sat, 23 Jun 2018 21:41:39 +0300 Subject: [PATCH] hygiene: Merge `NameAndSpan` into `ExpnInfo` --- src/librustc/hir/lowering.rs | 12 ++-- src/librustc/ich/impls_syntax.rs | 8 +-- src/librustc/traits/error_reporting.rs | 3 +- src/librustc_allocator/expand.rs | 14 ++--- src/librustc_save_analysis/lib.rs | 4 +- src/libsyntax/codemap.rs | 2 +- src/libsyntax/ext/base.rs | 2 +- src/libsyntax/ext/derive.rs | 14 ++--- src/libsyntax/ext/expand.rs | 72 ++++++++++------------- src/libsyntax/std_inject.rs | 14 ++--- src/libsyntax/test.rs | 14 ++--- src/libsyntax_ext/deriving/mod.rs | 4 +- src/libsyntax_ext/proc_macro_registrar.rs | 14 ++--- src/libsyntax_pos/hygiene.rs | 54 ++++++++--------- src/libsyntax_pos/lib.rs | 39 ++++++------ 15 files changed, 116 insertions(+), 154 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 02e9415fd8e..4f470e1c26b 100644 --- a/src/librustc/hir/lowering.rs +++ b/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 { - format: codemap::CompilerDesugaring(reason), - span: Some(span), - allow_internal_unstable: true, - allow_internal_unsafe: false, - edition: codemap::hygiene::default_edition(), - }, + def_site: Some(span), + format: codemap::CompilerDesugaring(reason), + allow_internal_unstable: true, + allow_internal_unsafe: false, + edition: codemap::hygiene::default_edition(), }); span.with_ctxt(SyntaxContext::empty().apply_mark(mark)) } diff --git a/src/librustc/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs index 0f4603be39d..935bc4c8c6d 100644 --- a/src/librustc/ich/impls_syntax.rs +++ b/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 -}); - -impl_stable_hash_for!(struct ::syntax_pos::hygiene::NameAndSpan { + def_site, format, allow_internal_unstable, allow_internal_unsafe, - edition, - span + edition }); impl_stable_hash_for!(enum ::syntax_pos::hygiene::ExpnFormat { diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index f76b312ee53..0d7d39ccf40 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/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(); diff --git a/src/librustc_allocator/expand.rs b/src/librustc_allocator/expand.rs index 78406e88c75..a9530964bff 100644 --- a/src/librustc_allocator/expand.rs +++ b/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 { - format: MacroAttribute(Symbol::intern(name)), - span: None, - allow_internal_unstable: true, - allow_internal_unsafe: false, - edition: hygiene::default_edition(), - }, + def_site: None, + format: MacroAttribute(Symbol::intern(name)), + allow_internal_unstable: true, + allow_internal_unsafe: false, + edition: hygiene::default_edition(), }); let span = item.span.with_ctxt(SyntaxContext::empty().apply_mark(mark)); let ecfg = ExpansionConfig::default(name.to_string()); diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 453500d5ab7..deb91774175 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/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, }) } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index fe8ce75a4b8..8e4b7660a1c 100644 --- a/src/libsyntax/codemap.rs +++ b/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; diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index e8fad1a2177..16d786dd6ca 100644 --- a/src/libsyntax/ext/base.rs +++ b/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; } diff --git a/src/libsyntax/ext/derive.rs b/src/libsyntax/ext/derive.rs index 0b6a7e1c4f4..940fb6405f1 100644 --- a/src/libsyntax/ext/derive.rs +++ b/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(cx: &mut ExtCtxt, span: Span, traits: &[ast::Path] cx.current_expansion.mark.set_expn_info(ExpnInfo { call_site: span, - callee: NameAndSpan { - format: ExpnFormat::MacroAttribute(Symbol::intern(&pretty_name)), - span: None, - allow_internal_unstable: true, - allow_internal_unsafe: false, - edition: hygiene::default_edition(), - }, + def_site: None, + format: ExpnFormat::MacroAttribute(Symbol::intern(&pretty_name)), + allow_internal_unstable: true, + allow_internal_unsafe: false, + edition: hygiene::default_edition(), }); let span = span.with_ctxt(cx.backtrace()); diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 8ad6e32f42d..69c99c63aaf 100644 --- a/src/libsyntax/ext/expand.rs +++ b/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 { - format: MacroAttribute(Symbol::intern(&format!("{}", attr.path))), - span: None, - allow_internal_unstable: false, - allow_internal_unsafe: false, - edition: ext.edition(), - } + def_site: None, + format: MacroAttribute(Symbol::intern(&format!("{}", attr.path))), + allow_internal_unstable: false, + allow_internal_unsafe: false, + 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 { - format: macro_bang_format(path), - span: def_site_span, - allow_internal_unstable, - allow_internal_unsafe, - edition, - }, + def_site: def_site_span, + format: macro_bang_format(path), + allow_internal_unstable, + allow_internal_unsafe, + 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 { - format: macro_bang_format(path), - span: tt_span, - allow_internal_unstable, - allow_internal_unsafe: false, - edition: hygiene::default_edition(), - } + def_site: tt_span, + format: macro_bang_format(path), + allow_internal_unstable, + allow_internal_unsafe: false, + 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 { - format: macro_bang_format(path), - // FIXME procedural macros do not have proper span info - // yet, when they do, we should use it here. - span: None, - // FIXME probably want to follow macro_rules macros here. - allow_internal_unstable, - allow_internal_unsafe: false, - edition, - }, + // FIXME procedural macros do not have proper span info + // yet, when they do, we should use it here. + def_site: None, + format: macro_bang_format(path), + // FIXME probably want to follow macro_rules macros here. + allow_internal_unstable, + allow_internal_unsafe: false, + 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 { - format: MacroAttribute(pretty_name), - span: None, - allow_internal_unstable: false, - allow_internal_unsafe: false, - edition: ext.edition(), - } + def_site: None, + format: MacroAttribute(pretty_name), + allow_internal_unstable: false, + allow_internal_unsafe: false, + 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(); diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs index e9cd7adb9c1..66e8e0d7a9c 100644 --- a/src/libsyntax/std_inject.rs +++ b/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 { - format: MacroAttribute(Symbol::intern("std_inject")), - span: None, - allow_internal_unstable: true, - allow_internal_unsafe: false, - edition: hygiene::default_edition(), - } + def_site: None, + format: MacroAttribute(Symbol::intern("std_inject")), + allow_internal_unstable: true, + allow_internal_unsafe: false, + edition: hygiene::default_edition(), }); sp.with_ctxt(SyntaxContext::empty().apply_mark(mark)) } diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index 77225585141..141fd122ff5 100644 --- a/src/libsyntax/test.rs +++ b/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 { - format: MacroAttribute(Symbol::intern("test")), - span: None, - allow_internal_unstable: true, - allow_internal_unsafe: false, - edition: hygiene::default_edition(), - } + def_site: None, + format: MacroAttribute(Symbol::intern("test")), + allow_internal_unstable: true, + allow_internal_unsafe: false, + edition: hygiene::default_edition(), }); TestHarnessGenerator { diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs index 6ff385b18e8..e6a1434ca9d 100644 --- a/src/libsyntax_ext/deriving/mod.rs +++ b/src/libsyntax_ext/deriving/mod.rs @@ -157,11 +157,11 @@ fn call_intrinsic(cx: &ExtCtxt, intrinsic: &str, args: Vec>) -> P { - 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)); diff --git a/src/libsyntax_ext/proc_macro_registrar.rs b/src/libsyntax_ext/proc_macro_registrar.rs index 3593165023a..ee343e47bd8 100644 --- a/src/libsyntax_ext/proc_macro_registrar.rs +++ b/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 { - format: MacroAttribute(Symbol::intern("proc_macro")), - span: None, - allow_internal_unstable: true, - allow_internal_unsafe: false, - edition: hygiene::default_edition(), - } + def_site: None, + format: MacroAttribute(Symbol::intern("proc_macro")), + allow_internal_unstable: true, + allow_internal_unsafe: false, + edition: hygiene::default_edition(), }); let span = DUMMY_SP.apply_mark(mark); diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs index 5c35984dfd0..08b7f7c76cb 100644 --- a/src/libsyntax_pos/hygiene.rs +++ b/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. - pub callee: NameAndSpan -} - -#[derive(Clone, Hash, Debug, RustcEncodable, RustcDecodable)] -pub struct NameAndSpan { + /// 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. + /// This span serves only informational purpose and is not used for resolution. + pub def_site: Option, /// 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 -} - -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 { - use CompilerDesugaringKind::*; - let s = match *self { - Async => "async", - DotFill => "...", - QuestionMark => "?", - Catch => "do catch", - ExistentialReturnType => "existental type", - }; - Symbol::intern(s) + pub fn name(self) -> Symbol { + Symbol::intern(match self { + CompilerDesugaringKind::Async => "async", + CompilerDesugaringKind::DotFill => "...", + CompilerDesugaringKind::QuestionMark => "?", + CompilerDesugaringKind::Catch => "do catch", + CompilerDesugaringKind::ExistentialReturnType => "existental type", + }) } } diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs index 17163576901..a4fb9571ecb 100644 --- a/src/libsyntax_pos/lib.rs +++ b/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, - /// else returns the NameAndSpan for the macro definition + /// Returns `None` if the supplied span has no expansion trace, + /// else returns the `ExpnInfo` for the macro definition /// corresponding to the source callsite. - pub fn source_callee(self) -> Option { - fn source_callee(info: ExpnInfo) -> NameAndSpan { + pub fn source_callee(self) -> Option { + 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 { 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, - def_site_span, + macro_decl_name: format!("{}{}{}", pre, info.format.name(), post), + def_site_span: info.def_site, }); }