Skip to content
Permalink
Browse files

Recover gracefully from argument with missing type or param name

  • Loading branch information...
estebank committed May 29, 2019
1 parent aee7012 commit b3ac88ad922a618e6bf0eb269084d60233a311e4
@@ -2298,7 +2298,7 @@ impl<'a> LoweringContext<'a> {

fn lower_arg_source(&mut self, source: &ArgSource) -> hir::ArgSource {
match source {
ArgSource::Normal => hir::ArgSource::Normal,
ArgSource::Normal | ArgSource::Recovery => hir::ArgSource::Normal,
ArgSource::AsyncFn(pat) => hir::ArgSource::AsyncFn(self.lower_pat(pat)),
}
}
@@ -1780,6 +1780,8 @@ pub enum ArgSource {
Normal,
/// Argument from `async fn` lowering, contains the original binding pattern.
AsyncFn(P<Pat>),
/// Placeholder argument caused by incorrect syntax. Used to silence unecessary errors.
Recovery,
}

/// Alternative representation for `Arg`s describing `self` parameter of methods.
@@ -580,7 +580,7 @@ pub fn noop_visit_arg<T: MutVisitor>(Arg { id, pat, ty, source }: &mut Arg, vis:

pub fn noop_visit_arg_source<T: MutVisitor>(source: &mut ArgSource, vis: &mut T) {
match source {
ArgSource::Normal => {},
ArgSource::Normal | ArgSource::Recovery => {},
ArgSource::AsyncFn(pat) => vis.visit_pat(pat),
}
}
@@ -1,7 +1,7 @@
use crate::ast;
use crate::ast::{
BlockCheckMode, BinOpKind, Expr, ExprKind, Item, ItemKind, Pat, PatKind, PathSegment, QSelf,
Ty, TyKind, VariantData,
Ty, TyKind, VariantData, Ident,
};
use crate::parse::{SeqSep, token, PResult, Parser};
use crate::parse::parser::{BlockMode, PathStyle, SemiColonMode, TokenType, TokenExpectType};
@@ -1092,12 +1092,12 @@ impl<'a> Parser<'a> {
pat: P<ast::Pat>,
require_name: bool,
is_trait_item: bool,
) {
) -> Option<Ident> {
// If we find a pattern followed by an identifier, it could be an (incorrect)
// C-style parameter declaration.
if self.check_ident() && self.look_ahead(1, |t| {
*t == token::Comma || *t == token::CloseDelim(token::Paren)
}) {
}) { // `fn foo(String s) {}`
let ident = self.parse_ident().unwrap();
let span = pat.span.with_hi(ident.span.hi());

@@ -1107,18 +1107,30 @@ impl<'a> Parser<'a> {
String::from("<identifier>: <type>"),
Applicability::HasPlaceholders,
);
} else if require_name && is_trait_item {
if let PatKind::Ident(_, ident, _) = pat.node {
return Some(ident);
} else if let PatKind::Ident(_, ident, _) = pat.node {
if require_name && (
is_trait_item ||
self.token == token::Comma ||
self.token == token::CloseDelim(token::Paren)
) { // `fn foo(a, b) {}` or `fn foo(usize, usize) {}`
err.span_suggestion(
pat.span,
"if this was a parameter name, give it a type",
format!("{}: TypeName", ident),
Applicability::HasPlaceholders,
);
err.span_suggestion(
pat.span,
"explicitly ignore parameter",
"if this is a type, explicitly ignore the parameter name",
format!("_: {}", ident),
Applicability::MachineApplicable,
);
err.note("anonymous parameters are removed in the 2018 edition (see RFC 1685)");
return Some(ident);
}

err.note("anonymous parameters are removed in the 2018 edition (see RFC 1685)");
}
None
}

crate fn recover_arg_parse(&mut self) -> PResult<'a, (P<ast::Pat>, P<ast::Ty>)> {
@@ -51,6 +51,7 @@ use crate::parse::diagnostics::Error;

use errors::{Applicability, DiagnosticBuilder, DiagnosticId, FatalError};
use rustc_target::spec::abi::{self, Abi};
use rustc_data_structures::fx::FxHashSet;
use syntax_pos::{Span, BytePos, DUMMY_SP, FileName, hygiene::CompilerDesugaringKind};
use log::debug;

@@ -452,19 +453,18 @@ impl From<P<Expr>> for LhsExpr {
}

/// Creates a placeholder argument.
fn dummy_arg(span: Span) -> Arg {
let ident = Ident::new(kw::Invalid, span);
fn dummy_arg(ident: Ident) -> Arg {
let pat = P(Pat {
id: ast::DUMMY_NODE_ID,
node: PatKind::Ident(BindingMode::ByValue(Mutability::Immutable), ident, None),
span,
span: ident.span,
});
let ty = Ty {
node: TyKind::Err,
span,
span: ident.span,
id: ast::DUMMY_NODE_ID
};
Arg { ty: P(ty), pat: pat, id: ast::DUMMY_NODE_ID, source: ast::ArgSource::Normal }
Arg { ty: P(ty), pat: pat, id: ast::DUMMY_NODE_ID, source: ast::ArgSource::Recovery }
}

#[derive(Copy, Clone, Debug)]
@@ -1528,8 +1528,17 @@ impl<'a> Parser<'a> {
let pat = self.parse_pat(Some("argument name"))?;

if let Err(mut err) = self.expect(&token::Colon) {
self.argument_without_type(&mut err, pat, require_name, is_trait_item);
return Err(err);
if let Some(ident) = self.argument_without_type(
&mut err,
pat,
require_name,
is_trait_item,
) {
err.emit();
return Ok(dummy_arg(ident));
} else {
return Err(err);
}
}

self.eat_incorrect_doc_comment("a method argument's type");
@@ -5431,7 +5440,7 @@ impl<'a> Parser<'a> {
p.eat_to_tokens(&[&token::Comma, &token::CloseDelim(token::Paren)]);
// Create a placeholder argument for proper arg count (issue #34264).
let span = lo.to(p.prev_span);
Ok(Some(dummy_arg(span)))
Ok(Some(dummy_arg(Ident::new(kw::Invalid, span))))
}
}
}
@@ -5584,7 +5593,7 @@ impl<'a> Parser<'a> {

// Parse the rest of the function parameter list.
let sep = SeqSep::trailing_allowed(token::Comma);
let (fn_inputs, recovered) = if let Some(self_arg) = self_arg {
let (mut fn_inputs, recovered) = if let Some(self_arg) = self_arg {
if self.check(&token::CloseDelim(token::Paren)) {
(vec![self_arg], false)
} else if self.eat(&token::Comma) {
@@ -5607,6 +5616,24 @@ impl<'a> Parser<'a> {
// Parse closing paren and return type.
self.expect(&token::CloseDelim(token::Paren))?;
}
// Replace duplicated recovered arguments with `_` pattern to avoid unecessary errors.
let mut seen_inputs = FxHashSet::default();
for input in fn_inputs.iter_mut() {
let opt_ident = if let (PatKind::Ident(_, ident, _), ast::ArgSource::Recovery) = (
&input.pat.node, &input.source,
) {
Some(*ident)
} else {
None
};
if let Some(ident) = opt_ident {
if seen_inputs.contains(&ident) {
input.pat.node = PatKind::Wild;
}
seen_inputs.insert(ident);
}
}

Ok(P(FnDecl {
inputs: fn_inputs,
output: self.parse_ret_ty(true)?,
@@ -6,7 +6,13 @@ trait T {
fn foo(i32); //~ expected one of `:` or `@`, found `)`

fn bar_with_default_impl(String, String) {}
//~^ ERROR expected one of `:` or `@`, found `,`
//~^ ERROR expected one of `:`
//~| ERROR expected one of `:`

// do not complain about missing `b`
fn baz(a:usize, b, c: usize) -> usize { //~ ERROR expected one of `:`
a + b + c
}
}

fn main() {}
@@ -2,21 +2,65 @@ error: expected one of `:` or `@`, found `)`
--> $DIR/anon-params-denied-2018.rs:6:15
|
LL | fn foo(i32);
| ---^ expected one of `:` or `@` here
| |
| help: explicitly ignore parameter: `_: i32`
| ^ expected one of `:` or `@` here
|
= note: anonymous parameters are removed in the 2018 edition (see RFC 1685)
help: if this was a parameter name, give it a type
|
LL | fn foo(i32: TypeName);
| ^^^^^^^^^^^^^
help: if this is a type, explicitly ignore the parameter name
|
LL | fn foo(_: i32);
| ^^^^^^

error: expected one of `:` or `@`, found `,`
--> $DIR/anon-params-denied-2018.rs:8:36
|
LL | fn bar_with_default_impl(String, String) {}
| ------^ expected one of `:` or `@` here
| |
| help: explicitly ignore parameter: `_: String`
| ^ expected one of `:` or `@` here
|
= note: anonymous parameters are removed in the 2018 edition (see RFC 1685)
help: if this was a parameter name, give it a type
|
LL | fn bar_with_default_impl(String: TypeName, String) {}
| ^^^^^^^^^^^^^^^^
help: if this is a type, explicitly ignore the parameter name
|
LL | fn bar_with_default_impl(_: String, String) {}
| ^^^^^^^^^

error: expected one of `:` or `@`, found `)`
--> $DIR/anon-params-denied-2018.rs:8:44
|
LL | fn bar_with_default_impl(String, String) {}
| ^ expected one of `:` or `@` here
|
= note: anonymous parameters are removed in the 2018 edition (see RFC 1685)
help: if this was a parameter name, give it a type
|
LL | fn bar_with_default_impl(String, String: TypeName) {}
| ^^^^^^^^^^^^^^^^
help: if this is a type, explicitly ignore the parameter name
|
LL | fn bar_with_default_impl(String, _: String) {}
| ^^^^^^^^^

error: expected one of `:` or `@`, found `,`
--> $DIR/anon-params-denied-2018.rs:13:22
|
LL | fn baz(a:usize, b, c: usize) -> usize {
| ^ expected one of `:` or `@` here
|
= note: anonymous parameters are removed in the 2018 edition (see RFC 1685)
help: if this was a parameter name, give it a type
|
LL | fn baz(a:usize, b: TypeName, c: usize) -> usize {
| ^^^^^^^^^^^
help: if this is a type, explicitly ignore the parameter name
|
LL | fn baz(a:usize, _: b, c: usize) -> usize {
| ^^^^

error: aborting due to 2 previous errors
error: aborting due to 4 previous errors

@@ -20,6 +20,8 @@ fn pattern((i32, i32) (a, b)) {}

fn fizz(i32) {}
//~^ ERROR expected one of `:` or `@`
//~| HELP if this was a parameter name, give it a type
//~| HELP if this is a type, explicitly ignore the parameter name

fn missing_colon(quux S) {}
//~^ ERROR expected one of `:` or `@`
@@ -33,9 +33,19 @@ error: expected one of `:` or `@`, found `)`
|
LL | fn fizz(i32) {}
| ^ expected one of `:` or `@` here
|
= note: anonymous parameters are removed in the 2018 edition (see RFC 1685)
help: if this was a parameter name, give it a type
|
LL | fn fizz(i32: TypeName) {}
| ^^^^^^^^^^^^^
help: if this is a type, explicitly ignore the parameter name
|
LL | fn fizz(_: i32) {}
| ^^^^^^

error: expected one of `:` or `@`, found `S`
--> $DIR/inverted-parameters.rs:24:23
--> $DIR/inverted-parameters.rs:26:23
|
LL | fn missing_colon(quux S) {}
| -----^
@@ -3,6 +3,16 @@ error: expected one of `:` or `@`, found `)`
|
LL | fn foo(x) {
| ^ expected one of `:` or `@` here
|
= note: anonymous parameters are removed in the 2018 edition (see RFC 1685)
help: if this was a parameter name, give it a type
|
LL | fn foo(x: TypeName) {
| ^^^^^^^^^^^
help: if this is a type, explicitly ignore the parameter name
|
LL | fn foo(_: x) {
| ^^^^

error: aborting due to previous error

@@ -9,12 +9,32 @@ error: expected one of `:` or `@`, found `)`
|
LL | fn foo(Option<i32>, String) {}
| ^ expected one of `:` or `@` here
|
= note: anonymous parameters are removed in the 2018 edition (see RFC 1685)
help: if this was a parameter name, give it a type
|
LL | fn foo(Option<i32>, String: TypeName) {}
| ^^^^^^^^^^^^^^^^
help: if this is a type, explicitly ignore the parameter name
|
LL | fn foo(Option<i32>, _: String) {}
| ^^^^^^^^^

error: expected one of `:` or `@`, found `,`
--> $DIR/issue-34264.rs:3:9
|
LL | fn bar(x, y: usize) {}
| ^ expected one of `:` or `@` here
|
= note: anonymous parameters are removed in the 2018 edition (see RFC 1685)
help: if this was a parameter name, give it a type
|
LL | fn bar(x: TypeName, y: usize) {}
| ^^^^^^^^^^^
help: if this is a type, explicitly ignore the parameter name
|
LL | fn bar(_: x, y: usize) {}
| ^^^^

error[E0061]: this function takes 2 parameters but 3 parameters were supplied
--> $DIR/issue-34264.rs:7:5

0 comments on commit b3ac88a

Please sign in to comment.
You can’t perform that action at this time.