Distinguish delim kind to decide whether to emit unexpected closing delimiter

To emit missing open delim note, I also moved `missing open delim` note to
`mismatched closing delimiter` error, which can emit without delaying to
`unexpected closing delimiter` error. And I moved `make_unclosed_delims_error`
to src/lexer/diagnostics.rs for clean. And some other clean.

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

Author: xizheyin

compiler/rustc_parse/src/lexer/diagnostics.rs

@@ -1,12 +1,22 @@
-use rustc_ast::token::Delimiter;
+use rustc_ast::token::{self, Delimiter};
+use rustc_ast_pretty::pprust;
 use rustc_errors::Diag;
+use rustc_session::parse::ParseSess;
 use rustc_span::Span;
 use rustc_span::source_map::SourceMap;
 
 use super::UnmatchedDelim;
+use crate::errors::MismatchedClosingDelimiter;
 
 #[derive(Default)]
 pub(super) struct TokenTreeDiagInfo {
+    /// record span of `(` for diagnostic
+    pub open_parens: Vec<Span>,
+    /// record span of `{` for diagnostic
+    pub open_braces: Vec<Span>,
+    /// record span of `[` for diagnostic
+    pub open_brackets: Vec<Span>,
+
     /// Stack of open delimiters and their spans. Used for error message.
     pub open_delimiters: Vec<(Delimiter, Span)>,
     pub unmatched_delims: Vec<UnmatchedDelim>,
@@ -22,13 +32,58 @@ pub(super) struct TokenTreeDiagInfo {
     pub matching_block_spans: Vec<(Span, Span)>,
 }
 
+impl TokenTreeDiagInfo {
+    pub(super) fn push_open_delimiter(&mut self, delim: Delimiter, span: Span) {
+        self.open_delimiters.push((delim, span));
+        match delim {
+            Delimiter::Parenthesis => self.open_parens.push(span),
+            Delimiter::Brace => self.open_braces.push(span),
+            Delimiter::Bracket => self.open_brackets.push(span),
+            _ => {}
+        }
+    }
+
+    pub(super) fn pop_open_delimiter(&mut self) -> Option<(Delimiter, Span)> {
+        let (delim, span) = self.open_delimiters.pop()?;
+        match delim {
+            Delimiter::Parenthesis => self.open_parens.pop(),
+            Delimiter::Brace => self.open_braces.pop(),
+            Delimiter::Bracket => self.open_brackets.pop(),
+            _ => unreachable!(),
+        };
+        Some((delim, span))
+    }
+}
+
 pub(super) fn same_indentation_level(sm: &SourceMap, open_sp: Span, close_sp: Span) -> bool {
     match (sm.span_to_margin(open_sp), sm.span_to_margin(close_sp)) {
         (Some(open_padding), Some(close_padding)) => open_padding == close_padding,
         _ => false,
     }
 }
 
+pub(crate) fn make_unclosed_delims_error(
+    unmatched: UnmatchedDelim,
+    psess: &ParseSess,
+) -> Option<Diag<'_>> {
+    // `None` here means an `Eof` was found. We already emit those errors elsewhere, we add them to
+    // `unmatched_delims` only for error recovery in the `Parser`.
+    let found_delim = unmatched.found_delim?;
+    let mut spans = vec![unmatched.found_span];
+    if let Some(sp) = unmatched.unclosed_span {
+        spans.push(sp);
+    };
+    let mut err = psess.dcx().create_err(MismatchedClosingDelimiter {
+        spans,
+        delimiter: pprust::token_kind_to_string(&token::CloseDelim(found_delim)).to_string(),
+        unmatched: unmatched.found_span,
+        opening_candidate: unmatched.candidate_span,
+        unclosed: unmatched.unclosed_span,
+    });
+    report_missing_open_delim(&mut err, &[unmatched]);
+    Some(err)
+}
+
 // When we get a `)` or `]` for `{`, we should emit help message here
 // it's more friendly compared to report `unmatched error` in later phase
 fn report_missing_open_delim(err: &mut Diag<'_>, unmatched_delims: &[UnmatchedDelim]) -> bool {
@@ -58,10 +113,6 @@ pub(super) fn report_suspicious_mismatch_block(
     sm: &SourceMap,
     delim: Delimiter,
 ) {
-    if report_missing_open_delim(err, &diag_info.unmatched_delims) {
-        return;
-    }
-
     let mut matched_spans: Vec<(Span, bool)> = diag_info
         .matching_block_spans
         .iter()

compiler/rustc_parse/src/lexer/mod.rs

@@ -1,5 +1,6 @@
 use std::ops::Range;
 
+use diagnostics::make_unclosed_delims_error;
 use rustc_ast::ast::{self, AttrStyle};
 use rustc_ast::token::{self, CommentKind, Delimiter, IdentIsRaw, Token, TokenKind};
 use rustc_ast::tokenstream::TokenStream;
@@ -17,9 +18,9 @@ use rustc_session::parse::ParseSess;
 use rustc_span::{BytePos, Pos, Span, Symbol};
 use tracing::debug;
 
+use crate::errors;
 use crate::lexer::diagnostics::TokenTreeDiagInfo;
 use crate::lexer::unicode_chars::UNICODE_ARRAY;
-use crate::{errors, make_unclosed_delims_error};
 
 mod diagnostics;
 mod tokentrees;

compiler/rustc_parse/src/lexer/tokentrees.rs

@@ -36,6 +36,15 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
                     return if is_delimited {
                         Ok((open_spacing, TokenStream::new(buf)))
                     } else {
+                        let matches_previous_open_delim = match delim {
+                            Delimiter::Parenthesis => self.diag_info.open_parens.last().is_some(),
+                            Delimiter::Brace => self.diag_info.open_braces.last().is_some(),
+                            Delimiter::Bracket => self.diag_info.open_brackets.last().is_some(),
+                            _ => unreachable!(),
+                        };
+                        if matches_previous_open_delim {
+                            return Err(vec![]);
+                        }
                         Err(vec![self.close_delim_err(delim)])
                     };
                 }
@@ -102,7 +111,7 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
         // The span for beginning of the delimited section.
         let pre_span = self.token.span;
 
-        self.diag_info.open_delimiters.push((open_delim, self.token.span));
+        self.diag_info.push_open_delimiter(open_delim, open_delim_span);
 
         // Lex the token trees within the delimiters.
         // We stop at any delimiter so we can try to recover if the user
@@ -117,7 +126,7 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
             // Correct delimiter.
             token::CloseDelim(close_delim) if close_delim == open_delim => {
                 let (open_delimiter, open_delimiter_span) =
-                    self.diag_info.open_delimiters.pop().unwrap();
+                    self.diag_info.pop_open_delimiter().unwrap();
                 let close_delim_span = self.token.span;
 
                 if tts.is_empty() && close_delim == Delimiter::Brace {

compiler/rustc_parse/src/lib.rs

@@ -33,7 +33,7 @@ pub const MACRO_ARGUMENTS: Option<&str> = Some("macro arguments");
 
 #[macro_use]
 pub mod parser;
-use parser::{Parser, make_unclosed_delims_error};
+use parser::Parser;
 pub mod lexer;
 pub mod validate_attr;
 

compiler/rustc_parse/src/parser/mod.rs

@@ -45,11 +45,8 @@ use token_type::TokenTypeSet;
 pub use token_type::{ExpKeywordPair, ExpTokenPair, TokenType};
 use tracing::debug;
 
-use crate::errors::{
-    self, IncorrectVisibilityRestriction, MismatchedClosingDelimiter, NonStringAbiLiteral,
-};
+use crate::errors::{self, IncorrectVisibilityRestriction, NonStringAbiLiteral};
 use crate::exp;
-use crate::lexer::UnmatchedDelim;
 
 #[cfg(test)]
 mod tests;
@@ -1780,27 +1777,6 @@ impl<'a> Parser<'a> {
     }
 }
 
-pub(crate) fn make_unclosed_delims_error(
-    unmatched: UnmatchedDelim,
-    psess: &ParseSess,
-) -> Option<Diag<'_>> {
-    // `None` here means an `Eof` was found. We already emit those errors elsewhere, we add them to
-    // `unmatched_delims` only for error recovery in the `Parser`.
-    let found_delim = unmatched.found_delim?;
-    let mut spans = vec![unmatched.found_span];
-    if let Some(sp) = unmatched.unclosed_span {
-        spans.push(sp);
-    };
-    let err = psess.dcx().create_err(MismatchedClosingDelimiter {
-        spans,
-        delimiter: pprust::token_kind_to_string(&token::CloseDelim(found_delim)).to_string(),
-        unmatched: unmatched.found_span,
-        opening_candidate: unmatched.candidate_span,
-        unclosed: unmatched.unclosed_span,
-    });
-    Some(err)
-}
-
 /// A helper struct used when building an `AttrTokenStream` from
 /// a `LazyAttrTokenStream`. Both delimiter and non-delimited tokens
 /// are stored as `FlatToken::Token`. A vector of `FlatToken`s

tests/ui/macros/issue-102878.stderr

@@ -2,8 +2,10 @@ error: mismatched closing delimiter: `)`
   --> $DIR/issue-102878.rs:1:35
    |
 LL | macro_rules!test{($l:expr,$_:r)=>({const:y y)}
-   |                                  -^         ^ mismatched closing delimiter
-   |                                  ||
+   |                                  -^         ^
+   |                                  ||         |
+   |                                  ||         mismatched closing delimiter
+   |                                  ||         missing open `(` for this delimiter
    |                                  |unclosed delimiter
    |                                  closing delimiter possibly meant for this
 

tests/ui/parser/deli-ident-issue-2.rs

@@ -2,6 +2,6 @@ fn main() {
     if 1 < 2 {
         let _a = vec!]; //~ ERROR mismatched closing delimiter
     }
-} //~ ERROR unexpected closing delimiter
+}
 
 fn main() {}

tests/ui/parser/deli-ident-issue-2.stderr

@@ -4,16 +4,10 @@ error: mismatched closing delimiter: `]`
 LL |     if 1 < 2 {
    |              ^ unclosed delimiter
 LL |         let _a = vec!];
-   |                      ^ mismatched closing delimiter
+   |                      ^
+   |                      |
+   |                      mismatched closing delimiter
+   |                      missing open `[` for this delimiter
 
-error: unexpected closing delimiter: `}`
-  --> $DIR/deli-ident-issue-2.rs:5:1
-   |
-LL |         let _a = vec!];
-   |                      - missing open `[` for this delimiter
-LL |     }
-LL | }
-   | ^ unexpected closing delimiter
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 

tests/ui/parser/do-not-suggest-semicolon-before-array.stderr

@@ -2,8 +2,10 @@ error: mismatched closing delimiter: `)`
   --> $DIR/do-not-suggest-semicolon-before-array.rs:5:5
    |
 LL |     [1, 3)
-   |     ^    ^ mismatched closing delimiter
-   |     |
+   |     ^    ^
+   |     |    |
+   |     |    mismatched closing delimiter
+   |     |    missing open `(` for this delimiter
    |     unclosed delimiter
 
 error: aborting due to 1 previous error

tests/ui/parser/issues/issue-104367.stderr

@@ -2,8 +2,10 @@ error: mismatched closing delimiter: `)`
   --> $DIR/issue-104367.rs:5:15
    |
 LL |             #![w,)
-   |               ^  ^ mismatched closing delimiter
-   |               |
+   |               ^  ^
+   |               |  |
+   |               |  mismatched closing delimiter
+   |               |  missing open `(` for this delimiter
    |               unclosed delimiter
 
 error: this file contains an unclosed delimiter
@@ -18,7 +20,6 @@ LL |     d: [u32; {
 LL |         #![cfg] {
    |                 - unclosed delimiter
 LL |             #![w,)
-   |                  - missing open `(` for this delimiter
 LL |
    |                                                                      ^