Silence reduntant type errors on assignment instead of equality check

Author: estebank

Diff for: compiler/rustc_hir_typeck/src/expr.rs

@@ -1177,12 +1177,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 };
             }
             if eq {
+                let span = span.shrink_to_hi();
                 err.span_suggestion_verbose(
-                    span.shrink_to_hi(),
+                    span,
                     "you might have meant to compare for equality",
                     '=',
                     applicability,
                 );
+                if self.tcx.sess.parse_sess.silence_missing_comparison.borrow().contains(&span) {
+                    err.delay_as_bug();
+                }
             }
 
             // If the assignment expression itself is ill-formed, don't

Diff for: compiler/rustc_parse/src/parser/expr.rs

@@ -2484,6 +2484,7 @@ impl<'a> Parser<'a> {
             // Avoid unnecessary resolve errors as we know we'll have some.
             *self.sess.silence_resolve_errors.borrow_mut() = true;
         }
+        self.sess.silence_missing_comparison.borrow_mut().append(&mut checker.seen_comparison);
 
         if let ExprKind::Let(_, _, _, None) = cond.kind {
             // Remove the last feature gating of a `let` expression since it's stable.
@@ -3563,6 +3564,7 @@ struct CondChecker<'a> {
     missing_let: Option<errors::MaybeMissingLet>,
     seen_missing_let: bool,
     comparison: Option<errors::MaybeComparison>,
+    seen_comparison: Vec<Span>,
 }
 
 impl<'a> CondChecker<'a> {
@@ -3573,6 +3575,7 @@ impl<'a> CondChecker<'a> {
             missing_let: None,
             seen_missing_let: false,
             comparison: None,
+            seen_comparison: vec![],
         }
     }
 }
@@ -3585,6 +3588,9 @@ impl MutVisitor for CondChecker<'_> {
         match e.kind {
             ExprKind::Let(_, _, _, ref mut is_recovered @ None) => {
                 if let Some(reason) = self.forbid_let_reason {
+                    if let Some(comparison) = self.comparison {
+                        self.seen_comparison.push(comparison.span);
+                    }
                     *is_recovered =
                         Some(self.parser.sess.emit_err(errors::ExpectedExpressionFoundLet {
                             span,
@@ -3630,7 +3636,8 @@ impl MutVisitor for CondChecker<'_> {
                         Some(errors::MaybeMissingLet { span: rhs.span.shrink_to_lo() });
                 }
                 let comparison = self.comparison;
-                self.comparison = Some(errors::MaybeComparison { span: span.shrink_to_hi() });
+                let span = span.shrink_to_hi();
+                self.comparison = Some(errors::MaybeComparison { span });
                 noop_visit_expr(e, self);
                 self.forbid_let_reason = forbid_let_reason;
                 self.missing_let = missing_let;

Diff for: compiler/rustc_session/src/parse.rs

@@ -220,6 +220,8 @@ pub struct ParseSess {
     /// Track parse errors that will cause unnecessary resolve errors.  This is a crude mechanism,
     /// we should do something that is scope-based, instead of crate-global.
     pub silence_resolve_errors: Lock<bool>,
+    /// Track parse errors that suggests changing an assignment to be an equality check.
+    pub silence_missing_comparison: Lock<Vec<Span>>,
 }
 
 impl ParseSess {
@@ -251,6 +253,7 @@ impl ParseSess {
             proc_macro_quoted_spans: Default::default(),
             attr_id_generator: AttrIdGenerator::new(),
             silence_resolve_errors: Default::default(),
+            silence_missing_comparison: Default::default(),
         }
     }
 

Diff for: tests/ui/expr/if/bad-if-let-suggestion-2.rs

@@ -4,7 +4,6 @@
 fn a() {
     if let x = 1 && i = 2 {}
     //~^ ERROR expected expression, found `let` statement
-    //~| ERROR mismatched types
 }
 
 fn main() {}

Diff for: tests/ui/expr/if/bad-if-let-suggestion-2.stderr

@@ -14,17 +14,5 @@ help: you might have meant to compare for equality
 LL |     if let x = 1 && i == 2 {}
    |                        +
 
-error[E0308]: mismatched types
-  --> $DIR/bad-if-let-suggestion-2.rs:5:8
-   |
-LL |     if let x = 1 && i = 2 {}
-   |        ^^^^^^^^^^^^^^^^^^ expected `bool`, found `()`
-   |
-help: you might have meant to compare for equality
-   |
-LL |     if let x = 1 && i == 2 {}
-   |                        +
-
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0308`.