snapshot.bump(); // `(`
match snapshot.parse_struct_fields(path, false, token::Paren) {
Ok((fields, ..)) if snapshot.eat(&token::CloseDelim(token::Paren)) => {
- // We have are certain we have `Enum::Foo(a: 3, b: 4)`, suggest
+ // We are certain we have `Enum::Foo(a: 3, b: 4)`, suggest
// `Enum::Foo { a: 3, b: 4 }` or `Enum::Foo(3, 4)`.
*self = snapshot;
let close_paren = self.prev_token.span;
let span = lo.to(self.prev_token.span);
- err.cancel();
- self.struct_span_err(
- span,
- "invalid `struct` delimiters or `fn` call arguments",
- )
- .multipart_suggestion(
- &format!("if `{}` is a struct, use braces as delimiters", name),
- vec![(open_paren, " { ".to_string()), (close_paren, " }".to_string())],
- Applicability::MaybeIncorrect,
- )
- .multipart_suggestion(
- &format!("if `{}` is a function, use the arguments directly", name),
- fields
- .into_iter()
- .map(|field| (field.span.until(field.expr.span), String::new()))
- .collect(),
- Applicability::MaybeIncorrect,
- )
- .emit();
+ if !fields.is_empty() {
+ err.cancel();
+ let mut err = self.struct_span_err(
+ span,
+ "invalid `struct` delimiters or `fn` call arguments",
+ );
+ err.multipart_suggestion(
+ &format!("if `{}` is a struct, use braces as delimiters", name),
+ vec![
+ (open_paren, " { ".to_string()),
+ (close_paren, " }".to_string()),
+ ],
+ Applicability::MaybeIncorrect,
+ );
+ err.multipart_suggestion(
+ &format!("if `{}` is a function, use the arguments directly", name),
+ fields
+ .into_iter()
+ .map(|field| (field.span.until(field.expr.span), String::new()))
+ .collect(),
+ Applicability::MaybeIncorrect,
+ );
+ err.emit();
+ } else {
+ err.emit();
+ }
return Some(self.mk_expr_err(span));
}
Ok(_) => {}
/// Assuming we have just parsed `.`, continue parsing into an expression.
fn parse_dot_suffix(&mut self, self_arg: P<Expr>, lo: Span) -> PResult<'a, P<Expr>> {
if self.token.uninterpolated_span().rust_2018() && self.eat_keyword(kw::Await) {
- return Ok(self.mk_await_expr(self_arg, lo));
+ return Ok(self.mk_await_expr(self_arg));
}
let fn_span_lo = self.token.span;
ExprKind::Call(f, args)
}
- fn mk_await_expr(&mut self, self_arg: P<Expr>, lo: Span) -> P<Expr> {
- let span = lo.to(self.prev_token.span);
+ fn mk_await_expr(&mut self, self_arg: P<Expr>) -> P<Expr> {
+ let span = self.prev_token.span;
let await_expr = self.mk_expr(span, ExprKind::Await(self_arg), AttrVec::new());
self.recover_from_await_method_call();
await_expr