user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Print fn signature when there is closure argument type mismatch

Browse source 
Fixes #42143.
E0281 is totally replaced by E0631. UI tests are updated accordingly.
This commit is contained in:
Wonwoo Choi 2017-09-23 10:15:30 +09:00
parent 3eb19bf9b1
commit 1bfbfb20a1
14 changed files with 245 additions and 119 deletions
Download patch file Download diff file Expand all files Collapse all files

13
src/test/ui/mismatched_types/E0281.stderr
View file

@ -1,13 +0,0 @@
error[E0281]: type mismatch: `[closure@$DIR/E0281.rs:14:9: 14:24]` implements the trait `std::ops::Fn<(std::string::String,)>`, but the trait `std::ops::Fn<(usize,)>` is required
--> $DIR/E0281.rs:14:5
|
14 | foo(|y: String| { });
| ^^^ --------------- implements `std::ops::Fn<(std::string::String,)>`
| |
| expected usize, found struct `std::string::String`
| requires `std::ops::Fn<(usize,)>`
|
= note: required by `foo`
error: aborting due to previous error

20
src/test/ui/mismatched_types/E0281.rs → src/test/ui/mismatched_types/E0631.rs
View file

@ -8,18 +8,14 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
fn foo<F: Fn(usize)>(x: F) { }
#![feature(unboxed_closures)]
fn foo<F: Fn(usize)>(_: F) {}
fn bar<F: Fn<usize>>(_: F) {}
fn main() {
foo(|y: String| { });
//~^ ERROR E0281
//~| ERROR E0281
//~| NOTE implements
//~| NOTE implements
//~| NOTE requires
//~| NOTE requires
//~| NOTE expected usize, found struct `std::string::String`
//~| NOTE expected usize, found struct `std::string::String`
//~| NOTE required by `foo`
//~| NOTE required by `foo`
fn f(_: u64) {}
foo(|_: isize| {});
bar(|_: isize| {});
foo(f);
bar(f);
}

44
src/test/ui/mismatched_types/E0631.stderr Normal file
View file

@ -0,0 +1,44 @@
error[E0631]: type mismatch in closure arguments
--> $DIR/E0631.rs:17:5
|
17 | foo(|_: isize| {});
| ^^^ ------------- found signature of `fn(isize) -> _`
| |
| expected signature of `fn(usize) -> _`
|
= note: required by `foo`
error[E0631]: type mismatch in closure arguments
--> $DIR/E0631.rs:18:5
|
18 | bar(|_: isize| {});
| ^^^ ------------- found signature of `fn(isize) -> _`
| |
| expected signature of `fn(usize) -> _`
|
= note: required by `bar`
error[E0631]: type mismatch in function arguments
--> $DIR/E0631.rs:19:5
|
19 | foo(f);
| ^^^
| |
| expected signature of `fn(usize) -> _`
| found signature of `fn(u64) -> _`
|
= note: required by `foo`
error[E0631]: type mismatch in function arguments
--> $DIR/E0631.rs:20:5
|
20 | bar(f);
| ^^^
| |
| expected signature of `fn(usize) -> _`
| found signature of `fn(u64) -> _`
|
= note: required by `bar`
error: aborting due to 4 previous errors

4
src/test/ui/mismatched_types/closure-arg-count.rs
View file

@ -8,8 +8,12 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(unboxed_closures)]
fn f<F: Fn<usize>>(_: F) {}
fn main() {
[1, 2, 3].sort_by(|| panic!());
[1, 2, 3].sort_by(|tuple| panic!());
[1, 2, 3].sort_by(|(tuple, tuple2)| panic!());
f(|| panic!());
}

28
src/test/ui/mismatched_types/closure-arg-count.stderr
View file

@ -1,35 +1,45 @@
error[E0593]: closure takes 0 arguments but 2 arguments are required
--> $DIR/closure-arg-count.rs:12:15
--> $DIR/closure-arg-count.rs:15:15
|
12 | [1, 2, 3].sort_by(|| panic!());
15 | [1, 2, 3].sort_by(|| panic!());
| ^^^^^^^ ----------- takes 0 arguments
| |
| expected closure that takes 2 arguments
error[E0593]: closure takes 1 argument but 2 arguments are required
--> $DIR/closure-arg-count.rs:13:15
--> $DIR/closure-arg-count.rs:16:15
|
13 | [1, 2, 3].sort_by(|tuple| panic!());
16 | [1, 2, 3].sort_by(|tuple| panic!());
| ^^^^^^^ ---------------- takes 1 argument
| |
| expected closure that takes 2 arguments
error[E0308]: mismatched types
--> $DIR/closure-arg-count.rs:14:24
--> $DIR/closure-arg-count.rs:17:24
|
14 | [1, 2, 3].sort_by(|(tuple, tuple2)| panic!());
17 | [1, 2, 3].sort_by(|(tuple, tuple2)| panic!());
| ^^^^^^^^^^^^^^^ expected &{integer}, found tuple
|
= note: expected type `&{integer}`
found type `(_, _)`
error[E0593]: closure takes 1 argument but 2 arguments are required
--> $DIR/closure-arg-count.rs:14:15
--> $DIR/closure-arg-count.rs:17:15
|
14 | [1, 2, 3].sort_by(|(tuple, tuple2)| panic!());
17 | [1, 2, 3].sort_by(|(tuple, tuple2)| panic!());
| ^^^^^^^ -------------------------- takes 1 argument
| |
| expected closure that takes 2 arguments
error: aborting due to 4 previous errors
error[E0593]: closure takes 0 arguments but 1 argument is required
--> $DIR/closure-arg-count.rs:18:5
|
18 | f(|| panic!());
| ^ ----------- takes 0 arguments
| |
| expected closure that takes 1 argument
|
= note: required by `f`
error: aborting due to 5 previous errors

21
src/test/ui/mismatched_types/closure-arg-type-mismatch.rs Normal file
View file

@ -0,0 +1,21 @@
// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
fn main() {
let a = [(1u32, 2u32)];
a.iter().map(|_: (u32, u32)| 45);
a.iter().map(|_: &(u16, u16)| 45);
a.iter().map(|_: (u16, u16)| 45);
}
fn baz<F: Fn(*mut &u32)>(_: F) {}
fn _test<'a>(f: fn(*mut &'a u32)) {
baz(f);
}

45
src/test/ui/mismatched_types/closure-arg-type-mismatch.stderr Normal file
View file

@ -0,0 +1,45 @@
error[E0631]: type mismatch in closure arguments
--> $DIR/closure-arg-type-mismatch.rs:13:14
|
13 | a.iter().map(|_: (u32, u32)| 45);
| ^^^ ------------------ found signature of `fn((u32, u32)) -> _`
| |
| expected signature of `fn(&(u32, u32)) -> _`
error[E0631]: type mismatch in closure arguments
--> $DIR/closure-arg-type-mismatch.rs:14:14
|
14 | a.iter().map(|_: &(u16, u16)| 45);
| ^^^ ------------------- found signature of `for<'r> fn(&'r (u16, u16)) -> _`
| |
| expected signature of `fn(&(u32, u32)) -> _`
error[E0631]: type mismatch in closure arguments
--> $DIR/closure-arg-type-mismatch.rs:15:14
|
15 | a.iter().map(|_: (u16, u16)| 45);
| ^^^ ------------------ found signature of `fn((u16, u16)) -> _`
| |
| expected signature of `fn(&(u32, u32)) -> _`
error[E0631]: type mismatch in function arguments
--> $DIR/closure-arg-type-mismatch.rs:20:5
|
20 | baz(f);
| ^^^
| |
| expected signature of `for<'r> fn(*mut &'r u32) -> _`
| found signature of `fn(*mut &'a u32) -> _`
|
= note: required by `baz`
error[E0271]: type mismatch resolving `for<'r> <fn(*mut &'a u32) as std::ops::FnOnce<(*mut &'r u32,)>>::Output == ()`
--> $DIR/closure-arg-type-mismatch.rs:20:5
|
20 | baz(f);
| ^^^ expected bound lifetime parameter, found concrete lifetime
|
= note: required by `baz`
error: aborting due to 5 previous errors

7
src/test/ui/mismatched_types/closure-mismatch.stderr
View file

@ -7,14 +7,13 @@ error[E0271]: type mismatch resolving `for<'r> <[closure@$DIR/closure-mismatch.r
= note: required because of the requirements on the impl of `Foo` for `[closure@$DIR/closure-mismatch.rs:18:9: 18:15]`
= note: required by `baz`
error[E0281]: type mismatch: `[closure@$DIR/closure-mismatch.rs:18:9: 18:15]` implements the trait `std::ops::Fn<(_,)>`, but the trait `for<'r> std::ops::Fn<(&'r (),)>` is required
error[E0631]: type mismatch in closure arguments
--> $DIR/closure-mismatch.rs:18:5
|
18 | baz(|_| ());
| ^^^ ------ implements `std::ops::Fn<(_,)>`
| ^^^ ------ found signature of `fn(_) -> _`
| |
| expected concrete lifetime, found bound lifetime parameter
| requires `for<'r> std::ops::Fn<(&'r (),)>`
| expected signature of `for<'r> fn(&'r ()) -> _`
|
= note: required because of the requirements on the impl of `Foo` for `[closure@$DIR/closure-mismatch.rs:18:9: 18:15]`
= note: required by `baz`

14
src/test/ui/mismatched_types/fn-variance-1.stderr
View file

@ -1,16 +1,22 @@
error[E0281]: type mismatch: `fn(&mut isize) {takes_mut}` implements the trait `for<'r> std::ops::FnOnce<(&'r mut isize,)>`, but the trait `std::ops::FnOnce<(&{integer},)>` is required
error[E0631]: type mismatch in function arguments
--> $DIR/fn-variance-1.rs:21:5
|
21 | apply(&3, takes_mut);
| ^^^^^ types differ in mutability
| ^^^^^
| |
| expected signature of `fn(&{integer}) -> _`
| found signature of `for<'r> fn(&'r mut isize) -> _`
|
= note: required by `apply`
error[E0281]: type mismatch: `fn(&isize) {takes_imm}` implements the trait `for<'r> std::ops::FnOnce<(&'r isize,)>`, but the trait `std::ops::FnOnce<(&mut {integer},)>` is required
error[E0631]: type mismatch in function arguments
--> $DIR/fn-variance-1.rs:27:5
|
27 | apply(&mut 3, takes_imm);
| ^^^^^ types differ in mutability
| ^^^^^
| |
| expected signature of `fn(&mut {integer}) -> _`
| found signature of `for<'r> fn(&'r isize) -> _`
|
= note: required by `apply`

7
src/test/ui/mismatched_types/issue-36053-2.stderr
View file

@ -8,14 +8,13 @@ error[E0599]: no method named `count` found for type `std::iter::Filter<std::ite
`std::iter::Filter<std::iter::Fuse<std::iter::Once<&str>>, [closure@$DIR/issue-36053-2.rs:17:39: 17:53]> : std::iter::Iterator`
`&mut std::iter::Filter<std::iter::Fuse<std::iter::Once<&str>>, [closure@$DIR/issue-36053-2.rs:17:39: 17:53]> : std::iter::Iterator`
error[E0281]: type mismatch: `[closure@$DIR/issue-36053-2.rs:17:39: 17:53]` implements the trait `for<'r> std::ops::FnMut<(&'r str,)>`, but the trait `for<'r> std::ops::FnMut<(&'r &str,)>` is required
error[E0631]: type mismatch in closure arguments
--> $DIR/issue-36053-2.rs:17:32
|
17 | once::<&str>("str").fuse().filter(|a: &str| true).count();
| ^^^^^^ -------------- implements `for<'r> std::ops::FnMut<(&'r str,)>`
| ^^^^^^ -------------- found signature of `for<'r> fn(&'r str) -> _`
| |
| expected &str, found str
| requires `for<'r> std::ops::FnMut<(&'r &str,)>`
| expected signature of `for<'r> fn(&'r &str) -> _`
error: aborting due to 2 previous errors

9
src/test/ui/mismatched_types/unboxed-closures-vtable-mismatch.stderr
View file

@ -1,14 +1,11 @@
error[E0281]: type mismatch: `[closure@$DIR/unboxed-closures-vtable-mismatch.rs:22:23: 22:73]` implements the trait `std::ops::FnMut<(usize, isize)>`, but the trait `std::ops::FnMut<(isize, isize)>` is required
error[E0631]: type mismatch in closure arguments
--> $DIR/unboxed-closures-vtable-mismatch.rs:25:13
|
22 | let f = to_fn_mut(|x: usize, y: isize| -> isize { (x as isize) + y });
| -------------------------------------------------- implements `std::ops::FnMut<(usize, isize)>`
| -------------------------------------------------- found signature of `fn(usize, isize) -> _`
...
25 | let z = call_it(3, f);
| ^^^^^^^
| |
| expected isize, found usize
| requires `std::ops::FnMut<(isize, isize)>`
| ^^^^^^^ expected signature of `fn(isize, isize) -> _`
|
= note: required by `call_it`