Suppress suggest try wrap when found is unresolved var

Signed-off-by: xizheyin <[email protected]>

Author: xizheyin

compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs

@@ -11,7 +11,9 @@ use rustc_hir::{MatchSource, Node};
 use rustc_middle::traits::{MatchExpressionArmCause, ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self as ty, GenericArgKind, IsSuggestable, Ty, TypeVisitableExt};
+use rustc_middle::ty::{
+    self as ty, GenericArgKind, IsSuggestable, Ty, TypeFlags, TypeVisitableExt,
+};
 use rustc_span::{Span, sym};
 use tracing::debug;
 
@@ -89,6 +91,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         exp_found: &ty::error::ExpectedFound<Ty<'tcx>>,
         diag: &mut Diag<'_>,
     ) {
+        // when found is unresolved var, we can't suggest anything
+        if exp_found.found.has_type_flags(TypeFlags::HAS_INFER_TY_VAR) {
+            return;
+        }
+
         // Heavily inspired by `FnCtxt::suggest_compatible_variants`, with
         // some modifications due to that being in typeck and this being in infer.
         if let ObligationCauseCode::Pattern { .. } = cause.code()

compiler/rustc_type_ir/src/flags.rs

@@ -133,6 +133,9 @@ bitflags::bitflags! {
 
         /// Does this type have any coroutines in it?
         const HAS_TY_CORO                 = 1 << 24;
+
+        /// Does this type have any Infer(TyVar(_)) in it?
+        const HAS_INFER_TY_VAR            = 1 << 25;
     }
 }
 
@@ -267,9 +270,10 @@ impl<I: Interner> FlagComputation<I> {
                 ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
                     self.add_flags(TypeFlags::HAS_TY_FRESH)
                 }
-
-                ty::TyVar(_) | ty::IntVar(_) | ty::FloatVar(_) => {
-                    self.add_flags(TypeFlags::HAS_TY_INFER)
+                ty::IntVar(_) | ty::FloatVar(_) => self.add_flags(TypeFlags::HAS_TY_INFER),
+                ty::TyVar(_) => {
+                    self.add_flags(TypeFlags::HAS_INFER_TY_VAR);
+                    self.add_flags(TypeFlags::HAS_TY_INFER);
                 }
             },
 

tests/ui/issues/issue-3680.stderr

@@ -8,10 +8,6 @@ LL |         Err(_) => ()
    |
    = note: expected enum `Option<_>`
               found enum `Result<_, _>`
-help: try wrapping the pattern in `Some`
-   |
-LL |         Some(Err(_)) => ()
-   |         +++++      +
 
 error: aborting due to 1 previous error
 

tests/ui/issues/issue-5358-1.stderr

@@ -8,10 +8,6 @@ LL |         Either::Right(_) => {}
    |
    = note: expected struct `S`
                 found enum `Either<_, _>`
-help: try wrapping the pattern in `S`
-   |
-LL |         S(Either::Right(_)) => {}
-   |         ++                +
 help: you might have meant to use field `0` whose type is `Either<usize, usize>`
    |
 LL |     match S(Either::Left(5)).0 {

tests/ui/match/issue-12552.stderr

@@ -8,10 +8,6 @@ LL |     Some(k) => match k {
    |
    = note: expected enum `Result<_, {integer}>`
               found enum `Option<_>`
-help: try wrapping the pattern in `Ok`
-   |
-LL |     Ok(Some(k)) => match k {
-   |     +++       +
 
 error[E0308]: mismatched types
   --> $DIR/issue-12552.rs:9:5
@@ -24,10 +20,6 @@ LL |     None => ()
    |
    = note: expected enum `Result<_, {integer}>`
               found enum `Option<_>`
-help: try wrapping the pattern in `Ok`
-   |
-LL |     Ok(None) => ()
-   |     +++    +
 
 error: aborting due to 2 previous errors
 

tests/ui/type/type-mismatch-suggest-wrap-issue-145634.rs

@@ -1,6 +1,6 @@
 // We should not suggest wrapping rhs with `Some`
 // when the found type is an unresolved type variable
-// 
+//
 // See https://github.com/rust-lang/rust/issues/145634
 
 fn main() {

tests/ui/type/type-mismatch-suggest-wrap-issue-145634.stderr

@@ -8,10 +8,6 @@ LL |     assert!(matches!(foo, &Some((1, 2))));
    |
    = note:   expected enum `Option<&({integer}, {integer})>`
            found reference `&_`
-help: try wrapping the pattern in `Some`
-   |
-LL |     assert!(matches!(foo, Some(&Some((1, 2)))));
-   |                           +++++             +
 
 error: aborting due to 1 previous error