bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

rename unmatched_braces to unmatched_delims

Browse source
This commit is contained in:
yukang 2023-02-21 14:51:19 +00:00
parent 65ad5f8de7
commit 9ce7472db4
6 changed files with 27 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

10
compiler/rustc_parse/src/lexer/diagnostics.rs
View file

@ -1,4 +1,4 @@
use super::UnmatchedBrace; use super::UnmatchedDelim;
use rustc_ast::token::Delimiter; use rustc_ast::token::Delimiter;
use rustc_errors::Diagnostic; use rustc_errors::Diagnostic;
use rustc_span::source_map::SourceMap; use rustc_span::source_map::SourceMap;
@ -8,7 +8,7 @@ use rustc_span::Span;
pub struct TokenTreeDiagInfo { pub struct TokenTreeDiagInfo {
/// Stack of open delimiters and their spans. Used for error message. /// Stack of open delimiters and their spans. Used for error message.
pub open_braces: Vec<(Delimiter, Span)>, pub open_braces: Vec<(Delimiter, Span)>,
pub unmatched_braces: Vec<UnmatchedBrace>, pub unmatched_delims: Vec<UnmatchedDelim>,
/// Used only for error recovery when arriving to EOF with mismatched braces. /// Used only for error recovery when arriving to EOF with mismatched braces.
pub last_unclosed_found_span: Option<Span>, pub last_unclosed_found_span: Option<Span>,
@ -32,10 +32,10 @@ pub fn same_identation_level(sm: &SourceMap, open_sp: Span, close_sp: Span) -> b
// it's more friendly compared to report `unmatched error` in later phase // it's more friendly compared to report `unmatched error` in later phase
pub fn report_missing_open_delim( pub fn report_missing_open_delim(
err: &mut Diagnostic, err: &mut Diagnostic,
unmatched_braces: &[UnmatchedBrace], unmatched_delims: &[UnmatchedDelim],
) -> bool { ) -> bool {
let mut reported_missing_open = false; let mut reported_missing_open = false;
for unmatch_brace in unmatched_braces.iter() { for unmatch_brace in unmatched_delims.iter() {
if let Some(delim) = unmatch_brace.found_delim if let Some(delim) = unmatch_brace.found_delim
&& matches!(delim, Delimiter::Parenthesis | Delimiter::Bracket) && matches!(delim, Delimiter::Parenthesis | Delimiter::Bracket)
{ {
@ -60,7 +60,7 @@ pub fn report_suspicious_mismatch_block(
sm: &SourceMap, sm: &SourceMap,
delim: Delimiter, delim: Delimiter,
) { ) {
if report_missing_open_delim(err, &diag_info.unmatched_braces) { if report_missing_open_delim(err, &diag_info.unmatched_delims) {
return; return;
} }

4
compiler/rustc_parse/src/lexer/mod.rs
View file

@ -31,7 +31,7 @@ use unescape_error_reporting::{emit_unescape_error, escaped_char};
rustc_data_structures::static_assert_size!(rustc_lexer::Token, 12); rustc_data_structures::static_assert_size!(rustc_lexer::Token, 12);
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct UnmatchedBrace { pub struct UnmatchedDelim {
pub expected_delim: Delimiter, pub expected_delim: Delimiter,
pub found_delim: Option<Delimiter>, pub found_delim: Option<Delimiter>,
pub found_span: Span, pub found_span: Span,
@ -44,7 +44,7 @@ pub(crate) fn parse_token_trees<'a>(
mut src: &'a str, mut src: &'a str,
mut start_pos: BytePos, mut start_pos: BytePos,
override_span: Option<Span>, override_span: Option<Span>,
) -> (PResult<'a, TokenStream>, Vec<UnmatchedBrace>) { ) -> (PResult<'a, TokenStream>, Vec<UnmatchedDelim>) {
// Skip `#!`, if present. // Skip `#!`, if present.
if let Some(shebang_len) = rustc_lexer::strip_shebang(src) { if let Some(shebang_len) = rustc_lexer::strip_shebang(src) {
src = &src[shebang_len..]; src = &src[shebang_len..];

11
compiler/rustc_parse/src/lexer/tokentrees.rs
View file

@ -1,7 +1,7 @@
use super::diagnostics::report_suspicious_mismatch_block; use super::diagnostics::report_suspicious_mismatch_block;
use super::diagnostics::same_identation_level; use super::diagnostics::same_identation_level;
use super::diagnostics::TokenTreeDiagInfo; use super::diagnostics::TokenTreeDiagInfo;
use super::{StringReader, UnmatchedBrace}; use super::{StringReader, UnmatchedDelim};
use rustc_ast::token::{self, Delimiter, Token}; use rustc_ast::token::{self, Delimiter, Token};
use rustc_ast::tokenstream::{DelimSpan, Spacing, TokenStream, TokenTree}; use rustc_ast::tokenstream::{DelimSpan, Spacing, TokenStream, TokenTree};
use rustc_ast_pretty::pprust::token_to_string; use rustc_ast_pretty::pprust::token_to_string;
@ -18,14 +18,14 @@ pub(super) struct TokenTreesReader<'a> {
impl<'a> TokenTreesReader<'a> { impl<'a> TokenTreesReader<'a> {
pub(super) fn parse_all_token_trees( pub(super) fn parse_all_token_trees(
string_reader: StringReader<'a>, string_reader: StringReader<'a>,
) -> (PResult<'a, TokenStream>, Vec<UnmatchedBrace>) { ) -> (PResult<'a, TokenStream>, Vec<UnmatchedDelim>) {
let mut tt_reader = TokenTreesReader { let mut tt_reader = TokenTreesReader {
string_reader, string_reader,
token: Token::dummy(), token: Token::dummy(),
diag_info: TokenTreeDiagInfo::default(), diag_info: TokenTreeDiagInfo::default(),
}; };
let res = tt_reader.parse_token_trees(/* is_delimited */ false); let res = tt_reader.parse_token_trees(/* is_delimited */ false);
(res, tt_reader.diag_info.unmatched_braces) (res, tt_reader.diag_info.unmatched_delims)
} }
// Parse a stream of tokens into a list of `TokenTree`s. // Parse a stream of tokens into a list of `TokenTree`s.
@ -79,7 +79,7 @@ impl<'a> TokenTreesReader<'a> {
let mut err = self.string_reader.sess.span_diagnostic.struct_span_err(self.token.span, msg); let mut err = self.string_reader.sess.span_diagnostic.struct_span_err(self.token.span, msg);
for &(_, sp) in &self.diag_info.open_braces { for &(_, sp) in &self.diag_info.open_braces {
err.span_label(sp, "unclosed delimiter"); err.span_label(sp, "unclosed delimiter");
self.diag_info.unmatched_braces.push(UnmatchedBrace { self.diag_info.unmatched_delims.push(UnmatchedDelim {
expected_delim: Delimiter::Brace, expected_delim: Delimiter::Brace,
found_delim: None, found_delim: None,
found_span: self.token.span, found_span: self.token.span,
@ -161,7 +161,8 @@ impl<'a> TokenTreesReader<'a> {
} }
} }
let (tok, _) = self.diag_info.open_braces.pop().unwrap(); let (tok, _) = self.diag_info.open_braces.pop().unwrap();
self.diag_info.unmatched_braces.push(UnmatchedBrace { debug!("anan now: open {:#?} close {:#?}", open_delim, close_delim);
self.diag_info.unmatched_delims.push(UnmatchedDelim {
expected_delim: tok, expected_delim: tok,
found_delim: Some(close_delim), found_delim: Some(close_delim),
found_span: self.token.span, found_span: self.token.span,

10
compiler/rustc_parse/src/lib.rs
View file

@ -182,7 +182,7 @@ pub fn source_file_to_stream(
sess: &ParseSess, sess: &ParseSess,
source_file: Lrc<SourceFile>, source_file: Lrc<SourceFile>,
override_span: Option<Span>, override_span: Option<Span>,
) -> (TokenStream, Vec<lexer::UnmatchedBrace>) { ) -> (TokenStream, Vec<lexer::UnmatchedDelim>) {
panictry_buffer!(&sess.span_diagnostic, maybe_file_to_stream(sess, source_file, override_span)) panictry_buffer!(&sess.span_diagnostic, maybe_file_to_stream(sess, source_file, override_span))
} }
@ -192,7 +192,7 @@ pub fn maybe_file_to_stream(
sess: &ParseSess, sess: &ParseSess,
source_file: Lrc<SourceFile>, source_file: Lrc<SourceFile>,
override_span: Option<Span>, override_span: Option<Span>,
) -> Result<(TokenStream, Vec<lexer::UnmatchedBrace>), Vec<Diagnostic>> { ) -> Result<(TokenStream, Vec<lexer::UnmatchedDelim>), Vec<Diagnostic>> {
let src = source_file.src.as_ref().unwrap_or_else(|| { let src = source_file.src.as_ref().unwrap_or_else(|| {
sess.span_diagnostic.bug(&format!( sess.span_diagnostic.bug(&format!(
"cannot lex `source_file` without source: {}", "cannot lex `source_file` without source: {}",
@ -200,11 +200,11 @@ pub fn maybe_file_to_stream(
)); ));
}); });
let (token_trees, unmatched_braces) = let (token_trees, unmatched_delims) =
lexer::parse_token_trees(sess, src.as_str(), source_file.start_pos, override_span); lexer::parse_token_trees(sess, src.as_str(), source_file.start_pos, override_span);
match token_trees { match token_trees {
Ok(stream) if unmatched_braces.is_empty() => Ok((stream, unmatched_braces)), Ok(stream) if unmatched_delims.is_empty() => Ok((stream, unmatched_delims)),
_ => { _ => {
// Return error if there are unmatched delimiters or unclosng delimiters. // Return error if there are unmatched delimiters or unclosng delimiters.
// We emit delimiter mismatch errors first, then emit the unclosing delimiter mismatch // We emit delimiter mismatch errors first, then emit the unclosing delimiter mismatch
@ -212,7 +212,7 @@ pub fn maybe_file_to_stream(
let mut buffer = Vec::with_capacity(1); let mut buffer = Vec::with_capacity(1);
// Not using `emit_unclosed_delims` to use `db.buffer` // Not using `emit_unclosed_delims` to use `db.buffer`
for unmatched in unmatched_braces { for unmatched in unmatched_delims {
if let Some(err) = make_unclosed_delims_error(unmatched, &sess) { if let Some(err) = make_unclosed_delims_error(unmatched, &sess) {
err.buffer(&mut buffer); err.buffer(&mut buffer);
} }

8
compiler/rustc_parse/src/parser/diagnostics.rs
View file

@ -19,9 +19,9 @@ use crate::errors::{
}; };
use crate::fluent_generated as fluent; use crate::fluent_generated as fluent;
use crate::lexer::UnmatchedBrace;
use crate::parser;
use rustc_ast as ast; use rustc_ast as ast;
use crate::parser;
use crate::lexer::UnmatchedDelim;
use rustc_ast::ptr::P; use rustc_ast::ptr::P;
use rustc_ast::token::{self, Delimiter, Lit, LitKind, TokenKind}; use rustc_ast::token::{self, Delimiter, Lit, LitKind, TokenKind};
use rustc_ast::util::parser::AssocOp; use rustc_ast::util::parser::AssocOp;
@ -222,7 +222,7 @@ impl MultiSugg {
/// is dropped. /// is dropped.
pub struct SnapshotParser<'a> { pub struct SnapshotParser<'a> {
parser: Parser<'a>, parser: Parser<'a>,
unclosed_delims: Vec<UnmatchedBrace>, unclosed_delims: Vec<UnmatchedDelim>,
} }
impl<'a> Deref for SnapshotParser<'a> { impl<'a> Deref for SnapshotParser<'a> {
@ -264,7 +264,7 @@ impl<'a> Parser<'a> {
self.unclosed_delims.extend(snapshot.unclosed_delims); self.unclosed_delims.extend(snapshot.unclosed_delims);
} }
pub fn unclosed_delims(&self) -> &[UnmatchedBrace] { pub fn unclosed_delims(&self) -> &[UnmatchedDelim] {
&self.unclosed_delims &self.unclosed_delims
} }

10
compiler/rustc_parse/src/parser/mod.rs
View file

@ -10,7 +10,7 @@ mod path;
mod stmt; mod stmt;
mod ty; mod ty;
use crate::lexer::UnmatchedBrace; use crate::lexer::UnmatchedDelim;
pub use attr_wrapper::AttrWrapper; pub use attr_wrapper::AttrWrapper;
pub use diagnostics::AttemptLocalParseRecovery; pub use diagnostics::AttemptLocalParseRecovery;
pub(crate) use item::FnParseMode; pub(crate) use item::FnParseMode;
@ -149,7 +149,7 @@ pub struct Parser<'a> {
/// A list of all unclosed delimiters found by the lexer. If an entry is used for error recovery /// A list of all unclosed delimiters found by the lexer. If an entry is used for error recovery
/// it gets removed from here. Every entry left at the end gets emitted as an independent /// it gets removed from here. Every entry left at the end gets emitted as an independent
/// error. /// error.
pub(super) unclosed_delims: Vec<UnmatchedBrace>, pub(super) unclosed_delims: Vec<UnmatchedDelim>,
last_unexpected_token_span: Option<Span>, last_unexpected_token_span: Option<Span>,
/// Span pointing at the `:` for the last type ascription the parser has seen, and whether it /// Span pointing at the `:` for the last type ascription the parser has seen, and whether it
/// looked like it could have been a mistyped path or literal `Option:Some(42)`). /// looked like it could have been a mistyped path or literal `Option:Some(42)`).
@ -1521,11 +1521,11 @@ impl<'a> Parser<'a> {
} }
pub(crate) fn make_unclosed_delims_error( pub(crate) fn make_unclosed_delims_error(
unmatched: UnmatchedBrace, unmatched: UnmatchedDelim,
sess: &ParseSess, sess: &ParseSess,
) -> Option<DiagnosticBuilder<'_, ErrorGuaranteed>> { ) -> Option<DiagnosticBuilder<'_, ErrorGuaranteed>> {
// `None` here means an `Eof` was found. We already emit those errors elsewhere, we add them to // `None` here means an `Eof` was found. We already emit those errors elsewhere, we add them to
// `unmatched_braces` only for error recovery in the `Parser`. // `unmatched_delims` only for error recovery in the `Parser`.
let found_delim = unmatched.found_delim?; let found_delim = unmatched.found_delim?;
let mut spans = vec![unmatched.found_span]; let mut spans = vec![unmatched.found_span];
if let Some(sp) = unmatched.unclosed_span { if let Some(sp) = unmatched.unclosed_span {
@ -1542,7 +1542,7 @@ pub(crate) fn make_unclosed_delims_error(
Some(err) Some(err)
} }
pub fn emit_unclosed_delims(unclosed_delims: &mut Vec<UnmatchedBrace>, sess: &ParseSess) { pub fn emit_unclosed_delims(unclosed_delims: &mut Vec<UnmatchedDelim>, sess: &ParseSess) {
*sess.reached_eof.borrow_mut() |= *sess.reached_eof.borrow_mut() |=
unclosed_delims.iter().any(|unmatched_delim| unmatched_delim.found_delim.is_none()); unclosed_delims.iter().any(|unmatched_delim| unmatched_delim.found_delim.is_none());
for unmatched in unclosed_delims.drain(..) { for unmatched in unclosed_delims.drain(..) {