bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Resolve vars in note_type_err

Browse source
This commit is contained in:
Jack Huey 2022-04-17 15:00:32 -04:00
parent 1549576732
commit 62d0e4cba9
30 changed files with 146 additions and 138 deletions
Download patch file Download diff file Expand all files Collapse all files

7
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View file

@ -1584,9 +1584,10 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
Variable(ty::error::ExpectedFound<Ty<'a>>),
Fixed(&'static str),
}
let (expected_found, exp_found, is_simple_error) = match values {
None => (None, Mismatch::Fixed("type"), false),
let (expected_found, exp_found, is_simple_error, values) = match values {
None => (None, Mismatch::Fixed("type"), false, None),
Some(values) => {
let values = self.resolve_vars_if_possible(values);
let (is_simple_error, exp_found) = match values {
ValuePairs::Terms(infer::ExpectedFound {
expected: ty::Term::Ty(expected),
@ -1614,7 +1615,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
return;
}
};
(vals, exp_found, is_simple_error)
(vals, exp_found, is_simple_error, Some(values))
}
};

14
compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
View file

@ -394,6 +394,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
break 'errors;
}
self.set_tainted_by_errors();
// The algorithm here is inspired by levenshtein distance and longest common subsequence.
// We'll try to detect 4 different types of mistakes:
// - An extra parameter has been provided that doesn't satisfy *any* of the other inputs
@ -569,7 +571,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.emit_coerce_suggestions(
&mut err,
&provided_args[*input_idx],
final_arg_types[*input_idx].map(|ty| ty.0).unwrap(),
provided_ty,
final_arg_types[*input_idx].map(|ty| ty.1).unwrap(),
None,
None,
@ -627,12 +629,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
match error {
Error::Invalid(input_idx, compatibility) => {
let expected_ty = expected_input_tys[input_idx];
let provided_ty = final_arg_types
.get(input_idx)
.and_then(|x| x.as_ref())
.map(|ty| ty.0)
.unwrap_or(tcx.ty_error());
if let Compatibility::Incompatible(error) = &compatibility {
let provided_ty = final_arg_types
.get(input_idx)
.and_then(|x| x.as_ref())
.map(|ty| ty.0)
.unwrap_or(tcx.ty_error());
let cause = &self.misc(
provided_args.get(input_idx).map(|i| i.span).unwrap_or(call_span),
);

4
src/test/ui/associated-types/associated-types-issue-20346.stderr
View file

@ -12,8 +12,8 @@ note: expected this to be `Option<T>`
|
LL | type Item = T;
| ^
= note: expected enum `Option<T>`
found type `T`
= note: expected enum `Option<T>`
found type parameter `T`
note: required by a bound in `is_iterator_of`
--> $DIR/associated-types-issue-20346.rs:15:34
|

2
src/test/ui/associated-types/higher-ranked-projection.bad.stderr
View file

@ -5,7 +5,7 @@ LL | foo(());
| ^^^ lifetime mismatch
|
= note: expected reference `&'a ()`
found type `&()`
found reference `&()`
note: the lifetime requirement is introduced here
--> $DIR/higher-ranked-projection.rs:15:33
|

27
src/test/ui/async-await/generator-desc.stderr
View file

@ -24,13 +24,18 @@ LL | fun(one(), two());
| |
| arguments to this function are incorrect
|
note: while checking the return type of the `async fn`
--> $DIR/generator-desc.rs:5:16
|
LL | async fn one() {}
| ^ checked the `Output` of this `async fn`, expected opaque type
note: while checking the return type of the `async fn`
--> $DIR/generator-desc.rs:6:16
|
LL | async fn two() {}
| ^ checked the `Output` of this `async fn`, found opaque type
= note: expected type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:5:16>)
found opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:6:16>)
= note: expected opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:5:16>)
found opaque type `impl Future<Output = ()>` (opaque type at <$DIR/generator-desc.rs:6:16>)
= help: consider `await`ing on both `Future`s
= note: distinct uses of `impl Trait` result in different opaque types
note: function defined here
@ -43,26 +48,26 @@ error[E0308]: mismatched types
--> $DIR/generator-desc.rs:14:26
|
LL | fun((async || {})(), (async || {})());
| --- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body
| |
| --- -- ^^^^^^^^^^^^^^^ expected `async` closure body, found a different `async` closure body
| | |
| | the expected `async` closure body
| arguments to this function are incorrect
|
::: $SRC_DIR/core/src/future/mod.rs:LL:COL
|
LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
| ------------------------------- the found opaque type
| -------------------------------
| |
| the expected opaque type
| the found opaque type
|
= note: expected type `impl Future<Output = ()>` (`async` closure body)
found opaque type `impl Future<Output = ()>` (`async` closure body)
= note: expected opaque type `impl Future<Output = ()>` (`async` closure body)
found opaque type `impl Future<Output = ()>` (`async` closure body)
note: function defined here
--> $DIR/generator-desc.rs:8:4
|
LL | fn fun<F: Future<Output = ()>>(f1: F, f2: F) {}
| ^^^ ----- -----
help: consider `await`ing on the `Future`
|
LL | fun((async || {})(), (async || {})().await);
| ++++++
error: aborting due to 3 previous errors

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

@ -60,8 +60,13 @@ LL | |
LL | | };
| |_____- `if` and `else` have incompatible types
|
= note: expected type `impl Future<Output = ()>`
found unit type `()`
note: while checking the return type of the `async fn`
--> $DIR/suggest-missing-await.rs:18:18
|
LL | async fn dummy() {}
| ^ checked the `Output` of this `async fn`, expected opaque type
= note: expected opaque type `impl Future<Output = ()>`
found unit type `()`
help: consider `await`ing on the `Future`
|
LL | dummy().await

22
src/test/ui/borrowck/suggest-local-var-imm-and-mut.nll.stderr
View file

@ -1,22 +0,0 @@
error[E0502]: cannot borrow `*self` as mutable because it is also borrowed as immutable
--> $DIR/suggest-local-var-imm-and-mut.rs:12:22
|
LL | self.foo(self.bar());
| ---------^^^^^^^^^^-
| | | |
| | | mutable borrow occurs here
| | immutable borrow later used by call
| immutable borrow occurs here
error[E0502]: cannot borrow `*self` as mutable because it is also borrowed as immutable
--> $DIR/suggest-local-var-imm-and-mut.rs:24:29
|
LL | Self::foo(self, Self::bar(self));
| --------- ---- ^^^^^^^^^^^^^^^ mutable borrow occurs here
| | |
| | immutable borrow occurs here
| immutable borrow later used by call
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0502`.

31
src/test/ui/closures/closure_cap_coerce_many_fail.stderr
View file

@ -11,8 +11,8 @@ LL | | _ => unimplemented!(),
LL | | };
| |_____- `match` arms have incompatible types
|
= note: expected type `fn(i32, i32) -> i32 {add}`
found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:9:16: 9:43]`
= note: expected fn item `fn(i32, i32) -> i32 {add}`
found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:9:16: 9:43]`
error[E0308]: `match` arms have incompatible types
--> $DIR/closure_cap_coerce_many_fail.rs:18:16
@ -20,15 +20,18 @@ error[E0308]: `match` arms have incompatible types
LL | let _ = match "+" {
| _____________-
LL | | "+" => |a, b| (a + b) as i32,
| | --------------------- this is found to be of type `[closure@$DIR/closure_cap_coerce_many_fail.rs:17:16: 17:37]`
| | ---------------------
| | |
| | the expected closure
| | this is found to be of type `[closure@$DIR/closure_cap_coerce_many_fail.rs:17:16: 17:37]`
LL | | "-" => |a, b| (a - b + cap) as i32,
| | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected closure, found a different closure
LL | | _ => unimplemented!(),
LL | | };
| |_____- `match` arms have incompatible types
|
= note: expected type `[closure@$DIR/closure_cap_coerce_many_fail.rs:17:16: 17:37]`
found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:18:16: 18:43]`
= note: expected closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:17:16: 17:37]`
found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:18:16: 18:43]`
= note: no two closures, even if identical, have the same type
= help: consider boxing your closure and/or using it as a trait object
@ -38,15 +41,18 @@ error[E0308]: `match` arms have incompatible types
LL | let _ = match "+" {
| _____________-
LL | | "+" => |a, b| (a + b + cap) as i32,
| | --------------------------- this is found to be of type `[closure@$DIR/closure_cap_coerce_many_fail.rs:26:16: 26:43]`
| | ---------------------------
| | |
| | the expected closure
| | this is found to be of type `[closure@$DIR/closure_cap_coerce_many_fail.rs:26:16: 26:43]`
LL | | "-" => |a, b| (a - b) as i32,
| | ^^^^^^^^^^^^^^^^^^^^^ expected closure, found a different closure
LL | | _ => unimplemented!(),
LL | | };
| |_____- `match` arms have incompatible types
|
= note: expected type `[closure@$DIR/closure_cap_coerce_many_fail.rs:26:16: 26:43]`
found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:27:16: 27:37]`
= note: expected closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:26:16: 26:43]`
found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:27:16: 27:37]`
= note: no two closures, even if identical, have the same type
= help: consider boxing your closure and/or using it as a trait object
@ -56,15 +62,18 @@ error[E0308]: `match` arms have incompatible types
LL | let _ = match "+" {
| _____________-
LL | | "+" => |a, b| (a + b + cap) as i32,
| | --------------------------- this is found to be of type `[closure@$DIR/closure_cap_coerce_many_fail.rs:34:16: 34:43]`
| | ---------------------------
| | |
| | the expected closure
| | this is found to be of type `[closure@$DIR/closure_cap_coerce_many_fail.rs:34:16: 34:43]`
LL | | "-" => |a, b| (a - b + cap) as i32,
| | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected closure, found a different closure
LL | | _ => unimplemented!(),
LL | | };
| |_____- `match` arms have incompatible types
|
= note: expected type `[closure@$DIR/closure_cap_coerce_many_fail.rs:34:16: 34:43]`
found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:35:16: 35:43]`
= note: expected closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:34:16: 34:43]`
found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:35:16: 35:43]`
= note: no two closures, even if identical, have the same type
= help: consider boxing your closure and/or using it as a trait object

4
src/test/ui/coercion/coerce-reborrow-multi-arg-fail.stderr
View file

@ -6,8 +6,8 @@ LL | test(&mut 7, &7);
| |
| arguments to this function are incorrect
|
= note: expected type `&mut {integer}`
found reference `&{integer}`
= note: expected mutable reference `&mut {integer}`
found reference `&{integer}`
note: function defined here
--> $DIR/coerce-reborrow-multi-arg-fail.rs:1:4
|

4
src/test/ui/destructuring-assignment/default-match-bindings-forbidden.stderr
View file

@ -6,8 +6,8 @@ LL | (x, y) = &(1, 2);
| |
| expected reference, found tuple
|
= note: expected type `&({integer}, {integer})`
found tuple `(_, _)`
= note: expected reference `&({integer}, {integer})`
found tuple `(_, _)`
error: aborting due to previous error

8
src/test/ui/destructuring-assignment/tuple_destructure_fail.stderr
View file

@ -14,8 +14,8 @@ LL | (a, a, b) = (1, 2);
| |
| expected a tuple with 2 elements, found one with 3 elements
|
= note: expected type `({integer}, {integer})`
found tuple `(_, _, _)`
= note: expected tuple `({integer}, {integer})`
found tuple `(_, _, _)`
error[E0070]: invalid left-hand side of assignment
--> $DIR/tuple_destructure_fail.rs:7:13
@ -33,8 +33,8 @@ LL | (_,) = (1, 2);
| |
| expected a tuple with 2 elements, found one with 1 element
|
= note: expected type `({integer}, {integer})`
found tuple `(_,)`
= note: expected tuple `({integer}, {integer})`
found tuple `(_,)`
error: aborting due to 4 previous errors

13
src/test/ui/error-codes/E0502.nll.stderr
View file

@ -1,13 +0,0 @@
error[E0502]: cannot borrow `*a` as mutable because it is also borrowed as immutable
--> $DIR/E0502.rs:4:5
|
LL | let ref y = a;
| ----- immutable borrow occurs here
LL | bar(a);
| ^^^^^^ mutable borrow occurs here
LL | y.use_ref();
| ----------- immutable borrow later used here
error: aborting due to previous error
For more information about this error, try `rustc --explain E0502`.

4
src/test/ui/fn/fn-item-type.rs
View file

@ -12,7 +12,7 @@ impl<T> Foo for T { /* `foo` is still default here */ }
fn main() {
eq(foo::<u8>, bar::<u8>);
//~^ ERROR mismatched types
//~| expected type `fn(_) -> _ {foo::<u8>}`
//~| expected fn item `fn(_) -> _ {foo::<u8>}`
//~| found fn item `fn(_) -> _ {bar::<u8>}`
//~| expected fn item, found a different fn item
//~| different `fn` items always have unique types, even if their signatures are the same
@ -28,7 +28,6 @@ fn main() {
eq(bar::<String>, bar::<Vec<u8>>);
//~^ ERROR mismatched types
//~| expected type `fn(_) -> _ {bar::<String>}`
//~| found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
//~| expected struct `String`, found struct `Vec`
//~| different `fn` items always have unique types, even if their signatures are the same
@ -45,7 +44,6 @@ fn main() {
eq(foo::<u8>, bar::<u8> as fn(isize) -> isize);
//~^ ERROR mismatched types
//~| expected type `fn(_) -> _ {foo::<u8>}`
//~| found fn pointer `fn(_) -> _`
//~| expected fn item, found fn pointer
//~| change the expected type to be function pointer

22
src/test/ui/fn/fn-item-type.stderr
View file

@ -6,8 +6,8 @@ LL | eq(foo::<u8>, bar::<u8>);
| |
| arguments to this function are incorrect
|
= note: expected type `fn(_) -> _ {foo::<u8>}`
found fn item `fn(_) -> _ {bar::<u8>}`
= note: expected fn item `fn(_) -> _ {foo::<u8>}`
found fn item `fn(_) -> _ {bar::<u8>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`
@ -25,8 +25,8 @@ LL | eq(foo::<u8>, foo::<i8>);
| |
| arguments to this function are incorrect
|
= note: expected type `fn(_) -> _ {foo::<u8>}`
found fn item `fn(_) -> _ {foo::<i8>}`
= note: expected fn item `fn(_) -> _ {foo::<u8>}`
found fn item `fn(_) -> _ {foo::<i8>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`
@ -44,8 +44,8 @@ LL | eq(bar::<String>, bar::<Vec<u8>>);
| |
| arguments to this function are incorrect
|
= note: expected type `fn(_) -> _ {bar::<String>}`
found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
= note: expected fn item `fn(_) -> _ {bar::<String>}`
found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `bar::<String> as fn(isize) -> isize`
@ -56,15 +56,15 @@ LL | fn eq<T>(x: T, y: T) { }
| ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:39:26
--> $DIR/fn-item-type.rs:38:26
|
LL | eq(<u8 as Foo>::foo, <u16 as Foo>::foo);
| -- ^^^^^^^^^^^^^^^^^ expected `u8`, found `u16`
| |
| arguments to this function are incorrect
|
= note: expected type `fn() {<u8 as Foo>::foo}`
found fn item `fn() {<u16 as Foo>::foo}`
= note: expected fn item `fn() {<u8 as Foo>::foo}`
found fn item `fn() {<u16 as Foo>::foo}`
= note: different `fn` items always have unique types, even if their signatures are the same
= help: change the expected type to be function pointer `fn()`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `<u8 as Foo>::foo as fn()`
@ -75,14 +75,14 @@ LL | fn eq<T>(x: T, y: T) { }
| ^^ ---- ----
error[E0308]: mismatched types
--> $DIR/fn-item-type.rs:46:19
--> $DIR/fn-item-type.rs:45:19
|
LL | eq(foo::<u8>, bar::<u8> as fn(isize) -> isize);
| -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn item, found fn pointer
| |
| arguments to this function are incorrect
|
= note: expected type `fn(_) -> _ {foo::<u8>}`
= note: expected fn item `fn(_) -> _ {foo::<u8>}`
found fn pointer `fn(_) -> _`
= help: change the expected type to be function pointer `fn(isize) -> isize`
= help: if the expected type is due to type inference, cast the expected `fn` to a function pointer: `foo::<u8> as fn(isize) -> isize`

2
src/test/ui/generator/type-mismatch-signature-deduction.stderr
View file

@ -4,7 +4,7 @@ error[E0308]: mismatched types
LL | 5
| ^ expected enum `Result`, found integer
|
= note: expected type `Result<{integer}, _>`
= note: expected enum `Result<{integer}, _>`
found type `{integer}`
note: return type inferred to be `Result<{integer}, _>` here
--> $DIR/type-mismatch-signature-deduction.rs:9:20

8
src/test/ui/let-else/let-else-non-diverging.stderr
View file

@ -5,7 +5,7 @@ LL | let Some(x) = Some(1) else { Some(2) };
| ^^^^^^^^^^^ expected `!`, found enum `Option`
|
= note: expected type `!`
found type `Option<{integer}>`
found enum `Option<{integer}>`
= help: try adding a diverging expression, such as `return` or `panic!(..)`
= help: ...or use `match` instead of `let...else`
@ -20,8 +20,8 @@ LL | | }
LL | | };
| |_____^ expected `!`, found `()`
|
= note: expected type `!`
found type `()`
= note: expected type `!`
found unit type `()`
= help: try adding a diverging expression, such as `return` or `panic!(..)`
= help: ...or use `match` instead of `let...else`
@ -35,7 +35,7 @@ LL | | };
| |_____^ expected `!`, found enum `Option`
|
= note: expected type `!`
found type `Option<{integer}>`
found enum `Option<{integer}>`
= help: try adding a diverging expression, such as `return` or `panic!(..)`
= help: ...or use `match` instead of `let...else`

2
src/test/ui/or-patterns/already-bound-name.stderr
View file

@ -92,7 +92,7 @@ LL | let (B(A(a, _) | B(a)) | A(a, A(a, _) | B(a))) = B(B(1));
| first introduced with type `{integer}` here
|
= note: expected type `{integer}`
found type `E<{integer}>`
found enum `E<{integer}>`
= note: a binding must have the same type in all alternatives
error: aborting due to 15 previous errors

8
src/test/ui/or-patterns/inconsistent-modes.stderr
View file

@ -57,8 +57,8 @@ LL | let (Ok(ref a) | Err(ref mut a)): Result<&u8, &mut u8> = Ok(&0);
| | types differ in mutability
| first introduced with type `&&u8` here
|
= note: expected type `&&u8`
found type `&mut &mut u8`
= note: expected reference `&&u8`
found mutable reference `&mut &mut u8`
= note: a binding must have the same type in all alternatives
error[E0308]: mismatched types
@ -70,8 +70,8 @@ LL | let (Ok((ref a, b)) | Err((ref mut a, ref b))) = Ok((0, &0));
| | types differ in mutability
| first introduced with type `&{integer}` here
|
= note: expected type `&{integer}`
found type `&mut _`
= note: expected reference `&{integer}`
found mutable reference `&mut _`
= note: a binding must have the same type in all alternatives
error: aborting due to 9 previous errors

9
src/test/ui/parser/recover-range-pats.stderr
View file

@ -316,6 +316,9 @@ LL | if let X.. .0 = 0 {}
| | |
| | expected integer, found floating-point number
| this is of type `u8`
|
= note: expected type `u8`
found type `{float}`
error[E0029]: only `char` and numeric types are allowed in range patterns
--> $DIR/recover-range-pats.rs:33:12
@ -350,6 +353,9 @@ LL | if let X..=.0 = 0 {}
| | |
| | expected integer, found floating-point number
| this is of type `u8`
|
= note: expected type `u8`
found type `{float}`
error[E0029]: only `char` and numeric types are allowed in range patterns
--> $DIR/recover-range-pats.rs:54:12
@ -384,6 +390,9 @@ LL | if let X... .0 = 0 {}
| | |
| | expected integer, found floating-point number
| this is of type `u8`
|
= note: expected type `u8`
found type `{float}`
error[E0029]: only `char` and numeric types are allowed in range patterns
--> $DIR/recover-range-pats.rs:73:12

4
src/test/ui/reify-intrinsic.stderr
View file

@ -25,8 +25,8 @@ error[E0308]: cannot coerce intrinsics to function pointers
LL | std::intrinsics::unlikely,
| ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot coerce intrinsics to function pointers
|
= note: expected type `extern "rust-intrinsic" fn(_) -> _ {likely}`
found fn item `extern "rust-intrinsic" fn(_) -> _ {unlikely}`
= note: expected fn item `extern "rust-intrinsic" fn(_) -> _ {likely}`
found fn item `extern "rust-intrinsic" fn(_) -> _ {unlikely}`
error: aborting due to 3 previous errors

4
src/test/ui/resolve/resolve-inconsistent-binding-mode.stderr
View file

@ -54,8 +54,8 @@ LL | Opts::A(ref mut i) | Opts::B(ref i) => {}
| |
| first introduced with type `&mut isize` here
|
= note: expected type `&mut isize`
found type `&isize`
= note: expected mutable reference `&mut isize`
found reference `&isize`
= note: in the same arm, a binding must have the same type in all alternatives
error: aborting due to 6 previous errors

8
src/test/ui/rfc-2005-default-binding-mode/lit.stderr
View file

@ -6,8 +6,8 @@ LL | match &s {
LL | "abc" => true,
| ^^^^^ expected `&str`, found `str`
|
= note: expected type `&&str`
found reference `&'static str`
= note: expected reference `&&str`
found reference `&'static str`
error[E0308]: mismatched types
--> $DIR/lit.rs:16:9
@ -17,8 +17,8 @@ LL | match &s {
LL | b"abc" => true,
| ^^^^^^ expected `&[u8]`, found array `[u8; 3]`
|
= note: expected type `&&[u8]`
found reference `&'static [u8; 3]`
= note: expected reference `&&[u8]`
found reference `&'static [u8; 3]`
error: aborting due to 2 previous errors

4
src/test/ui/suggestions/issue-81839.stderr
View file

@ -19,8 +19,8 @@ note: while checking the return type of the `async fn`
|
LL | pub async fn answer_str(&self, _s: &str) -> Test {
| ^^^^ checked the `Output` of this `async fn`, found opaque type
= note: expected type `()`
found opaque type `impl Future<Output = Test>`
= note: expected unit type `()`
found opaque type `impl Future<Output = Test>`
error: aborting due to previous error

9
src/test/ui/suggestions/match-prev-arm-needing-semi.rs
View file

@ -16,6 +16,9 @@ fn extra_semicolon() {
async fn async_dummy() {} //~ NOTE checked the `Output` of this `async fn`, found opaque type
//~| NOTE while checking the return type of the `async fn`
//~| NOTE in this expansion of desugaring of `async` block or function
//~| NOTE checked the `Output` of this `async fn`, expected opaque type
//~| NOTE while checking the return type of the `async fn`
//~| NOTE in this expansion of desugaring of `async` block or function
async fn async_dummy2() {} //~ NOTE checked the `Output` of this `async fn`, found opaque type
//~| NOTE checked the `Output` of this `async fn`, found opaque type
//~| NOTE while checking the return type of the `async fn`
@ -31,7 +34,7 @@ async fn async_extra_semicolon_same() {
}
false => async_dummy(), //~ ERROR `match` arms have incompatible types
//~^ NOTE expected `()`, found opaque type
//~| NOTE expected type `()`
//~| NOTE expected unit type `()`
//~| HELP consider `await`ing on the `Future`
};
}
@ -44,7 +47,7 @@ async fn async_extra_semicolon_different() {
}
false => async_dummy2(), //~ ERROR `match` arms have incompatible types
//~^ NOTE expected `()`, found opaque type
//~| NOTE expected type `()`
//~| NOTE expected unit type `()`
//~| HELP consider `await`ing on the `Future`
};
}
@ -55,7 +58,7 @@ async fn async_different_futures() {
//~| HELP consider `await`ing on both `Future`s
false => async_dummy2(), //~ ERROR `match` arms have incompatible types
//~^ NOTE expected opaque type, found a different opaque type
//~| NOTE expected type `impl Future<Output = ()>`
//~| NOTE expected opaque type `impl Future<Output = ()>`
//~| NOTE distinct uses of `impl Trait` result in different opaque types
};
}

27
src/test/ui/suggestions/match-prev-arm-needing-semi.stderr
View file

@ -1,5 +1,5 @@
error[E0308]: `match` arms have incompatible types
--> $DIR/match-prev-arm-needing-semi.rs:32:18
--> $DIR/match-prev-arm-needing-semi.rs:35:18
|
LL | let _ = match true {
| _____________-
@ -20,8 +20,8 @@ note: while checking the return type of the `async fn`
|
LL | async fn async_dummy() {}
| ^ checked the `Output` of this `async fn`, found opaque type
= note: expected type `()`
found opaque type `impl Future<Output = ()>`
= note: expected unit type `()`
found opaque type `impl Future<Output = ()>`
help: consider `await`ing on the `Future`
|
LL | false => async_dummy().await,
@ -33,7 +33,7 @@ LL + async_dummy()
|
error[E0308]: `match` arms have incompatible types
--> $DIR/match-prev-arm-needing-semi.rs:45:18
--> $DIR/match-prev-arm-needing-semi.rs:48:18
|
LL | let _ = match true {
| _____________-
@ -50,12 +50,12 @@ LL | | };
| |_____- `match` arms have incompatible types
|
note: while checking the return type of the `async fn`
--> $DIR/match-prev-arm-needing-semi.rs:19:25
--> $DIR/match-prev-arm-needing-semi.rs:22:25
|
LL | async fn async_dummy2() {}
| ^ checked the `Output` of this `async fn`, found opaque type
= note: expected type `()`
found opaque type `impl Future<Output = ()>`
= note: expected unit type `()`
found opaque type `impl Future<Output = ()>`
help: consider `await`ing on the `Future`
|
LL | false => async_dummy2().await,
@ -69,7 +69,7 @@ LL ~ false => Box::new(async_dummy2()),
|
error[E0308]: `match` arms have incompatible types
--> $DIR/match-prev-arm-needing-semi.rs:56:18
--> $DIR/match-prev-arm-needing-semi.rs:59:18
|
LL | let _ = match true {
| _____________-
@ -84,12 +84,17 @@ LL | | };
| |_____- `match` arms have incompatible types
|
note: while checking the return type of the `async fn`
--> $DIR/match-prev-arm-needing-semi.rs:19:25
--> $DIR/match-prev-arm-needing-semi.rs:16:24
|
LL | async fn async_dummy() {}
| ^ checked the `Output` of this `async fn`, expected opaque type
note: while checking the return type of the `async fn`
--> $DIR/match-prev-arm-needing-semi.rs:22:25
|
LL | async fn async_dummy2() {}
| ^ checked the `Output` of this `async fn`, found opaque type
= note: expected type `impl Future<Output = ()>` (opaque type at <$DIR/match-prev-arm-needing-semi.rs:16:24>)
found opaque type `impl Future<Output = ()>` (opaque type at <$DIR/match-prev-arm-needing-semi.rs:19:25>)
= note: expected opaque type `impl Future<Output = ()>` (opaque type at <$DIR/match-prev-arm-needing-semi.rs:16:24>)
found opaque type `impl Future<Output = ()>` (opaque type at <$DIR/match-prev-arm-needing-semi.rs:22:25>)
= note: distinct uses of `impl Trait` result in different opaque types
help: consider `await`ing on both `Future`s
|

4
src/test/ui/suggestions/match-with-different-arm-types-as-stmt-instead-of-expr.stderr
View file

@ -20,8 +20,8 @@ LL | | _ => Box::new(Bar),
LL | | };
| |_____- `match` arms have incompatible types
|
= note: expected type `Box<Baz>`
found struct `Box<Bar>`
= note: expected struct `Box<Baz>`
found struct `Box<Bar>`
note: you might have meant to return the `match` expression
--> $DIR/match-with-different-arm-types-as-stmt-instead-of-expr.rs:27:6
|

7
src/test/ui/suggestions/opaque-type-error.stderr
View file

@ -1,6 +1,9 @@
error[E0308]: `if` and `else` have incompatible types
--> $DIR/opaque-type-error.rs:20:9
|
LL | fn thing_one() -> impl Future<Output = Result<(), ()>> {
| ------------------------------------ the expected opaque type
...
LL | fn thing_two() -> impl Future<Output = Result<(), ()>> {
| ------------------------------------ the found opaque type
...
@ -13,8 +16,8 @@ LL | | thing_two()
LL | | }.await
| |_____- `if` and `else` have incompatible types
|
= note: expected type `impl Future<Output = Result<(), ()>>` (opaque type at <$DIR/opaque-type-error.rs:8:19>)
found opaque type `impl Future<Output = Result<(), ()>>` (opaque type at <$DIR/opaque-type-error.rs:12:19>)
= note: expected opaque type `impl Future<Output = Result<(), ()>>` (opaque type at <$DIR/opaque-type-error.rs:8:19>)
found opaque type `impl Future<Output = Result<(), ()>>` (opaque type at <$DIR/opaque-type-error.rs:12:19>)
= note: distinct uses of `impl Trait` result in different opaque types
help: consider `await`ing on both `Future`s
|

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

@ -9,8 +9,8 @@ LL | builder.push(output);
| |
| arguments to this function are incorrect
|
= note: expected type `F`
found struct `Class<P>`
= note: expected type parameter `F`
found struct `Class<P>`
note: associated function defined here
--> $DIR/issue-52893.rs:11:8
|

9
src/test/ui/unsized/box-instead-of-dyn-fn.stderr
View file

@ -3,7 +3,10 @@ error[E0308]: `if` and `else` have incompatible types
|
LL | / if a % 2 == 0 {
LL | | move || println!("{a}")
| | ----------------------- expected because of this
| | -----------------------
| | |
| | the expected closure
| | expected because of this
LL | | } else {
LL | | Box::new(move || println!("{}", b))
| | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected closure, found struct `Box`
@ -11,8 +14,8 @@ LL | |
LL | | }
| |_____- `if` and `else` have incompatible types
|
= note: expected type `[closure@$DIR/box-instead-of-dyn-fn.rs:8:9: 8:32]`
found struct `Box<[closure@$DIR/box-instead-of-dyn-fn.rs:10:18: 10:43]>`
= note: expected closure `[closure@$DIR/box-instead-of-dyn-fn.rs:8:9: 8:32]`
found struct `Box<[closure@$DIR/box-instead-of-dyn-fn.rs:10:18: 10:43]>`
error[E0746]: return type cannot have an unboxed trait object
--> $DIR/box-instead-of-dyn-fn.rs:5:56

4
src/test/ui/wf/wf-unsafe-trait-obj-match.stderr
View file

@ -9,8 +9,8 @@ LL | | None => &R,
LL | | }
| |_____- `match` arms have incompatible types
|
= note: expected type `&S`
found reference `&R`
= note: expected reference `&S`
found reference `&R`
error[E0038]: the trait `Trait` cannot be made into an object
--> $DIR/wf-unsafe-trait-obj-match.rs:26:21