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))
}
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 {
}
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();
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;
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());
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 {
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,
})
}
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;
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;
}
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;
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());
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::*;
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));
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 {
}
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(())
};
} 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();
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());
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 {
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();
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;
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))
}
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};
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 {
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));
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;
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);
/// 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<Span>,
/// The format with which the macro was invoked.
pub format: ExpnFormat,
/// Whether the macro is allowed to use #[unstable]/feature-gated
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.
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,
}
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",
+ })
}
}
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};
/// 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<NameAndSpan> {
- fn source_callee(info: ExpnInfo) -> NameAndSpan {
+ pub fn source_callee(self) -> Option<ExpnInfo> {
+ 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)
/// `#[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,
}
}
/// 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,
},
/// 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
},
// (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,
}
}
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,
});
}