nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-06-05 03:38:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

review comments: do not always point at init expr

Browse Source
This commit is contained in:
Esteban Küber 2023-01-02 23:34:26 -08:00
parent 48094a4a6f
commit 6b0cce4b50
20 changed files with 14 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
compiler/rustc_hir_typeck/src/demand.rs
View File

@ -355,6 +355,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
}
}
if span_labels.len() < 2 {
return false;
}
for (sp, label) in span_labels {
err.span_label(sp, &label);
}

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

@ -1,8 +1,6 @@
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,8 +1,6 @@
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,8 +1,6 @@
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,8 +1,6 @@
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,8 +1,6 @@
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,9 +33,6 @@ 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
| |
@ -52,9 +49,6 @@ 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
| |
@ -71,9 +65,6 @@ 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,9 +4,6 @@ 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,8 +1,6 @@
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<&[&str; 1]>`
LL | let msg = foo(x);
| --- ^ expected slice `[&str]`, found array `[&str; 1]`
| |

6
src/test/ui/let-else/let-else-ref-bindings.stderr
View File

@ -19,9 +19,6 @@ 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<Vec<u8>>`
...
LL | let Some(a): Option<&[u8]> = some else { return };
| ------------- ^^^^ expected `&[u8]`, found struct `Vec`
| |
@ -62,9 +59,6 @@ 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<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,9 +10,6 @@ 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`
| |
@ -21,9 +18,6 @@ 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`
| |
@ -66,9 +60,6 @@ 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`
| |
@ -77,9 +68,6 @@ 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`
| |
@ -88,9 +76,6 @@ 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,19 +53,11 @@ 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 | 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<X<String, {integer}>, {integer}>`
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 | x
| ^ expected struct `String`, found integer
|
= note: expected struct `X<X<_, String>, String>`
found struct `X<X<_, {integer}>, {integer}>`
@ -73,19 +65,11 @@ 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 | 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<X<String, {integer}>, String>`
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 | 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,8 +51,6 @@ 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 } {}
| ---------------^^^^^--
| | |

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

@ -100,9 +100,6 @@ 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<i32>`
...
LL | let Some(n) = opt && n == 1 else {
| ^^^ expected `bool`, found enum `Option`
|
@ -123,9 +120,6 @@ 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<i32>`
...
LL | let Some(n) = opt && let another = n else {
| ^^^ expected `bool`, found enum `Option`
|

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

@ -13,8 +13,6 @@ 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,10 +4,7 @@ error[E0308]: mismatched types
LL | let mut x = 1i32;
| ---- expected due to this value
LL | let y = Box::new(|| 1);
| --------------
| | |
| | the found closure
| here the type of `y` is inferred to be `Box<[closure@call-boxed.rs:3:22]>`
| -- the found closure
LL | x = y;
| ^ expected `i32`, found struct `Box`
|

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

@ -49,8 +49,6 @@ 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,8 +4,6 @@ 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,9 +1,6 @@
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<String>`
...
LL | groups.push(new_group, vec![process]);
| ^^^^ ------------- argument of type `Vec<&Process>` unexpected
|

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

@ -1,9 +1,6 @@
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 `Foo`
...
LL | a::try_foo(foo2);
| ---------- ^^^^ expected struct `main::a::Foo`, found a different struct `main::a::Foo`
| |
@ -30,9 +27,6 @@ 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 `Box<dyn Bar>`
...
LL | a::try_bar(bar2);
| ---------- ^^^^ expected trait `main::a::Bar`, found a different trait `main::a::Bar`
| |