nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 14:55:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #66364 - Centril:cleanup-macro-def, r=petrochenkov,eddyb

Browse Source 
Cleanup `rmeta::MacroDef`

Avoid using rountrip parsing in the encoder and in `fn load_macro_untracked`.

The main reason I was interested in this was to remove `rustc_parse` as a dependency of `rustc_metadata` but it seems like this had other benefits as well.

Fixes #49511.

r? @eddyb
cc @matthewjasper @estebank @petrochenkov
This commit is contained in:
bors 2020-03-10 17:12:48 +00:00
commit 1581278534
33 changed files with 183 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock
View File

@ -3891,14 +3891,12 @@ dependencies = [
"memmap",
"rustc",
"rustc_ast",
"rustc_ast_pretty",
"rustc_attr",
"rustc_data_structures",
"rustc_errors",
"rustc_expand",
"rustc_hir",
"rustc_index",
"rustc_parse",
"rustc_span",
"rustc_target",
"serialize",

2
src/librustc/dep_graph/dep_node.rs
View File

@ -111,6 +111,7 @@ macro_rules! define_dep_nodes {
) => (
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash,
RustcEncodable, RustcDecodable)]
#[allow(non_camel_case_types)]
pub enum DepKind {
$($variant),*
}
@ -173,6 +174,7 @@ macro_rules! define_dep_nodes {
pub struct DepConstructor;
#[allow(non_camel_case_types)]
impl DepConstructor {
$(
#[inline(always)]

11
src/librustc/lint.rs
View File

@ -344,15 +344,8 @@ pub fn in_external_macro(sess: &Session, span: Span) -> bool {
ExpnKind::Root | ExpnKind::Desugaring(DesugaringKind::ForLoop) => false,
ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) => true, // well, it's "external"
ExpnKind::Macro(MacroKind::Bang, _) => {
if expn_data.def_site.is_dummy() {
// Dummy span for the `def_site` means it's an external macro.
return true;
}
match sess.source_map().span_to_snippet(expn_data.def_site) {
Ok(code) => !code.starts_with("macro_rules"),
// No snippet means external macro or compiler-builtin expansion.
Err(_) => true,
}
// Dummy span for the `def_site` means it's an external macro.
expn_data.def_site.is_dummy() || sess.source_map().is_imported(expn_data.def_site)
}
ExpnKind::Macro(..) => true, // definitely a plugin
}

2
src/librustc/middle/stability.rs
View File

@ -110,7 +110,7 @@ pub fn report_unstable(
let span_key = msp.primary_span().and_then(|sp: Span| {
if !sp.is_dummy() {
let file = sm.lookup_char_pos(sp.lo()).file;
if file.name.is_macros() { None } else { Some(span) }
if file.is_imported() { None } else { Some(span) }
} else {
None
}

22
src/librustc_errors/emitter.rs
View File

@ -414,22 +414,24 @@ pub trait Emitter {
}
// This does a small "fix" for multispans by looking to see if it can find any that
// point directly at <*macros>. Since these are often difficult to read, this
// will change the span to point at the use site.
// point directly at external macros. Since these are often difficult to read,
// this will change the span to point at the use site.
fn fix_multispans_in_extern_macros(
&self,
source_map: &Option<Lrc<SourceMap>>,
span: &mut MultiSpan,
children: &mut Vec<SubDiagnostic>,
) {
for span in iter::once(span).chain(children.iter_mut().map(|child| &mut child.span)) {
debug!("fix_multispans_in_extern_macros: before: span={:?} children={:?}", span, children);
for span in iter::once(&mut *span).chain(children.iter_mut().map(|child| &mut child.span)) {
self.fix_multispan_in_extern_macros(source_map, span);
}
debug!("fix_multispans_in_extern_macros: after: span={:?} children={:?}", span, children);
}
// This "fixes" MultiSpans that contain Spans that are pointing to locations inside of
// <*macros>. Since these locations are often difficult to read, we move these Spans from
// <*macros> to their corresponding use site.
// This "fixes" MultiSpans that contain `Span`s pointing to locations inside of external macros.
// Since these locations are often difficult to read,
// we move these spans from the external macros to their corresponding use site.
fn fix_multispan_in_extern_macros(
&self,
source_map: &Option<Lrc<SourceMap>>,
@ -440,14 +442,14 @@ pub trait Emitter {
None => return,
};
// First, find all the spans in <*macros> and point instead at their use site
// First, find all the spans in external macros and point instead at their use site.
let replacements: Vec<(Span, Span)> = span
.primary_spans()
.iter()
.copied()
.chain(span.span_labels().iter().map(|sp_label| sp_label.span))
.filter_map(|sp| {
if !sp.is_dummy() && sm.span_to_filename(sp).is_macros() {
if !sp.is_dummy() && sm.is_imported(sp) {
let maybe_callsite = sp.source_callsite();
if sp != maybe_callsite {
return Some((sp, maybe_callsite));
@ -457,7 +459,7 @@ pub trait Emitter {
})
.collect();
// After we have them, make sure we replace these 'bad' def sites with their use sites
// After we have them, make sure we replace these 'bad' def sites with their use sites.
for (from, to) in replacements {
span.replace(from, to);
}
@ -472,6 +474,7 @@ impl Emitter for EmitterWriter {
fn emit_diagnostic(&mut self, diag: &Diagnostic) {
let mut children = diag.children.clone();
let (mut primary_span, suggestions) = self.primary_span_formatted(&diag);
debug!("emit_diagnostic: suggestions={:?}", suggestions);
self.fix_multispans_in_extern_macros_and_render_macro_backtrace(
&self.sm,
@ -1533,6 +1536,7 @@ impl EmitterWriter {
// Render the replacements for each suggestion
let suggestions = suggestion.splice_lines(&**sm);
debug!("emit_suggestion_default: suggestions={:?}", suggestions);
if suggestions.is_empty() {
// Suggestions coming from macros can have malformed spans. This is a heavy handed

5
src/librustc_errors/json.rs
View File

@ -394,6 +394,11 @@ impl DiagnosticSpanLine {
je.sm
.span_to_lines(span)
.map(|lines| {
// We can't get any lines if the source is unavailable.
if !je.sm.ensure_source_file_source_present(lines.file.clone()) {
return vec![];
}
let sf = &*lines.file;
lines
.lines

5
src/librustc_errors/lib.rs
View File

@ -196,6 +196,11 @@ impl CodeSuggestion {
let lines = sm.span_to_lines(bounding_span).ok()?;
assert!(!lines.lines.is_empty());
// We can't splice anything if the source is unavailable.
if !sm.ensure_source_file_source_present(lines.file.clone()) {
return None;
}
// To build up the result, we do this for each span:
// - push the line segment trailing the previous span
// (at the beginning a "phantom" span pointing at the start of the line)

6
src/librustc_expand/mbe/macro_rules.rs
View File

@ -105,10 +105,10 @@ impl<'a> ParserAnyMacro<'a> {
if e.span.is_dummy() {
// Get around lack of span in error (#30128)
e.replace_span_with(site_span);
if parser.sess.source_map().span_to_filename(arm_span).is_real() {
if !parser.sess.source_map().is_imported(arm_span) {
e.span_label(arm_span, "in this macro arm");
}
} else if !parser.sess.source_map().span_to_filename(parser.token.span).is_real() {
} else if parser.sess.source_map().is_imported(parser.token.span) {
e.span_label(site_span, "in this macro invocation");
}
match kind {
@ -297,7 +297,7 @@ fn generic_extension<'cx>(
let span = token.span.substitute_dummy(sp);
let mut err = cx.struct_span_err(span, &parse_failure_msg(&token));
err.span_label(span, label);
if !def_span.is_dummy() && cx.source_map().span_to_filename(def_span).is_real() {
if !def_span.is_dummy() && !cx.source_map().is_imported(def_span) {
err.span_label(cx.source_map().def_span(def_span), "when calling this macro");
}

4
src/librustc_macros/src/symbols.rs
View File

@ -103,6 +103,7 @@ pub fn symbols(input: TokenStream) -> TokenStream {
#value,
});
keyword_stream.extend(quote! {
#[allow(non_upper_case_globals)]
pub const #name: Symbol = Symbol::new(#counter);
});
counter += 1;
@ -120,6 +121,8 @@ pub fn symbols(input: TokenStream) -> TokenStream {
#value,
});
symbols_stream.extend(quote! {
#[allow(rustc::default_hash_types)]
#[allow(non_upper_case_globals)]
pub const #name: Symbol = Symbol::new(#counter);
});
counter += 1;
@ -149,6 +152,7 @@ pub fn symbols(input: TokenStream) -> TokenStream {
() => {
#symbols_stream
#[allow(non_upper_case_globals)]
pub const digits_array: &[Symbol; 10] = &[
#digits_stream
];

2
src/librustc_metadata/Cargo.toml
View File

@ -15,7 +15,6 @@ log = "0.4"
memmap = "0.7"
smallvec = { version = "1.0", features = ["union", "may_dangle"] }
rustc = { path = "../librustc" }
rustc_ast_pretty = { path = "../librustc_ast_pretty" }
rustc_attr = { path = "../librustc_attr" }
rustc_data_structures = { path = "../librustc_data_structures" }
rustc_errors = { path = "../librustc_errors" }
@ -26,7 +25,6 @@ rustc_serialize = { path = "../libserialize", package = "serialize" }
stable_deref_trait = "1.0.0"
rustc_ast = { path = "../librustc_ast" }
rustc_expand = { path = "../librustc_expand" }
rustc_parse = { path = "../librustc_parse" }
rustc_span = { path = "../librustc_span" }
[target.'cfg(windows)'.dependencies]

4
src/librustc_metadata/rmeta/decoder.rs
View File

@ -1275,9 +1275,9 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
}
}
fn get_macro(&self, id: DefIndex) -> MacroDef {
fn get_macro(&self, id: DefIndex, sess: &Session) -> MacroDef {
match self.kind(id) {
EntryKind::MacroDef(macro_def) => macro_def.decode(self),
EntryKind::MacroDef(macro_def) => macro_def.decode((self, sess)),
_ => bug!(),
}
}

45
src/librustc_metadata/rmeta/decoder/cstore_impl.rs
View File

@ -14,26 +14,21 @@ use rustc::session::{CrateDisambiguator, Session};
use rustc::ty::query::Providers;
use rustc::ty::query::QueryConfig;
use rustc::ty::{self, TyCtxt};
use rustc_data_structures::svh::Svh;
use rustc_hir as hir;
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_parse::parser::emit_unclosed_delims;
use rustc_parse::source_file_to_stream;
use rustc_data_structures::sync::Lrc;
use smallvec::SmallVec;
use std::any::Any;
use std::sync::Arc;
use rustc_ast::ast;
use rustc_ast::attr;
use rustc_ast::expand::allocator::AllocatorKind;
use rustc_ast::ptr::P;
use rustc_ast::tokenstream::DelimSpan;
use rustc_span::source_map;
use rustc_span::source_map::Spanned;
use rustc_data_structures::svh::Svh;
use rustc_hir as hir;
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_span::source_map::{self, Span, Spanned};
use rustc_span::symbol::Symbol;
use rustc_span::{FileName, Span};
use rustc_data_structures::sync::Lrc;
use smallvec::SmallVec;
use std::any::Any;
use std::sync::Arc;
macro_rules! provide {
(<$lt:tt> $tcx:ident, $def_id:ident, $other:ident, $cdata:ident,
@ -419,15 +414,9 @@ impl CStore {
return LoadedMacro::ProcMacro(data.load_proc_macro(id.index, sess));
}
let def = data.get_macro(id.index);
let macro_full_name = data.def_path(id.index).to_string_friendly(|_| data.root.name);
let source_name = FileName::Macros(macro_full_name);
let source_file = sess.parse_sess.source_map().new_source_file(source_name, def.body);
let local_span = Span::with_root_ctxt(source_file.start_pos, source_file.end_pos);
let dspan = DelimSpan::from_single(local_span);
let (body, mut errors) = source_file_to_stream(&sess.parse_sess, source_file, None);
emit_unclosed_delims(&mut errors, &sess.parse_sess);
let span = data.get_span(id.index, sess);
let dspan = DelimSpan::from_single(span);
let rmeta::MacroDef { body, legacy } = data.get_macro(id.index, sess);
// Mark the attrs as used
let attrs = data.get_item_attrs(id.index, sess);
@ -441,22 +430,20 @@ impl CStore {
.data
.get_opt_name()
.expect("no name in load_macro");
sess.imported_macro_spans
.borrow_mut()
.insert(local_span, (name.to_string(), data.get_span(id.index, sess)));
sess.imported_macro_spans.borrow_mut().insert(span, (name.to_string(), span));
LoadedMacro::MacroDef(
ast::Item {
// FIXME: cross-crate hygiene
ident: ast::Ident::with_dummy_span(name),
id: ast::DUMMY_NODE_ID,
span: local_span,
span,
attrs: attrs.iter().cloned().collect(),
kind: ast::ItemKind::MacroDef(ast::MacroDef {
body: P(ast::MacArgs::Delimited(dspan, ast::MacDelimiter::Brace, body)),
legacy: def.legacy,
legacy,
}),
vis: source_map::respan(local_span.shrink_to_lo(), ast::VisibilityKind::Inherited),
vis: source_map::respan(span.shrink_to_lo(), ast::VisibilityKind::Inherited),
tokens: None,
},
data.root.edition,

3
src/librustc_metadata/rmeta/encoder.rs
View File

@ -1235,10 +1235,9 @@ impl EncodeContext<'tcx> {
/// Serialize the text of exported macros
fn encode_info_for_macro_def(&mut self, macro_def: &hir::MacroDef<'_>) {
use rustc_ast_pretty::pprust;
let def_id = self.tcx.hir().local_def_id(macro_def.hir_id);
record!(self.per_def.kind[def_id] <- EntryKind::MacroDef(self.lazy(MacroDef {
body: pprust::tts_to_string(macro_def.body.clone()),
body: macro_def.body.clone(),
legacy: macro_def.legacy,
})));
record!(self.per_def.visibility[def_id] <- ty::Visibility::Public);

3
src/librustc_metadata/rmeta/mod.rs
View File

@ -11,6 +11,7 @@ use rustc::session::config::SymbolManglingVersion;
use rustc::session::CrateDisambiguator;
use rustc::ty::{self, ReprOptions, Ty};
use rustc_ast::ast;
use rustc_ast::tokenstream::TokenStream;
use rustc_attr as attr;
use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::MetadataRef;
@ -324,7 +325,7 @@ struct ModData {
#[derive(RustcEncodable, RustcDecodable)]
struct MacroDef {
body: String,
body: TokenStream,
legacy: bool,
}

22
src/librustc_span/lib.rs
View File

@ -83,8 +83,6 @@ scoped_tls::scoped_thread_local!(pub static GLOBALS: Globals);
)]
pub enum FileName {
Real(PathBuf),
/// A macro. This includes the full name of the macro, so that there are no clashes.
Macros(String),
/// Call to `quote!`.
QuoteExpansion(u64),
/// Command line.
@ -107,7 +105,6 @@ impl std::fmt::Display for FileName {
use FileName::*;
match *self {
Real(ref path) => write!(fmt, "{}", path.display()),
Macros(ref name) => write!(fmt, "<{} macros>", name),
QuoteExpansion(_) => write!(fmt, "<quote expansion>"),
MacroExpansion(_) => write!(fmt, "<macro expansion>"),
Anon(_) => write!(fmt, "<anon>"),
@ -132,8 +129,7 @@ impl FileName {
use FileName::*;
match *self {
Real(_) => true,
Macros(_)
| Anon(_)
Anon(_)
| MacroExpansion(_)
| ProcMacroSourceCode(_)
| CfgSpec(_)
@ -144,22 +140,6 @@ impl FileName {
}
}
pub fn is_macros(&self) -> bool {
use FileName::*;
match *self {
Real(_)
| Anon(_)
| MacroExpansion(_)
| ProcMacroSourceCode(_)
| CfgSpec(_)
| CliCrateAttr(_)
| Custom(_)
| QuoteExpansion(_)
| DocTest(_, _) => false,
Macros(_) => true,
}
}
pub fn quote_expansion_source_code(src: &str) -> FileName {
let mut hasher = StableHasher::new();
src.hash(&mut hasher);

6
src/librustc_span/source_map.rs
View File

@ -975,6 +975,12 @@ impl SourceMap {
_ => None,
})
}
pub fn is_imported(&self, sp: Span) -> bool {
let source_file_index = self.lookup_source_file_idx(sp.lo());
let source_file = &self.files()[source_file_index];
source_file.is_imported()
}
}
#[derive(Clone)]

6
src/librustc_typeck/check/demand.rs
View File

@ -373,7 +373,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) -> Option<(Span, &'static str, String)> {
let sm = self.sess().source_map();
let sp = expr.span;
if !sm.span_to_filename(sp).is_real() {
if sm.is_imported(sp) {
// Ignore if span is from within a macro #41858, #58298. We previously used the macro
// call span, but that breaks down when the type error comes from multiple calls down.
return None;
@ -523,7 +523,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
{
// We have `&T`, check if what was expected was `T`. If so,
// we may want to suggest removing a `&`.
if !sm.span_to_filename(expr.span).is_real() {
if sm.is_imported(expr.span) {
if let Ok(code) = sm.span_to_snippet(sp) {
if code.starts_with('&') {
return Some((
@ -601,7 +601,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// FIXME(estebank): modify once we decide to suggest `as` casts
return false;
}
if !self.tcx.sess.source_map().span_to_filename(expr.span).is_real() {
if self.tcx.sess.source_map().is_imported(expr.span) {
// Ignore if span is from within a macro.
return false;
}

2
src/librustdoc/html/render.rs
View File

@ -1565,7 +1565,7 @@ impl Context {
let mut path = String::new();
// We can safely ignore macros from other libraries
// We can safely ignore synthetic `SourceFile`s.
let file = match item.source.filename {
FileName::Real(ref path) => path,
_ => return None,

2
src/librustdoc/html/sources.rs
View File

@ -35,7 +35,7 @@ impl<'a> DocFolder for SourceCollector<'a> {
// If we're including source files, and we haven't seen this file yet,
// then we need to render it out to the filesystem.
if self.scx.include_sources
// skip all invalid or macro spans
// skip all synthetic "files"
&& item.source.filename.is_real()
// skip non-local items
&& item.def_id.is_local()

2
src/test/rustdoc/issue-26606.rs
View File

@ -7,5 +7,5 @@
extern crate issue_26606_macro;
// @has issue_26606/constant.FOO.html
// @!has - '//a/@href' '../src/'
// @has - '//a/@href' '../src/issue_26606/auxiliary/issue-26606-macro.rs.html#3'
make_item!(FOO);

2
src/test/ui/consts/miri_unleashed/mutable_const2.stderr
View File

@ -10,7 +10,7 @@ error: internal compiler error: mutable allocation in constant
LL | const MUTABLE_BEHIND_RAW: *mut i32 = &UnsafeCell::new(42) as *const _ as *mut _;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
thread 'rustc' panicked at 'no errors encountered even though `delay_span_bug` issued', src/librustc_errors/lib.rs:355:17
thread 'rustc' panicked at 'no errors encountered even though `delay_span_bug` issued', src/librustc_errors/lib.rs:360:17
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: internal compiler error: unexpected panic

4
src/test/ui/editions/edition-keywords-2015-2018-expansion.stderr
View File

@ -7,8 +7,8 @@ LL | produces_async! {}
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
help: you can escape reserved keywords to use them as identifiers
|
LL | () => (pub fn r#async () { })
| ^^^^^^^
LL | () => (pub fn r#async() {})
| ^^^^^^^
error: aborting due to previous error

6
src/test/ui/editions/edition-keywords-2018-2015-parsing.stderr
View File

@ -33,10 +33,10 @@ LL | r#async = consumes_async_raw!(async);
| ^^^^^ no rules expected this token in macro call
error: macro expansion ends with an incomplete expression: expected one of `move`, `|`, or `||`
--> <::edition_kw_macro_2015::passes_ident macros>:1:22
--> $DIR/auxiliary/edition-kw-macro-2015.rs:27:23
|
LL | ($ i : ident) => ($ i)
| ^ expected one of `move`, `|`, or `||`
LL | ($i: ident) => ($i)
| ^ expected one of `move`, `|`, or `||`
|
::: $DIR/edition-keywords-2018-2015-parsing.rs:16:8
|

4
src/test/ui/editions/edition-keywords-2018-2018-expansion.stderr
View File

@ -7,8 +7,8 @@ LL | produces_async! {}
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
help: you can escape reserved keywords to use them as identifiers
|
LL | () => (pub fn r#async () { })
| ^^^^^^^
LL | () => (pub fn r#async() {})
| ^^^^^^^
error: aborting due to previous error

6
src/test/ui/editions/edition-keywords-2018-2018-parsing.stderr
View File

@ -33,10 +33,10 @@ LL | r#async = consumes_async_raw!(async);
| ^^^^^ no rules expected this token in macro call
error: macro expansion ends with an incomplete expression: expected one of `move`, `|`, or `||`
--> <::edition_kw_macro_2018::passes_ident macros>:1:22
--> $DIR/auxiliary/edition-kw-macro-2018.rs:27:23
|
LL | ($ i : ident) => ($ i)
| ^ expected one of `move`, `|`, or `||`
LL | ($i: ident) => ($i)
| ^ expected one of `move`, `|`, or `||`
|
::: $DIR/edition-keywords-2018-2018-parsing.rs:16:8
|

104
src/test/ui/macro_backtrace/main.-Zmacro-backtrace.stderr
View File

@ -13,66 +13,70 @@ LL | pong!();
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `error`
--> $DIR/main.rs:10:20
|
LL | / macro_rules! pong {
LL | | () => { syntax error };
| | ^^^^^ expected one of 8 possible tokens
LL | | }
| |_- in this expansion of `pong!`
LL | / macro_rules! pong {
LL | | () => { syntax error };
| | ^^^^^ expected one of 8 possible tokens
LL | | }
| |__- in this expansion of `pong!`
...
LL | ping!();
| -------- in this macro invocation
LL | ping!();
| -------- in this macro invocation
|
::: <::ping::ping macros>:1:1
::: $DIR/auxiliary/ping.rs:5:1
|
LL | () => { pong ! () ; }
| ---------------------
| | |
| | in this macro invocation
| in this expansion of `ping!`
LL | / macro_rules! ping {
LL | | () => {
LL | | pong!();
| | -------- in this macro invocation
LL | | }
LL | | }
| |_- in this expansion of `ping!`
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `error`
--> $DIR/main.rs:10:20
|
LL | / macro_rules! pong {
LL | | () => { syntax error };
| | ^^^^^ expected one of 8 possible tokens
LL | | }
| |_- in this expansion of `pong!` (#5)
LL | / macro_rules! pong {
LL | | () => { syntax error };
| | ^^^^^ expected one of 8 possible tokens
LL | | }
| |__- in this expansion of `pong!` (#5)
...
LL | deep!();
| -------- in this macro invocation (#1)
LL | deep!();
| -------- in this macro invocation (#1)
|
::: <::ping::deep macros>:1:1
::: $DIR/auxiliary/ping.rs:5:1
|
LL | () => { foo ! () ; }
| --------------------
| | |
| | in this macro invocation (#2)
| in this expansion of `deep!` (#1)
|
::: <::ping::foo macros>:1:1
|
LL | () => { bar ! () ; }
| --------------------
| | |
| | in this macro invocation (#3)
| in this expansion of `foo!` (#2)
|
::: <::ping::bar macros>:1:1
|
LL | () => { ping ! () ; }
| ---------------------
| | |
| | in this macro invocation (#4)
| in this expansion of `bar!` (#3)
|
::: <::ping::ping macros>:1:1
|
LL | () => { pong ! () ; }
| ---------------------
| | |
| | in this macro invocation (#5)
| in this expansion of `ping!` (#4)
LL | / macro_rules! ping {
LL | | () => {
LL | | pong!();
| | -------- in this macro invocation (#5)
LL | | }
LL | | }
| |_- in this expansion of `ping!` (#4)
...
LL | / macro_rules! deep {
LL | | () => {
LL | | foo!();
| | ------- in this macro invocation (#2)
LL | | }
LL | | }
| |__- in this expansion of `deep!` (#1)
...
LL | / macro_rules! foo {
LL | | () => {
LL | | bar!();
| | ------- in this macro invocation (#3)
LL | | }
LL | | }
| |__- in this expansion of `foo!` (#2)
...
LL | / macro_rules! bar {
LL | | () => {
LL | | ping!();
| | -------- in this macro invocation (#4)
LL | | }
LL | | }
| |__- in this expansion of `bar!` (#3)
error: aborting due to 3 previous errors

5
src/test/ui/macros/unknown-builtin.rs
View File

@ -1,3 +1,8 @@
// FIXME: missing sysroot spans (#53081)
// ignore-i586-unknown-linux-gnu
// ignore-i586-unknown-linux-musl
// ignore-i686-unknown-linux-musl
// error-pattern: cannot find a built-in macro with name `line`
#![feature(rustc_attrs)]

12
src/test/ui/macros/unknown-builtin.stderr
View File

@ -1,14 +1,18 @@
error: cannot find a built-in macro with name `unknown`
--> $DIR/unknown-builtin.rs:6:1
--> $DIR/unknown-builtin.rs:11:1
|
LL | macro_rules! unknown { () => () }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: cannot find a built-in macro with name `line`
--> <::core::macros::builtin::line macros>:1:1
--> $SRC_DIR/libcore/macros/mod.rs:LL:COL
|
LL | () => { } ;
| ^^^^^^^^^^^
LL | / macro_rules! line {
LL | | () => {
LL | | /* compiler built-in */
LL | | };
LL | | }
| |_____^
error: aborting due to 2 previous errors

7
src/test/ui/methods/method-on-ambiguous-numeric-type.stderr
View File

@ -42,10 +42,13 @@ LL | ($ident:ident) => { let $ident: i32 = 42; }
error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
--> $DIR/method-on-ambiguous-numeric-type.rs:30:9
|
LL | mac!(bar);
| ---------- you must specify a type for this binding, like `i32`
LL | bar.pow(2);
| ^^^
|
help: you must specify a type for this binding, like `i32`
|
LL | ($ident:ident) => { let $ident: i32 = 42; }
| ^^^^^^^^^^^
error: aborting due to 5 previous errors

17
src/test/ui/proc-macro/mixed-site-span.stderr
View File

@ -21,21 +21,10 @@ LL | local_def;
| ^^^^^^^^^ not found in this scope
error[E0412]: cannot find type `ItemUse` in crate `$crate`
--> $DIR/auxiliary/mixed-site-span.rs:14:1
--> $DIR/mixed-site-span.rs:26:1
|
LL | / pub fn proc_macro_rules(input: TokenStream) -> TokenStream {
LL | | if input.is_empty() {
LL | | let id = |s| TokenTree::from(Ident::new(s, Span::mixed_site()));
LL | | let item_def = id("ItemDef");
... |
LL | | }
LL | | }
| |_^ not found in `$crate`
|
::: $DIR/mixed-site-span.rs:26:1
|
LL | pass_dollar_crate!();
| --------------------- in this macro invocation
LL | pass_dollar_crate!();
| ^^^^^^^^^^^^^^^^^^^^^ not found in `$crate`
|
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
help: possible candidate is found in another module, you can import it into scope

119
src/test/ui/proc-macro/multispan.stderr
View File

@ -1,19 +1,8 @@
error: hello to you, too!
--> $DIR/auxiliary/multispan.rs:31:1
--> $DIR/multispan.rs:14:5
|
LL | / pub fn hello(input: TokenStream) -> TokenStream {
LL | | if let Err(diag) = parse(input) {
LL | | diag.emit();
LL | | }
LL | |
LL | | TokenStream::new()
LL | | }
| |_^
|
::: $DIR/multispan.rs:14:5
|
LL | hello!(hi);
| ----------- in this macro invocation
LL | hello!(hi);
| ^^^^^^^^^^^
|
note: found these 'hi's
--> $DIR/multispan.rs:14:12
@ -23,21 +12,10 @@ LL | hello!(hi);
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error: hello to you, too!
--> $DIR/auxiliary/multispan.rs:31:1
--> $DIR/multispan.rs:17:5
|
LL | / pub fn hello(input: TokenStream) -> TokenStream {
LL | | if let Err(diag) = parse(input) {
LL | | diag.emit();
LL | | }
LL | |
LL | | TokenStream::new()
LL | | }
| |_^
|
::: $DIR/multispan.rs:17:5
|
LL | hello!(hi hi);
| -------------- in this macro invocation
LL | hello!(hi hi);
| ^^^^^^^^^^^^^^
|
note: found these 'hi's
--> $DIR/multispan.rs:17:12
@ -47,21 +25,10 @@ LL | hello!(hi hi);
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error: hello to you, too!
--> $DIR/auxiliary/multispan.rs:31:1
--> $DIR/multispan.rs:20:5
|
LL | / pub fn hello(input: TokenStream) -> TokenStream {
LL | | if let Err(diag) = parse(input) {
LL | | diag.emit();
LL | | }
LL | |
LL | | TokenStream::new()
LL | | }
| |_^
|
::: $DIR/multispan.rs:20:5
|
LL | hello!(hi hi hi);
| ----------------- in this macro invocation
LL | hello!(hi hi hi);
| ^^^^^^^^^^^^^^^^^
|
note: found these 'hi's
--> $DIR/multispan.rs:20:12
@ -71,21 +38,10 @@ LL | hello!(hi hi hi);
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error: hello to you, too!
--> $DIR/auxiliary/multispan.rs:31:1
--> $DIR/multispan.rs:23:5
|
LL | / pub fn hello(input: TokenStream) -> TokenStream {
LL | | if let Err(diag) = parse(input) {
LL | | diag.emit();
LL | | }
LL | |
LL | | TokenStream::new()
LL | | }
| |_^
|
::: $DIR/multispan.rs:23:5
|
LL | hello!(hi hey hi yo hi beep beep hi hi);
| ---------------------------------------- in this macro invocation
LL | hello!(hi hey hi yo hi beep beep hi hi);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: found these 'hi's
--> $DIR/multispan.rs:23:12
@ -95,21 +51,10 @@ LL | hello!(hi hey hi yo hi beep beep hi hi);
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error: hello to you, too!
--> $DIR/auxiliary/multispan.rs:31:1
--> $DIR/multispan.rs:24:5
|
LL | / pub fn hello(input: TokenStream) -> TokenStream {
LL | | if let Err(diag) = parse(input) {
LL | | diag.emit();
LL | | }
LL | |
LL | | TokenStream::new()
LL | | }
| |_^
|
::: $DIR/multispan.rs:24:5
|
LL | hello!(hi there, hi how are you? hi... hi.);
| -------------------------------------------- in this macro invocation
LL | hello!(hi there, hi how are you? hi... hi.);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: found these 'hi's
--> $DIR/multispan.rs:24:12
@ -119,21 +64,10 @@ LL | hello!(hi there, hi how are you? hi... hi.);
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error: hello to you, too!
--> $DIR/auxiliary/multispan.rs:31:1
--> $DIR/multispan.rs:25:5
|
LL | / pub fn hello(input: TokenStream) -> TokenStream {
LL | | if let Err(diag) = parse(input) {
LL | | diag.emit();
LL | | }
LL | |
LL | | TokenStream::new()
LL | | }
| |_^
|
::: $DIR/multispan.rs:25:5
|
LL | hello!(whoah. hi di hi di ho);
| ------------------------------ in this macro invocation
LL | hello!(whoah. hi di hi di ho);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: found these 'hi's
--> $DIR/multispan.rs:25:19
@ -143,21 +77,10 @@ LL | hello!(whoah. hi di hi di ho);
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error: hello to you, too!
--> $DIR/auxiliary/multispan.rs:31:1
--> $DIR/multispan.rs:26:5
|
LL | / pub fn hello(input: TokenStream) -> TokenStream {
LL | | if let Err(diag) = parse(input) {
LL | | diag.emit();
LL | | }
LL | |
LL | | TokenStream::new()
LL | | }
| |_^
|
::: $DIR/multispan.rs:26:5
|
LL | hello!(hi good hi and good bye);
| -------------------------------- in this macro invocation
LL | hello!(hi good hi and good bye);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: found these 'hi's
--> $DIR/multispan.rs:26:12

6
src/test/ui/proc-macro/span-api-tests.rs
View File

@ -11,7 +11,9 @@ extern crate span_test_macros;
extern crate span_api_tests;
use span_api_tests::{reemit, assert_fake_source_file, assert_source_file, macro_stringify};
// FIXME(69775): Investigate `assert_fake_source_file`.
use span_api_tests::{reemit, assert_source_file, macro_stringify};
macro_rules! say_hello {
($macname:ident) => ( $macname! { "Hello, world!" })
@ -25,7 +27,7 @@ reemit_legacy! {
assert_source_file! { "Hello, world!" }
}
say_hello_extern! { assert_fake_source_file }
say_hello_extern! { assert_source_file }
reemit! {
assert_source_file! { "Hello, world!" }

17
src/test/ui/proc-macro/three-equals.stderr
View File

@ -1,19 +1,8 @@
error: found 2 equal signs, need exactly 3
--> $DIR/auxiliary/three-equals.rs:42:1
--> $DIR/three-equals.rs:15:5
|
LL | / pub fn three_equals(input: TokenStream) -> TokenStream {
LL | | if let Err(diag) = parse(input) {
LL | | diag.emit();
LL | | return TokenStream::new();
... |
LL | | "3".parse().unwrap()
LL | | }
| |_^
|
::: $DIR/three-equals.rs:15:5
|
LL | three_equals!(==);
| ------------------ in this macro invocation
LL | three_equals!(==);
| ^^^^^^^^^^^^^^^^^^
|
= help: input must be: `===`
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)