Resolve vars in note_type_err

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -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 {
+        let (expected_found, exp_found, is_simple_error, values) = match values {
-            None => (None, Mismatch::Fixed("type"), false),
+            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))
             }
         };
 

compiler/rustc_typeck/src/check/fn_ctxt/checks.rs

@@ -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),
                             );

src/test/ui/associated-types/associated-types-issue-20346.stderr

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

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

@@ -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
    |

src/test/ui/async-await/generator-desc.stderr

@@ -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>)
+   = 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>)
+              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)
+   = note: expected opaque type `impl Future<Output = ()>` (`async` closure body)
-           found 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
 

src/test/ui/async-await/suggest-missing-await.stderr

@@ -60,8 +60,13 @@ LL | |
 LL | |     };
    | |_____- `if` and `else` have incompatible types
    |
-   = note:   expected type `impl Future<Output = ()>`
+note: while checking the return type of the `async fn`
-           found unit type `()`
+  --> $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

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

@@ -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`.

src/test/ui/closures/closure_cap_coerce_many_fail.stderr

@@ -11,8 +11,8 @@ LL | |         _ => unimplemented!(),
 LL | |     };
    | |_____- `match` arms have incompatible types
    |
-   = note: expected type `fn(i32, i32) -> i32 {add}`
+   = note: expected fn item `fn(i32, i32) -> i32 {add}`
-           found closure `[closure@$DIR/closure_cap_coerce_many_fail.rs:9:16: 9:43]`
+              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]`
+   = 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]`
+              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]`
+   = 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]`
+              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]`
+   = 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]`
+              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
 

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

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

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

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

src/test/ui/destructuring-assignment/tuple_destructure_fail.stderr

@@ -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})`
+   = note: expected tuple `({integer}, {integer})`
-             found tuple `(_, _, _)`
+              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})`
+   = note: expected tuple `({integer}, {integer})`
-             found tuple `(_,)`
+              found tuple `(_,)`
 
 error: aborting due to 4 previous errors
 

src/test/ui/error-codes/E0502.nll.stderr

@@ -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`.

src/test/ui/fn/fn-item-type.rs

@@ -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

src/test/ui/fn/fn-item-type.stderr

@@ -6,8 +6,8 @@ LL |     eq(foo::<u8>, bar::<u8>);
    |     |
    |     arguments to this function are incorrect
    |
-   = note: expected type `fn(_) -> _ {foo::<u8>}`
+   = note: expected fn item `fn(_) -> _ {foo::<u8>}`
-           found fn item `fn(_) -> _ {bar::<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>}`
+   = note: expected fn item `fn(_) -> _ {foo::<u8>}`
-           found fn item `fn(_) -> _ {foo::<i8>}`
+              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>}`
+   = note: expected fn item `fn(_) -> _ {bar::<String>}`
-           found fn item `fn(_) -> _ {bar::<Vec<u8>>}`
+              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}`
+   = note: expected fn item `fn() {<u8 as Foo>::foo}`
-           found fn item `fn() {<u16 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`

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

@@ -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

src/test/ui/let-else/let-else-non-diverging.stderr

@@ -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 `!`
+   = note:   expected type `!`
-              found 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`
 

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

@@ -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

src/test/ui/or-patterns/inconsistent-modes.stderr

@@ -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`
+   = note:      expected reference `&&u8`
-              found type `&mut &mut 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}`
+   = note:      expected reference `&{integer}`
-              found type `&mut _`
+           found mutable reference `&mut _`
    = note: a binding must have the same type in all alternatives
 
 error: aborting due to 9 previous errors

src/test/ui/parser/recover-range-pats.stderr

@@ -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

src/test/ui/reify-intrinsic.stderr

@@ -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}`
+   = note: expected fn item `extern "rust-intrinsic" fn(_) -> _ {likely}`
-           found fn item `extern "rust-intrinsic" fn(_) -> _ {unlikely}`
+              found fn item `extern "rust-intrinsic" fn(_) -> _ {unlikely}`
 
 error: aborting due to 3 previous errors
 

src/test/ui/resolve/resolve-inconsistent-binding-mode.stderr

@@ -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`
+   = note: expected mutable reference `&mut isize`
-              found type `&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

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

@@ -6,8 +6,8 @@ LL |     match &s {
 LL |             "abc" => true,
    |             ^^^^^ expected `&str`, found `str`
    |
-   = note:   expected type `&&str`
+   = note: expected reference `&&str`
-           found reference `&'static 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]`
+   = note: expected reference `&&[u8]`
-           found reference `&'static [u8; 3]`
+              found reference `&'static [u8; 3]`
 
 error: aborting due to 2 previous errors
 

src/test/ui/suggestions/issue-81839.stderr

@@ -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 `()`
+   = note: expected unit type `()`
-           found opaque type `impl Future<Output = Test>`
+            found opaque type `impl Future<Output = Test>`
 
 error: aborting due to previous error
 

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

@@ -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
     };
 }

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

@@ -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 `()`
+   = note: expected unit type `()`
-           found opaque type `impl Future<Output = ()>`
+            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 `()`
+   = note: expected unit type `()`
-           found opaque type `impl Future<Output = ()>`
+            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>)
+   = 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:19:25>)
+              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
    |

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

@@ -20,8 +20,8 @@ LL | |         _ => Box::new(Bar),
 LL | |     };
    | |_____- `match` arms have incompatible types
    |
-   = note: expected type `Box<Baz>`
+   = note: expected struct `Box<Baz>`
-            found struct `Box<Bar>`
+              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
    |

src/test/ui/suggestions/opaque-type-error.stderr

@@ -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>)
+   = 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>)
+              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
    |

src/test/ui/traits/issue-52893.stderr

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

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

@@ -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]`
+   = 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]>`
+               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

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

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