Tweak ? inference error messages

Author: wabain

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

@@ -166,14 +166,14 @@ impl UseDiagnostic<'_> {
     /// Return a descriptor of the value at the use site
     fn descr(&self) -> &'static str {
         match self {
-            Self::TryConversion { .. } => "`?` error",
+            Self::TryConversion { .. } => "error for `?` operator",
         }
     }
 
     /// Return a descriptor of the type at the use site
     fn type_descr(&self) -> &'static str {
         match self {
-            Self::TryConversion { .. } => "`?` error type",
+            Self::TryConversion { .. } => "error type for `?` operator",
         }
     }
 
@@ -188,20 +188,17 @@ impl UseDiagnostic<'_> {
     fn attach_note(&self, err: &mut DiagnosticBuilder<'_>) {
         match *self {
             Self::TryConversion { pre_ty, post_ty, .. } => {
-                let pre_ty = pre_ty.to_string();
-                let post_ty = post_ty.to_string();
+                let intro = "`?` implicitly converts the error value";
 
-                let intro = "the `?` operation implicitly converts the error value";
-
-                let msg = match (pre_ty.as_str(), post_ty.as_str()) {
-                    ("_", "_") => format!("{} using the `From` trait", intro),
-                    (_, "_") => {
+                let msg = match (pre_ty.is_ty_infer(), post_ty.is_ty_infer()) {
+                    (true, true) => format!("{} using the `From` trait", intro),
+                    (false, true) => {
                         format!("{} into a type implementing `From<{}>`", intro, pre_ty)
                     }
-                    ("_", _) => {
+                    (true, false) => {
                         format!("{} into `{}` using the `From` trait", intro, post_ty)
                     }
-                    (_, _) => {
+                    (false, false) => {
                         format!(
                             "{} into `{}` using its implementation of `From<{}>`",
                             intro, post_ty, pre_ty

src/test/ui/inference/cannot-infer-async-enabled-impl-trait-bindings.stderr

@@ -13,9 +13,9 @@ error[E0282]: type annotations needed for `impl Future`
 LL |     let fut = async {
    |         --- consider giving `fut` the explicit type `impl Future`, with the type parameters specified
 LL |         make_unit()?;
-   |                    ^ cannot infer type of `?` error
+   |                    ^ cannot infer type of error for `?` operator
    |
-   = note: the `?` operation implicitly converts the error value into a type implementing `From<std::io::Error>`
+   = note: `?` implicitly converts the error value into a type implementing `From<std::io::Error>`
 
 error: aborting due to previous error; 1 warning emitted
 

src/test/ui/inference/cannot-infer-async.stderr

@@ -4,9 +4,9 @@ error[E0282]: type annotations needed
 LL |     let fut = async {
    |         --- consider giving `fut` a type
 LL |         make_unit()?;
-   |                    ^ cannot infer type of `?` error
+   |                    ^ cannot infer type of error for `?` operator
    |
-   = note: the `?` operation implicitly converts the error value into a type implementing `From<std::io::Error>`
+   = note: `?` implicitly converts the error value into a type implementing `From<std::io::Error>`
 
 error: aborting due to previous error
 

src/test/ui/inference/cannot-infer-closure.stderr

@@ -2,9 +2,9 @@ error[E0282]: type annotations needed for the closure `fn((), ()) -> std::result
   --> $DIR/cannot-infer-closure.rs:3:15
    |
 LL |         Err(a)?;
-   |               ^ cannot infer type of `?` error
+   |               ^ cannot infer type of error for `?` operator
    |
-   = note: the `?` operation implicitly converts the error value into a type implementing `From<()>`
+   = note: `?` implicitly converts the error value into a type implementing `From<()>`
 help: give this closure an explicit return type without `_` placeholders
    |
 LL |     let x = |a: (), b: ()| -> std::result::Result<(), _> {

src/test/ui/inference/cannot-infer-partial-try-return.stderr

@@ -2,9 +2,9 @@ error[E0282]: type annotations needed for the closure `fn() -> std::result::Resu
   --> $DIR/cannot-infer-partial-try-return.rs:19:9
    |
 LL |         infallible()?;
-   |         ^^^^^^^^^^^^^ cannot infer type of `?` error
+   |         ^^^^^^^^^^^^^ cannot infer type of error for `?` operator
    |
-   = note: the `?` operation implicitly converts the error value into `QualifiedError<_>` using its implementation of `From<Infallible>`
+   = note: `?` implicitly converts the error value into `QualifiedError<_>` using its implementation of `From<Infallible>`
 help: give this closure an explicit return type without `_` placeholders
    |
 LL |     let x = || -> std::result::Result<(), QualifiedError<_>> {