Enforce ErrorGuaranteed for silencing resolve errors

Author: estebank

compiler/rustc_parse/src/parser/expr.rs

@@ -2480,9 +2480,9 @@ impl<'a> Parser<'a> {
 
         let mut checker = CondChecker::new(self);
         checker.visit_expr(&mut cond);
-        if checker.seen_missing_let {
+        if checker.seen_missing_let.is_some() {
             // Avoid unnecessary resolve errors as we know we'll have some.
-            *self.sess.silence_resolve_errors.borrow_mut() = true;
+            *self.sess.silence_resolve_errors.borrow_mut() = checker.seen_missing_let;
         }
         self.sess.silence_missing_comparison.borrow_mut().append(&mut checker.seen_comparison);
 
@@ -3562,7 +3562,7 @@ struct CondChecker<'a> {
     parser: &'a Parser<'a>,
     forbid_let_reason: Option<ForbiddenLetReason>,
     missing_let: Option<errors::MaybeMissingLet>,
-    seen_missing_let: bool,
+    seen_missing_let: Option<ErrorGuaranteed>,
     comparison: Option<errors::MaybeComparison>,
     seen_comparison: Vec<Span>,
 }
@@ -3573,7 +3573,7 @@ impl<'a> CondChecker<'a> {
             parser,
             forbid_let_reason: None,
             missing_let: None,
-            seen_missing_let: false,
+            seen_missing_let: None,
             comparison: None,
             seen_comparison: vec![],
         }
@@ -3591,13 +3591,16 @@ impl MutVisitor for CondChecker<'_> {
                     if let Some(comparison) = self.comparison {
                         self.seen_comparison.push(comparison.span);
                     }
-                    *is_recovered =
-                        Some(self.parser.sess.emit_err(errors::ExpectedExpressionFoundLet {
-                            span,
-                            reason,
-                            missing_let: self.missing_let,
-                            comparison: self.comparison,
-                        }));
+                    let error = self.parser.sess.emit_err(errors::ExpectedExpressionFoundLet {
+                        span,
+                        reason,
+                        missing_let: self.missing_let,
+                        comparison: self.comparison,
+                    });
+                    *is_recovered = Some(error);
+                    if self.missing_let.is_some() {
+                        self.seen_missing_let = Some(error);
+                    }
                 } else {
                     self.parser.sess.gated_spans.gate(sym::let_chains, span);
                 }
@@ -3631,7 +3634,6 @@ impl MutVisitor for CondChecker<'_> {
                     | ExprKind::Call(_, _)
                     | ExprKind::Array(_) = rhs.kind
                 {
-                    self.seen_missing_let = true;
                     self.missing_let =
                         Some(errors::MaybeMissingLet { span: rhs.span.shrink_to_lo() });
                 }

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -435,7 +435,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
             code,
         );
 
-        if *self.r.tcx.sess.parse_sess.silence_resolve_errors.borrow() {
+        if self.r.tcx.sess.parse_sess.silence_resolve_errors.borrow().is_some() {
             // Silence redundant resolve errors that will be caused due to mis-parse fallout.
             err.delay_as_bug();
         }

compiler/rustc_session/src/parse.rs

@@ -217,9 +217,9 @@ pub struct ParseSess {
     pub proc_macro_quoted_spans: AppendOnlyVec<Span>,
     /// Used to generate new `AttrId`s. Every `AttrId` is unique.
     pub attr_id_generator: AttrIdGenerator,
-    /// Track parse errors that will cause unnecessary resolve errors.  This is a crude mechanism,
+    /// 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>,
+    pub silence_resolve_errors: Lock<Option<ErrorGuaranteed>>,
     /// Track parse errors that suggests changing an assignment to be an equality check.
     pub silence_missing_comparison: Lock<Vec<Span>>,
 }