diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index 115782ca2ade..5056876f3ad5 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -764,23 +764,51 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { // // found_trait_ref: std::ops::FnMut<(&i32,)> // ``` - let closure_args_span = found_did.and_then(|did| self.tcx.hir.get_if_local(did)) + let (closure_span, closure_args) = found_did + .and_then(|did| self.tcx.hir.get_if_local(did)) .and_then(|node| { if let hir::map::NodeExpr( - &hir::Expr { node: hir::ExprClosure(_, _, _, span, _), .. }) = node + &hir::Expr { + node: hir::ExprClosure(_, ref decl, id, span, _), + .. + }) = node { - Some(span) + let ty_snips = decl.inputs.iter() + .map(|ty| { + self.tcx.sess.codemap().span_to_snippet(ty.span).ok() + .and_then(|snip| { + // filter out dummy spans + if snip == "," || snip == "|" { + None + } else { + Some(snip) + } + }) + }) + .collect::>>(); + + let body = self.tcx.hir.body(id); + let pat_snips = body.arguments.iter() + .map(|arg| + self.tcx.sess.codemap().span_to_snippet(arg.pat.span).ok()) + .collect::>>(); + + Some((span, pat_snips, ty_snips)) } else { None } - }); + }) + .map(|(span, pat, ty)| (Some(span), Some((pat, ty)))) + .unwrap_or((None, None)); + let closure_args = closure_args.and_then(|(pat, ty)| Some((pat?, ty))); self.report_arg_count_mismatch( span, - closure_args_span.or(found_span), + closure_span.or(found_span), expected_ty_count, expected_tuple, found_ty_count, + closure_args, found_trait_ty.is_closure() ) } @@ -803,44 +831,85 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { err.emit(); } - fn report_arg_count_mismatch(&self, - span: Span, - found_span: Option, - expected: usize, - expected_tuple: Option, - found: usize, - is_closure: bool) - -> DiagnosticBuilder<'tcx> - { + fn report_arg_count_mismatch( + &self, + span: Span, + found_span: Option, + expected: usize, + expected_tuple: Option, + found: usize, + closure_args: Option<(Vec, Vec>)>, + is_closure: bool + ) -> DiagnosticBuilder<'tcx> { + use std::borrow::Cow; + let kind = if is_closure { "closure" } else { "function" }; - let tuple_or_args = |tuple, args| if let Some(n) = tuple { - format!("a {}-tuple", n) - } else { - format!( + let args_str = |n| format!( "{} argument{}", - args, - if args == 1 { "" } else { "s" } - ) - }; - - let found_str = tuple_or_args(None, found); - let expected_str = tuple_or_args(expected_tuple, expected); + n, + if n == 1 { "" } else { "s" } + ); let mut err = struct_span_err!(self.tcx.sess, span, E0593, - "{} takes {} but {} {} required", + "{} takes {}, but {} {} required", kind, - found_str, - expected_str, - if expected_tuple.is_some() || expected == 1 { "is" } else { "are" }); + if expected_tuple.is_some() { + Cow::from("multiple arguments") + } else { + Cow::from(args_str(found)) + }, + if expected_tuple.is_some() { + Cow::from("a tuple argument") + } else { + Cow::from(args_str(expected)) + }, + if expected == 1 { "is" } else { "are" }); err.span_label( span, - format!("expected {} that takes {}", kind, expected_str) + format!( + "expected {} that takes {}{}", + kind, + args_str(expected), + if let Some(n) = expected_tuple { + assert!(expected == 1); + Cow::from(format!(", a {}-tuple", n)) + } else { + Cow::from("") + } + ) ); if let Some(span) = found_span { - err.span_label(span, format!("takes {}", found_str)); + if let (Some(expected_tuple), Some((pats, tys))) = (expected_tuple, closure_args) { + if expected_tuple != found || pats.len() != found { + err.span_label(span, format!("takes {}", args_str(found))); + } else { + let sugg = format!( + "|({}){}|", + pats.join(", "), + + // add type annotations if available + if tys.iter().any(|ty| ty.is_some()) { + Cow::from(format!( + ": ({})", + tys.into_iter().map(|ty| if let Some(ty) = ty { + ty + } else { + "_".to_string() + }).collect::>().join(", ") + )) + } else { + Cow::from("") + }, + ); + + err.span_suggestion(span, "consider changing to", sugg); + } + } else { + err.span_label(span, format!("takes {}", args_str(found))); + } } err diff --git a/src/test/ui/mismatched_types/closure-arg-count.rs b/src/test/ui/mismatched_types/closure-arg-count.rs index a2a31d44a499..5d2d1d2b04c5 100644 --- a/src/test/ui/mismatched_types/closure-arg-count.rs +++ b/src/test/ui/mismatched_types/closure-arg-count.rs @@ -18,4 +18,6 @@ fn main() { f(|| panic!()); let _it = vec![1, 2, 3].into_iter().enumerate().map(|i, x| i); + let _it = vec![1, 2, 3].into_iter().enumerate().map(|i: usize, x| i); + let _it = vec![1, 2, 3].into_iter().enumerate().map(|i, x, y| i); } diff --git a/src/test/ui/mismatched_types/closure-arg-count.stderr b/src/test/ui/mismatched_types/closure-arg-count.stderr index e59a585149b8..24860faf2d52 100644 --- a/src/test/ui/mismatched_types/closure-arg-count.stderr +++ b/src/test/ui/mismatched_types/closure-arg-count.stderr @@ -1,4 +1,4 @@ -error[E0593]: closure takes 0 arguments but 2 arguments are required +error[E0593]: closure takes 0 arguments, but 2 arguments are required --> $DIR/closure-arg-count.rs:15:15 | 15 | [1, 2, 3].sort_by(|| panic!()); @@ -6,7 +6,7 @@ error[E0593]: closure takes 0 arguments but 2 arguments are required | | | expected closure that takes 2 arguments -error[E0593]: closure takes 1 argument but 2 arguments are required +error[E0593]: closure takes 1 argument, but 2 arguments are required --> $DIR/closure-arg-count.rs:16:15 | 16 | [1, 2, 3].sort_by(|tuple| panic!()); @@ -23,7 +23,7 @@ error[E0308]: mismatched types = note: expected type `&{integer}` found type `(_, _)` -error[E0593]: closure takes 1 argument but 2 arguments are required +error[E0593]: closure takes 1 argument, but 2 arguments are required --> $DIR/closure-arg-count.rs:17:15 | 17 | [1, 2, 3].sort_by(|(tuple, tuple2)| panic!()); @@ -31,7 +31,7 @@ error[E0593]: closure takes 1 argument but 2 arguments are required | | | expected closure that takes 2 arguments -error[E0593]: closure takes 0 arguments but 1 argument is required +error[E0593]: closure takes 0 arguments, but 1 argument is required --> $DIR/closure-arg-count.rs:18:5 | 18 | f(|| panic!()); @@ -41,13 +41,29 @@ error[E0593]: closure takes 0 arguments but 1 argument is required | = note: required by `f` -error[E0593]: closure takes 2 arguments but a 2-tuple is required +error[E0593]: closure takes multiple arguments, but a tuple argument is required --> $DIR/closure-arg-count.rs:20:53 | 20 | let _it = vec![1, 2, 3].into_iter().enumerate().map(|i, x| i); - | ^^^ ------ takes 2 arguments + | ^^^ ------ help: consider changing to: `|(i, x)|` | | - | expected closure that takes a 2-tuple + | expected closure that takes 1 argument, a 2-tuple -error: aborting due to 6 previous errors +error[E0593]: closure takes multiple arguments, but a tuple argument is required + --> $DIR/closure-arg-count.rs:21:53 + | +21 | let _it = vec![1, 2, 3].into_iter().enumerate().map(|i: usize, x| i); + | ^^^ ------------- help: consider changing to: `|(i, x): (usize, _)|` + | | + | expected closure that takes 1 argument, a 2-tuple + +error[E0593]: closure takes multiple arguments, but a tuple argument is required + --> $DIR/closure-arg-count.rs:22:53 + | +22 | let _it = vec![1, 2, 3].into_iter().enumerate().map(|i, x, y| i); + | ^^^ --------- takes 3 arguments + | | + | expected closure that takes 1 argument, a 2-tuple + +error: aborting due to 8 previous errors