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

Point at expressions where inference refines an unexpected type

Browse source 
Address #106355.
This commit is contained in:
Esteban Küber 2023-01-02 16:23:08 -08:00
parent 1d284af117
commit ea43eb3721
24 changed files with 299 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/test/ui/argument-suggestions/two-mismatch-notes.stderr
View file

@ -1,6 +1,8 @@
error[E0308]: arguments to this function are incorrect
--> $DIR/two-mismatch-notes.rs:10:5
|
LL | let w = Wrapper::<isize>(1isize);
| ------------------------ here the type of `w` is inferred to be `Wrapper<isize>`
LL | foo(f, w);
| ^^^
|

2
src/test/ui/async-await/dont-suggest-missing-await.stderr
View file

@ -1,6 +1,8 @@
error[E0308]: mismatched types
--> $DIR/dont-suggest-missing-await.rs:14:18
|
LL | let x = make_u32();
| ---------- here the type of `x` is inferred to be `impl Future<Output = u32>`
LL | take_u32(x)
| -------- ^ expected `u32`, found opaque type
| |

2
src/test/ui/async-await/suggest-missing-await-closure.stderr
View file

@ -1,6 +1,8 @@
error[E0308]: mismatched types
--> $DIR/suggest-missing-await-closure.rs:16:18
|
LL | let x = make_u32();
| ---------- here the type of `x` is inferred to be `impl Future<Output = u32>`
LL | take_u32(x)
| -------- ^ expected `u32`, found opaque type
| |

2
src/test/ui/async-await/suggest-missing-await.stderr
View file

@ -1,6 +1,8 @@
error[E0308]: mismatched types
--> $DIR/suggest-missing-await.rs:12:14
|
LL | let x = make_u32();
| ---------- here the type of `x` is inferred to be `impl Future<Output = u32>`
LL | take_u32(x)
| -------- ^ expected `u32`, found opaque type
| |

2
src/test/ui/closures/closure-return-type-mismatch.stderr
View file

@ -1,6 +1,8 @@
error[E0308]: mismatched types
--> $DIR/closure-return-type-mismatch.rs:7:9
|
LL | let a = true;
| ---- here the type of `a` is inferred to be `bool`
LL | a
| ^ expected `&str`, found `bool`
|

9
src/test/ui/coercion/coerce-to-bang.stderr
View file

@ -33,6 +33,9 @@ LL | fn foo(x: usize, y: !, z: usize) { }
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:26:12
|
LL | let b = 22;
| -- here the type of `b` is inferred to be `{integer}`
LL | let c = 44;
LL | foo(a, b, c); // ... and hence a reference to `a` is expected to diverge.
| --- ^ expected `!`, found integer
| |
@ -49,6 +52,9 @@ LL | fn foo(x: usize, y: !, z: usize) { }
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:36:12
|
LL | let b = 22;
| -- here the type of `b` is inferred to be `{integer}`
LL | let c = 44;
LL | foo(a, b, c);
| --- ^ expected `!`, found integer
| |
@ -65,6 +71,9 @@ LL | fn foo(x: usize, y: !, z: usize) { }
error[E0308]: mismatched types
--> $DIR/coerce-to-bang.rs:45:12
|
LL | let b = 22;
| -- here the type of `b` is inferred to be `{integer}`
LL | let c = 44;
LL | foo(a, b, c);
| --- ^ expected `!`, found integer
| |

3
src/test/ui/generic-associated-types/collections-project-default.stderr
View file

@ -4,6 +4,9 @@ error[E0308]: mismatched types
LL | fn floatify_sibling<C>(ints: &C) -> <C as Collection<i32>>::Sibling<f32>
| ------------------------------------ expected `<C as Collection<i32>>::Sibling<f32>` because of return type
...
LL | let mut res = <C::Family as CollectionFamily>::Member::<f32>::empty();
| ------------------------------------------------------- here the type of `res` is inferred to be `<<C as Collection<i32>>::Family as CollectionFamily>::Member<f32>`
...
LL | res
| ^^^ expected Collection::Sibling, found CollectionFamily::Member
|

2
src/test/ui/issues/issue-15783.stderr
View file

@ -1,6 +1,8 @@
error[E0308]: mismatched types
--> $DIR/issue-15783.rs:8:19
|
LL | let x = Some(&[name]);
| ------------- here the type of `x` is inferred to be `Option<_>`
LL | let msg = foo(x);
| --- ^ expected slice `[&str]`, found array `[&str; 1]`
| |

12
src/test/ui/let-else/let-else-ref-bindings.stderr
View file

@ -19,6 +19,12 @@ LL | let Some(ref a): Option<&[u8]> = &some else { return };
error[E0308]: mismatched types
--> $DIR/let-else-ref-bindings.rs:24:34
|
LL | let some = Some(bytes);
| ----------- here the type of `some` is inferred to be `Option<_>`
...
LL | let Some(ref a): Option<&[u8]> = some else { return };
| ---- here the type of `some` is inferred to be `Option<Vec<u8>>`
...
LL | let Some(a): Option<&[u8]> = some else { return };
| ------------- ^^^^ expected `&[u8]`, found struct `Vec`
| |
@ -59,6 +65,12 @@ LL | let Some(ref mut a): Option<&mut [u8]> = &mut some else { return };
error[E0308]: mismatched types
--> $DIR/let-else-ref-bindings.rs:52:38
|
LL | let mut some = Some(bytes);
| ----------- here the type of `some` is inferred to be `Option<_>`
...
LL | let Some(ref mut a): Option<&mut [u8]> = some else { return };
| ---- here the type of `some` is inferred to be `Option<Vec<u8>>`
...
LL | let Some(a): Option<&mut [u8]> = some else { return };
| ----------------- ^^^^ expected `&mut [u8]`, found struct `Vec`
| |

15
src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr
View file

@ -10,6 +10,9 @@ LL | #![feature(unsized_locals, unsized_fn_params)]
error[E0308]: mismatched types
--> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:87:24
|
LL | let z = x.foo();
| ------- here the type of `z` is inferred to be `u32`
...
LL | let _seetype: () = z;
| -- ^ expected `()`, found `u32`
| |
@ -18,6 +21,9 @@ LL | let _seetype: () = z;
error[E0308]: mismatched types
--> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:104:24
|
LL | let z = x.foo();
| ------- here the type of `z` is inferred to be `u64`
...
LL | let _seetype: () = z;
| -- ^ expected `()`, found `u64`
| |
@ -60,6 +66,9 @@ LL | let z = FinalFoo::foo(x);
error[E0308]: mismatched types
--> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:139:24
|
LL | let z = x.foo();
| ------- here the type of `z` is inferred to be `u8`
...
LL | let _seetype: () = z;
| -- ^ expected `()`, found `u8`
| |
@ -68,6 +77,9 @@ LL | let _seetype: () = z;
error[E0308]: mismatched types
--> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:157:24
|
LL | let z = x.foo();
| ------- here the type of `z` is inferred to be `u32`
...
LL | let _seetype: () = z;
| -- ^ expected `()`, found `u32`
| |
@ -76,6 +88,9 @@ LL | let _seetype: () = z;
error[E0308]: mismatched types
--> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:174:24
|
LL | let z = x.foo();
| ------- here the type of `z` is inferred to be `u32`
...
LL | let _seetype: () = z;
| -- ^ expected `()`, found `u32`
| |

36
src/test/ui/mismatched_types/abridged.stderr
View file

@ -53,11 +53,19 @@ LL | Ok(Foo { bar: 1 })
error[E0308]: mismatched types
--> $DIR/abridged.rs:39:5
|
LL | fn d() -> X<X<String, String>, String> {
| ---------------------------- expected `X<X<String, String>, String>` because of return type
...
LL | x
| ^ expected struct `String`, found integer
LL | fn d() -> X<X<String, String>, String> {
| ---------------------------- expected `X<X<String, String>, String>` because of return type
LL | let x = X {
| _____________-
LL | | x: X {
LL | | x: "".to_string(),
LL | | y: 2,
LL | | },
LL | | y: 3,
LL | | };
| |_____- here the type of `x` is inferred to be `X<_, _>`
LL | x
| ^ expected struct `String`, found integer
|
= note: expected struct `X<X<_, String>, String>`
found struct `X<X<_, {integer}>, {integer}>`
@ -65,11 +73,19 @@ LL | x
error[E0308]: mismatched types
--> $DIR/abridged.rs:50:5
|
LL | fn e() -> X<X<String, String>, String> {
| ---------------------------- expected `X<X<String, String>, String>` because of return type
...
LL | x
| ^ expected struct `String`, found integer
LL | fn e() -> X<X<String, String>, String> {
| ---------------------------- expected `X<X<String, String>, String>` because of return type
LL | let x = X {
| _____________-
LL | | x: X {
LL | | x: "".to_string(),
LL | | y: 2,
LL | | },
LL | | y: "".to_string(),
LL | | };
| |_____- here the type of `x` is inferred to be `X<_, _>`
LL | x
| ^ expected struct `String`, found integer
|
= note: expected struct `X<X<_, String>, _>`
found struct `X<X<_, {integer}>, _>`

2
src/test/ui/parser/struct-literal-variant-in-if.stderr
View file

@ -51,6 +51,8 @@ LL | if x == E::V { field } {}
error[E0308]: mismatched types
--> $DIR/struct-literal-variant-in-if.rs:10:20
|
LL | let field = true;
| ---- here the type of `field` is inferred to be `bool`
LL | if x == E::V { field } {}
| ---------------^^^^^--
| | |

12
src/test/ui/rfc-2497-if-let-chains/ensure-that-let-else-does-not-interact-with-let-chains.stderr
View file

@ -100,6 +100,12 @@ LL | let Some(n) = opt && let another = n else {
error[E0308]: mismatched types
--> $DIR/ensure-that-let-else-does-not-interact-with-let-chains.rs:9:19
|
LL | let opt = Some(1i32);
| ---------- here the type of `opt` is inferred to be `Option<_>`
LL |
LL | let Some(n) = opt else {
| --- here the type of `opt` is inferred to be `Option<i32>`
...
LL | let Some(n) = opt && n == 1 else {
| ^^^ expected `bool`, found enum `Option`
|
@ -120,6 +126,12 @@ LL | let Some(n) = opt && n == 1 else {
error[E0308]: mismatched types
--> $DIR/ensure-that-let-else-does-not-interact-with-let-chains.rs:15:19
|
LL | let opt = Some(1i32);
| ---------- here the type of `opt` is inferred to be `Option<_>`
LL |
LL | let Some(n) = opt else {
| --- here the type of `opt` is inferred to be `Option<i32>`
...
LL | let Some(n) = opt && let another = n else {
| ^^^ expected `bool`, found enum `Option`
|

5
src/test/ui/span/coerce-suggestions.stderr
View file

@ -63,7 +63,10 @@ error[E0308]: mismatched types
--> $DIR/coerce-suggestions.rs:21:9
|
LL | s = format!("foo");
| ^^^^^^^^^^^^^^ expected `&mut String`, found struct `String`
| ^^^^^^^^^^^^^^
| |
| expected `&mut String`, found struct `String`
| here the type of `res` is inferred to be `String`
|
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)

5
src/test/ui/span/issue-33884.stderr
View file

@ -2,7 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-33884.rs:6:22
|
LL | stream.write_fmt(format!("message received"))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `Arguments`, found struct `String`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| expected struct `Arguments`, found struct `String`
| here the type of `res` is inferred to be `String`
|
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)

2
src/test/ui/structs/struct-base-wrong-type.stderr
View file

@ -13,6 +13,8 @@ LL | static foo_i: Foo = Foo { a: 2, ..4 };
error[E0308]: mismatched types
--> $DIR/struct-base-wrong-type.rs:12:27
|
LL | let b = Bar { x: 5 };
| ------------ here the type of `b` is inferred to be `Bar`
LL | let f = Foo { a: 2, ..b };
| ^ expected struct `Foo`, found struct `Bar`

5
src/test/ui/suggestions/call-boxed.stderr
View file

@ -4,7 +4,10 @@ error[E0308]: mismatched types
LL | let mut x = 1i32;
| ---- expected due to this value
LL | let y = Box::new(|| 1);
| -- the found closure
| --------------
| | |
| | the found closure
| here the type of `y` is inferred to be `Box<_>`
LL | x = y;
| ^ expected `i32`, found struct `Box`
|

5
src/test/ui/suggestions/dont-suggest-deref-inside-macro-issue-58298.stderr
View file

@ -4,7 +4,10 @@ error[E0308]: mismatched types
LL | / intrinsic_match! {
LL | | "abc"
LL | | };
| |_____^ expected `&str`, found struct `String`
| | ^
| | |
| |_____expected `&str`, found struct `String`
| here the type of `res` is inferred to be `String`
|
= note: this error originates in the macro `format` which comes from the expansion of the macro `intrinsic_match` (in Nightly builds, run with -Z macro-backtrace for more info)

2
src/test/ui/suggestions/issue-86100-tuple-paren-comma.stderr
View file

@ -49,6 +49,8 @@ LL | let _s = S { _s: ("abc".to_string(),) };
error[E0308]: mismatched types
--> $DIR/issue-86100-tuple-paren-comma.rs:23:22
|
LL | let t = (1, 2);
| ------ here the type of `t` is inferred to be `({integer}, {integer})`
LL | let _x: (i32,) = (t);
| ------ ^^^ expected a tuple with 1 element, found one with 2 elements
| |

2
src/test/ui/traits/issue-52893.stderr
View file

@ -4,6 +4,8 @@ error[E0308]: mismatched types
LL | impl<F, Name, P> AddClass<Name, F> for Class<P>
| - this type parameter
...
LL | let output = builder.to_ref();
| ---------------- here the type of `output` is inferred to be `Class<P>`
LL | builder.push(output);
| ---- ^^^^^^ expected type parameter `F`, found struct `Class`
| |

3
src/test/ui/tuple/wrong_argument_ice-3.stderr
View file

@ -1,6 +1,9 @@
error[E0061]: this method takes 1 argument but 2 arguments were supplied
--> $DIR/wrong_argument_ice-3.rs:9:16
|
LL | let new_group = vec![String::new()];
| ------------------- here the type of `new_group` is inferred to be `Vec<_, _>`
...
LL | groups.push(new_group, vec![process]);
| ^^^^ ------------- argument of type `Vec<&Process>` unexpected
|

18
src/test/ui/type/type-check/assignment-in-if.stderr
View file

@ -67,6 +67,12 @@ LL | x == 5
error[E0308]: mismatched types
--> $DIR/assignment-in-if.rs:44:18
|
LL | let x = 1;
| - here the type of `x` is inferred to be `{integer}`
...
LL | println!("{}", x);
| - here the type of `x` is inferred to be `usize`
...
LL | if x == x && x = x && x == x {
| ------ ^ expected `bool`, found `usize`
| |
@ -75,6 +81,12 @@ LL | if x == x && x = x && x == x {
error[E0308]: mismatched types
--> $DIR/assignment-in-if.rs:44:22
|
LL | let x = 1;
| - here the type of `x` is inferred to be `{integer}`
...
LL | println!("{}", x);
| - here the type of `x` is inferred to be `usize`
...
LL | if x == x && x = x && x == x {
| ^ expected `bool`, found `usize`
@ -92,6 +104,12 @@ LL | if x == x && x == x && x == x {
error[E0308]: mismatched types
--> $DIR/assignment-in-if.rs:51:28
|
LL | let x = 1;
| - here the type of `x` is inferred to be `{integer}`
...
LL | println!("{}", x);
| - here the type of `x` is inferred to be `usize`
...
LL | if x == x && x == x && x = x {
| ---------------- ^ expected `bool`, found `usize`
| |

6
src/test/ui/type/type-mismatch-same-crate-name.stderr
View file

@ -1,6 +1,9 @@
error[E0308]: mismatched types
--> $DIR/type-mismatch-same-crate-name.rs:16:20
|
LL | let foo2 = {extern crate crate_a2 as a; a::Foo};
| ------------------------------------ here the type of `foo2` is inferred to be `_`
...
LL | a::try_foo(foo2);
| ---------- ^^^^ expected struct `main::a::Foo`, found a different struct `main::a::Foo`
| |
@ -27,6 +30,9 @@ LL | pub fn try_foo(x: Foo){}
error[E0308]: mismatched types
--> $DIR/type-mismatch-same-crate-name.rs:20:20
|
LL | let bar2 = {extern crate crate_a2 as a; a::bar()};
| -------------------------------------- here the type of `bar2` is inferred to be `_`
...
LL | a::try_bar(bar2);
| ---------- ^^^^ expected trait `main::a::Bar`, found a different trait `main::a::Bar`
| |