OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Tweak macro parse errors when reaching EOF during macro call parse 

- Add detail on origin of current parser when reaching EOF and stop
  saying "found <eof>" and point at the end of macro calls
- Handle empty `cfg_attr` attribute
- Reword empty `derive` attribute error
This commit is contained in:
Esteban Küber 2019-05-21 17:47:23 -07:00
parent fc45382c12
commit 24160171e4
21 changed files with 176 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/libfmt_macros/lib.rs
View File

@ -627,7 +627,7 @@ mod tests {
use super::*;
fn same(fmt: &'static str, p: &[Piece<'static>]) {
let parser = Parser::new(fmt, None, vec![], false);
let parser = Parser::new(fmt, None, vec![], false, None);
assert!(parser.collect::<Vec<Piece<'static>>>() == p);
}
@ -643,7 +643,7 @@ mod tests {
}
fn musterr(s: &str) {
let mut p = Parser::new(s, None, vec![], false);
let mut p = Parser::new(s, None, vec![], false, None);
p.next();
assert!(!p.errors.is_empty());
}

24
src/librustc/traits/on_unimplemented.rs
View File

@ -226,12 +226,12 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString {
Ok(result)
}
fn verify(&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
trait_def_id: DefId,
span: Span)
-> Result<(), ErrorReported>
{
fn verify(
&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
trait_def_id: DefId,
span: Span,
) -> Result<(), ErrorReported> {
let name = tcx.item_name(trait_def_id);
let generics = tcx.generics_of(trait_def_id);
let parser = Parser::new(&self.0, None, vec![], false);
@ -272,12 +272,12 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString {
result
}
pub fn format(&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
trait_ref: ty::TraitRef<'tcx>,
options: &FxHashMap<String, String>)
-> String
{
pub fn format(
&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
trait_ref: ty::TraitRef<'tcx>,
options: &FxHashMap<String, String>,
) -> String {
let name = tcx.item_name(trait_ref.def_id);
let trait_str = tcx.def_path_str(trait_ref.def_id);
let generics = tcx.generics_of(trait_ref.def_id);

9
src/libsyntax/attr/mod.rs
View File

@ -278,7 +278,14 @@ impl Attribute {
pub fn parse<'a, T, F>(&self, sess: &'a ParseSess, mut f: F) -> PResult<'a, T>
where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
let mut parser = Parser::new(sess, self.tokens.clone(), None, false, false);
let mut parser = Parser::new(
sess,
self.tokens.clone(),
None,
false,
false,
Some("attribute"),
);
let result = f(&mut parser)?;
if parser.token != token::Eof {
parser.unexpected()?;

13
src/libsyntax/config.rs
View File

@ -94,6 +94,17 @@ impl<'a> StripUnconfigured<'a> {
if !attr.check_name(sym::cfg_attr) {
return vec![attr];
}
if attr.tokens.len() == 0 {
self.sess.span_diagnostic.struct_span_err(attr.span, "bad `cfg_attr` attribute")
.span_label(attr.span, "missing condition and attribute")
.note("`cfg_attr` must be of the form: \
`#[cfg_attr(condition, attribute)]`")
.note("for more information, visit \
<https://doc.rust-lang.org/reference/conditional-compilation.html\
#the-cfg_attr-attribute>")
.emit();
return vec![];
}
let (cfg_predicate, expanded_attrs) = match attr.parse(self.sess, |parser| {
parser.expect(&token::OpenDelim(token::Paren))?;
@ -117,7 +128,7 @@ impl<'a> StripUnconfigured<'a> {
Ok(result) => result,
Err(mut e) => {
e.emit();
return Vec::new();
return vec![];
}
};

6
src/libsyntax/ext/base.rs
View File

@ -850,7 +850,11 @@ impl<'a> ExtCtxt<'a> {
}
pub fn new_parser_from_tts(&self, tts: &[tokenstream::TokenTree]) -> parser::Parser<'a> {
parse::stream_to_parser(self.parse_sess, tts.iter().cloned().collect())
parse::stream_to_parser(
self.parse_sess,
tts.iter().cloned().collect(),
Some("macro arguments"),
)
}
pub fn source_map(&self) -> &'a SourceMap { self.parse_sess.source_map() }
pub fn parse_sess(&self) -> &'a parse::ParseSess { self.parse_sess }

7
src/libsyntax/ext/derive.rs
View File

@ -17,8 +17,11 @@ pub fn collect_derives(cx: &mut ExtCtxt<'_>, attrs: &mut Vec<ast::Attribute>) ->
return true;
}
if !attr.is_meta_item_list() {
cx.span_err(attr.span,
"attribute must be of the form `#[derive(Trait1, Trait2, ...)]`");
cx.struct_span_err(attr.span, "bad `derive` attribute")
.span_label(attr.span, "missing traits to be derived")
.note("`derive` must be of the form: \
`#[derive(Trait1, Trait2, ...)]`")
.emit();
return false;
}

9
src/libsyntax/ext/tt/macro_parser.rs
View File

@ -658,7 +658,14 @@ pub fn parse(
recurse_into_modules: bool,
) -> NamedParseResult {
// Create a parser that can be used for the "black box" parts.
let mut parser = Parser::new(sess, tts, directory, recurse_into_modules, true);
let mut parser = Parser::new(
sess,
tts,
directory,
recurse_into_modules,
true,
Some("macro arguments"),
);
// A queue of possible matcher positions. We initialize it with the matcher position in which
// the "dot" is before the first token of the first token tree in `ms`. `inner_parse_loop` then

2
src/libsyntax/ext/tt/macro_rules.rs
View File

@ -172,7 +172,7 @@ fn generic_extension<'cx>(cx: &'cx mut ExtCtxt<'_>,
path: Cow::from(cx.current_expansion.module.directory.as_path()),
ownership: cx.current_expansion.directory_ownership,
};
let mut p = Parser::new(cx.parse_sess(), tts, Some(directory), true, false);
let mut p = Parser::new(cx.parse_sess(), tts, Some(directory), true, false, None);
p.root_module_name = cx.current_expansion.module.mod_path.last()
.map(|id| id.as_str().to_string());

12
src/libsyntax/parse/mod.rs
View File

@ -236,7 +236,7 @@ fn maybe_source_file_to_parser(
) -> Result<Parser<'_>, Vec<Diagnostic>> {
let end_pos = source_file.end_pos;
let (stream, unclosed_delims) = maybe_file_to_stream(sess, source_file, None)?;
let mut parser = stream_to_parser(sess, stream);
let mut parser = stream_to_parser(sess, stream, None);
parser.unclosed_delims = unclosed_delims;
if parser.token == token::Eof && parser.span.is_dummy() {
parser.span = Span::new(end_pos, end_pos, parser.span.ctxt());
@ -248,7 +248,7 @@ fn maybe_source_file_to_parser(
// must preserve old name for now, because quote! from the *existing*
// compiler expands into it
pub fn new_parser_from_tts(sess: &ParseSess, tts: Vec<TokenTree>) -> Parser<'_> {
stream_to_parser(sess, tts.into_iter().collect())
stream_to_parser(sess, tts.into_iter().collect(), Some("macro arguments"))
}
@ -328,8 +328,12 @@ pub fn maybe_file_to_stream(
}
/// Given stream and the `ParseSess`, produces a parser.
pub fn stream_to_parser(sess: &ParseSess, stream: TokenStream) -> Parser<'_> {
Parser::new(sess, stream, None, true, false)
pub fn stream_to_parser<'a>(
sess: &'a ParseSess,
stream: TokenStream,
is_subparser: Option<&'static str>,
) -> Parser<'a> {
Parser::new(sess, stream, None, true, false, is_subparser)
}
/// Given stream, the `ParseSess` and the base directory, produces a parser.

91
src/libsyntax/parse/parser.rs
View File

@ -51,7 +51,7 @@ use crate::symbol::{kw, sym, Symbol};
use errors::{Applicability, DiagnosticBuilder, DiagnosticId, FatalError};
use rustc_target::spec::abi::{self, Abi};
use syntax_pos::{
Span, MultiSpan, BytePos, FileName,
BytePos, DUMMY_SP, FileName, MultiSpan, Span,
hygiene::CompilerDesugaringKind,
};
use log::{debug, trace};
@ -233,6 +233,8 @@ pub struct Parser<'a> {
/// error.
crate unclosed_delims: Vec<UnmatchedBrace>,
last_unexpected_token_span: Option<Span>,
/// If `true`, this `Parser` is not parsing Rust code but rather a macro call.
is_subparser: Option<&'static str>,
}
impl<'a> Drop for Parser<'a> {
@ -309,7 +311,7 @@ impl TokenCursor {
self.frame = frame;
continue
} else {
return TokenAndSpan { tok: token::Eof, sp: syntax_pos::DUMMY_SP }
return TokenAndSpan { tok: token::Eof, sp: DUMMY_SP }
};
match self.frame.last_token {
@ -533,17 +535,19 @@ enum TokenExpectType {
}
impl<'a> Parser<'a> {
pub fn new(sess: &'a ParseSess,
tokens: TokenStream,
directory: Option<Directory<'a>>,
recurse_into_file_modules: bool,
desugar_doc_comments: bool)
-> Self {
pub fn new(
sess: &'a ParseSess,
tokens: TokenStream,
directory: Option<Directory<'a>>,
recurse_into_file_modules: bool,
desugar_doc_comments: bool,
is_subparser: Option<&'static str>,
) -> Self {
let mut parser = Parser {
sess,
token: token::Whitespace,
span: syntax_pos::DUMMY_SP,
prev_span: syntax_pos::DUMMY_SP,
span: DUMMY_SP,
prev_span: DUMMY_SP,
meta_var_span: None,
prev_token_kind: PrevTokenKind::Other,
restrictions: Restrictions::empty(),
@ -568,6 +572,7 @@ impl<'a> Parser<'a> {
max_angle_bracket_count: 0,
unclosed_delims: Vec::new(),
last_unexpected_token_span: None,
is_subparser,
};
let tok = parser.next_tok();
@ -639,16 +644,28 @@ impl<'a> Parser<'a> {
} else {
let token_str = pprust::token_to_string(t);
let this_token_str = self.this_token_descr();
let mut err = self.fatal(&format!("expected `{}`, found {}",
token_str,
this_token_str));
let sp = if self.token == token::Token::Eof {
// EOF, don't want to point at the following char, but rather the last token
self.prev_span
} else {
self.sess.source_map().next_point(self.prev_span)
let (prev_sp, sp) = match (&self.token, self.is_subparser) {
// Point at the end of the macro call when reaching end of macro arguments.
(token::Token::Eof, Some(_)) => {
let sp = self.sess.source_map().next_point(self.span);
(sp, sp)
}
// We don't want to point at the following span after DUMMY_SP.
// This happens when the parser finds an empty TokenStream.
_ if self.prev_span == DUMMY_SP => (self.span, self.span),
// EOF, don't want to point at the following char, but rather the last token.
(token::Token::Eof, None) => (self.prev_span, self.span),
_ => (self.sess.source_map().next_point(self.prev_span), self.span),
};
let msg = format!(
"expected `{}`, found {}",
token_str,
match (&self.token, self.is_subparser) {
(token::Token::Eof, Some(origin)) => format!("end of {}", origin),
_ => this_token_str,
},
);
let mut err = self.struct_span_err(sp, &msg);
let label_exp = format!("expected `{}`", token_str);
match self.recover_closing_delimiter(&[t.clone()], err) {
Err(e) => err = e,
@ -657,15 +674,15 @@ impl<'a> Parser<'a> {
}
}
let cm = self.sess.source_map();
match (cm.lookup_line(self.span.lo()), cm.lookup_line(sp.lo())) {
match (cm.lookup_line(prev_sp.lo()), cm.lookup_line(sp.lo())) {
(Ok(ref a), Ok(ref b)) if a.line == b.line => {
// When the spans are in the same line, it means that the only content
// between them is whitespace, point only at the found token.
err.span_label(self.span, label_exp);
err.span_label(sp, label_exp);
}
_ => {
err.span_label(sp, label_exp);
err.span_label(self.span, "unexpected token");
err.span_label(prev_sp, label_exp);
err.span_label(sp, "unexpected token");
}
}
Err(err)
@ -812,7 +829,7 @@ impl<'a> Parser<'a> {
// | expected one of 8 possible tokens here
err.span_label(self.span, label_exp);
}
_ if self.prev_span == syntax_pos::DUMMY_SP => {
_ if self.prev_span == DUMMY_SP => {
// Account for macro context where the previous span might not be
// available to avoid incorrect output (#54841).
err.span_label(self.span, "unexpected token");
@ -2041,7 +2058,7 @@ impl<'a> Parser<'a> {
path = self.parse_path(PathStyle::Type)?;
path_span = path_lo.to(self.prev_span);
} else {
path = ast::Path { segments: Vec::new(), span: syntax_pos::DUMMY_SP };
path = ast::Path { segments: Vec::new(), span: DUMMY_SP };
path_span = self.span.to(self.span);
}
@ -2627,16 +2644,24 @@ impl<'a> Parser<'a> {
}
Err(mut err) => {
self.cancel(&mut err);
let msg = format!("expected expression, found {}",
self.this_token_descr());
let mut err = self.fatal(&msg);
let (span, msg) = match (&self.token, self.is_subparser) {
(&token::Token::Eof, Some(origin)) => {
let sp = self.sess.source_map().next_point(self.span);
(sp, format!( "expected expression, found end of {}", origin))
}
_ => (self.span, format!(
"expected expression, found {}",
self.this_token_descr(),
)),
};
let mut err = self.struct_span_err(span, &msg);
let sp = self.sess.source_map().start_point(self.span);
if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow()
.get(&sp)
{
self.sess.expr_parentheses_needed(&mut err, *sp, None);
}
err.span_label(self.span, "expected expression");
err.span_label(span, "expected expression");
return Err(err);
}
}
@ -5592,7 +5617,7 @@ impl<'a> Parser<'a> {
where_clause: WhereClause {
id: ast::DUMMY_NODE_ID,
predicates: Vec::new(),
span: syntax_pos::DUMMY_SP,
span: DUMMY_SP,
},
span: span_lo.to(self.prev_span),
})
@ -5838,7 +5863,7 @@ impl<'a> Parser<'a> {
let mut where_clause = WhereClause {
id: ast::DUMMY_NODE_ID,
predicates: Vec::new(),
span: syntax_pos::DUMMY_SP,
span: DUMMY_SP,
};
if !self.eat_keyword(kw::Where) {
@ -7005,7 +7030,7 @@ impl<'a> Parser<'a> {
Ident::with_empty_ctxt(sym::warn_directory_ownership)),
tokens: TokenStream::empty(),
is_sugared_doc: false,
span: syntax_pos::DUMMY_SP,
span: DUMMY_SP,
};
attr::mark_known(&attr);
attrs.push(attr);
@ -7013,7 +7038,7 @@ impl<'a> Parser<'a> {
Ok((id, ItemKind::Mod(module), Some(attrs)))
} else {
let placeholder = ast::Mod {
inner: syntax_pos::DUMMY_SP,
inner: DUMMY_SP,
items: Vec::new(),
inline: false
};

6
src/libsyntax_ext/asm.rs
View File

@ -138,7 +138,11 @@ fn parse_inline_asm<'a>(
if p2.token != token::Eof {
let mut extra_tts = p2.parse_all_token_trees()?;
extra_tts.extend(tts[first_colon..].iter().cloned());
p = parse::stream_to_parser(cx.parse_sess, extra_tts.into_iter().collect());
p = parse::stream_to_parser(
cx.parse_sess,
extra_tts.into_iter().collect(),
Some("inline assembly"),
);
}
asm = s;

2
src/libsyntax_ext/deriving/custom.rs
View File

@ -89,7 +89,7 @@ impl MultiItemModifier for ProcMacroDerive {
let error_count_before = ecx.parse_sess.span_diagnostic.err_count();
let msg = "proc-macro derive produced unparseable tokens";
let mut parser = parse::stream_to_parser(ecx.parse_sess, stream);
let mut parser = parse::stream_to_parser(ecx.parse_sess, stream, Some("proc-macro derive"));
let mut items = vec![];
loop {

12
src/test/ui/macros/format-parse-errors.stderr
View File

@ -12,17 +12,17 @@ error: expected expression, found keyword `struct`
LL | format!(struct);
| ^^^^^^ expected expression
error: expected expression, found `<eof>`
--> $DIR/format-parse-errors.rs:4:23
error: expected expression, found end of macro arguments
--> $DIR/format-parse-errors.rs:4:24
|
LL | format!("s", name =);
| ^ expected expression
| ^ expected expression
error: expected `=`, found `<eof>`
--> $DIR/format-parse-errors.rs:5:29
error: expected `=`, found end of macro arguments
--> $DIR/format-parse-errors.rs:5:32
|
LL | format!("s", foo = foo, bar);
| ^^^ expected `=`
| ^ expected `=`
error: expected expression, found keyword `struct`
--> $DIR/format-parse-errors.rs:6:24

12
src/test/ui/malformed/malformed-derive-entry.rs
View File

@ -1,17 +1,13 @@
#[derive(Copy(Bad))]
//~^ ERROR expected one of `)`, `,`, or `::`, found `(`
#[derive(Copy(Bad))] //~ ERROR expected one of `)`, `,`, or `::`, found `(`
struct Test1;
#[derive(Copy="bad")]
//~^ ERROR expected one of `)`, `,`, or `::`, found `=`
#[derive(Copy="bad")] //~ ERROR expected one of `)`, `,`, or `::`, found `=`
struct Test2;
#[derive()]
//~^ WARNING empty trait list
#[derive()] //~ WARNING empty trait list
struct Test3;
#[derive]
//~^ ERROR attribute must be of the form
#[derive] //~ ERROR bad `derive` attribute
struct Test4;
fn main() {}

12
src/test/ui/malformed/malformed-derive-entry.stderr
View File

@ -5,22 +5,24 @@ LL | #[derive(Copy(Bad))]
| ^ expected one of `)`, `,`, or `::` here
error: expected one of `)`, `,`, or `::`, found `=`
--> $DIR/malformed-derive-entry.rs:5:14
--> $DIR/malformed-derive-entry.rs:4:14
|
LL | #[derive(Copy="bad")]
| ^ expected one of `)`, `,`, or `::` here
warning: empty trait list in `derive`
--> $DIR/malformed-derive-entry.rs:9:1
--> $DIR/malformed-derive-entry.rs:7:1
|
LL | #[derive()]
| ^^^^^^^^^^^
error: attribute must be of the form `#[derive(Trait1, Trait2, ...)]`
--> $DIR/malformed-derive-entry.rs:13:1
error: bad `derive` attribute
--> $DIR/malformed-derive-entry.rs:10:1
|
LL | #[derive]
| ^^^^^^^^^
| ^^^^^^^^^ missing traits to be derived
|
= note: `derive` must be of the form: `#[derive(Trait1, Trait2, ...)]`
error: aborting due to 3 previous errors

6
src/test/ui/malformed/malformed-special-attrs.rs
View File

@ -1,13 +1,13 @@
#[cfg_attr] //~ ERROR expected `(`, found `<eof>`
#[cfg_attr] //~ ERROR bad `cfg_attr` attribute
struct S1;
#[cfg_attr = ""] //~ ERROR expected `(`, found `=`
struct S2;
#[derive] //~ ERROR attribute must be of the form
#[derive] //~ ERROR bad `derive` attribute
struct S3;
#[derive = ""] //~ ERROR attribute must be of the form
#[derive = ""] //~ ERROR bad `derive` attribute
struct S4;
fn main() {}

26
src/test/ui/malformed/malformed-special-attrs.stderr
View File

@ -1,25 +1,33 @@
error: expected `(`, found `<eof>`
error: bad `cfg_attr` attribute
--> $DIR/malformed-special-attrs.rs:1:1
|
LL | #[cfg_attr]
| ^^^^^^^^^^^ missing condition and attribute
|
= note: `cfg_attr` must be of the form: `#[cfg_attr(condition, attribute)]`
= note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
error: expected `(`, found `=`
--> $DIR/malformed-special-attrs.rs:4:12
|
LL | #[cfg_attr]
| - expected `(`
...
LL | #[cfg_attr = ""]
| ^ unexpected token
| ^ expected `(`
error: attribute must be of the form `#[derive(Trait1, Trait2, ...)]`
error: bad `derive` attribute
--> $DIR/malformed-special-attrs.rs:7:1
|
LL | #[derive]
| ^^^^^^^^^
| ^^^^^^^^^ missing traits to be derived
|
= note: `derive` must be of the form: `#[derive(Trait1, Trait2, ...)]`
error: attribute must be of the form `#[derive(Trait1, Trait2, ...)]`
error: bad `derive` attribute
--> $DIR/malformed-special-attrs.rs:10:1
|
LL | #[derive = ""]
| ^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^ missing traits to be derived
|
= note: `derive` must be of the form: `#[derive(Trait1, Trait2, ...)]`
error: aborting due to 4 previous errors

4
src/test/ui/parser/bad-macro-argument.rs Normal file
View File

@ -0,0 +1,4 @@
fn main() {
let message = "world";
println!("Hello, {}", message/); //~ ERROR expected expression
}

8
src/test/ui/parser/bad-macro-argument.stderr Normal file
View File

@ -0,0 +1,8 @@
error: expected expression, found end of macro arguments
--> $DIR/bad-macro-argument.rs:3:35
|
LL | println!("Hello, {}", message/);
| ^ expected expression
error: aborting due to previous error

2
src/test/ui/proc-macro/attr-invalid-exprs.rs
View File

@ -9,7 +9,7 @@ use attr_stmt_expr::{duplicate, no_output};
fn main() {
let _ = #[no_output] "Hello, world!";
//~^ ERROR expected expression, found `<eof>`
//~^ ERROR expected expression, found end of macro arguments
let _ = #[duplicate] "Hello, world!";
//~^ ERROR macro expansion ignores token `,` and any following

2
src/test/ui/proc-macro/attr-invalid-exprs.stderr
View File

@ -1,4 +1,4 @@
error: expected expression, found `<eof>`
error: expected expression, found end of macro arguments
--> $DIR/attr-invalid-exprs.rs:11:13
|
LL | let _ = #[no_output] "Hello, world!";