1
Fork 0

Make unexpected always "return" PResult<()> & add unexpected_any

This prevents breakage when `?` no longer skews inference.
This commit is contained in:
Maybe Waffle 2024-03-15 11:36:21 +00:00
parent ee03c286cf
commit defcc44238
7 changed files with 25 additions and 15 deletions

View file

@ -189,7 +189,7 @@ pub fn parse_asm_args<'a>(
args.templates.push(template); args.templates.push(template);
continue; continue;
} else { } else {
return p.unexpected(); p.unexpected_any()?
}; };
allow_templates = false; allow_templates = false;

View file

@ -151,7 +151,7 @@ fn parse_assert<'a>(cx: &mut ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PRes
}; };
if parser.token != token::Eof { if parser.token != token::Eof {
return parser.unexpected(); parser.unexpected()?;
} }
Ok(Assert { cond_expr, custom_message }) Ok(Assert { cond_expr, custom_message })

View file

@ -380,12 +380,12 @@ impl<'a> Parser<'a> {
}; };
if let Some(item) = nt_meta { if let Some(item) = nt_meta {
return match item.meta(item.path.span) { match item.meta(item.path.span) {
Some(meta) => { Some(meta) => {
self.bump(); self.bump();
Ok(meta) return Ok(meta);
} }
None => self.unexpected(), None => self.unexpected()?,
}; };
} }

View file

@ -481,7 +481,7 @@ impl<'a> Parser<'a> {
})) }))
} else { } else {
self.maybe_recover_bounds_doubled_colon(&ty)?; self.maybe_recover_bounds_doubled_colon(&ty)?;
self.unexpected() self.unexpected_any()
} }
} }

View file

@ -1514,7 +1514,7 @@ impl<'a> Parser<'a> {
let ident = this.parse_field_ident("enum", vlo)?; let ident = this.parse_field_ident("enum", vlo)?;
if this.token == token::Not { if this.token == token::Not {
if let Err(err) = this.unexpected::<()>() { if let Err(err) = this.unexpected() {
err.with_note(fluent::parse_macro_expands_to_enum_variant).emit(); err.with_note(fluent::parse_macro_expands_to_enum_variant).emit();
} }
@ -1937,7 +1937,7 @@ impl<'a> Parser<'a> {
) -> PResult<'a, FieldDef> { ) -> PResult<'a, FieldDef> {
let name = self.parse_field_ident(adt_ty, lo)?; let name = self.parse_field_ident(adt_ty, lo)?;
if self.token.kind == token::Not { if self.token.kind == token::Not {
if let Err(mut err) = self.unexpected::<FieldDef>() { if let Err(mut err) = self.unexpected() {
// Encounter the macro invocation // Encounter the macro invocation
err.subdiagnostic(self.dcx(), MacroExpandsToAdtField { adt_ty }); err.subdiagnostic(self.dcx(), MacroExpandsToAdtField { adt_ty });
return Err(err); return Err(err);
@ -2067,7 +2067,7 @@ impl<'a> Parser<'a> {
let params = self.parse_token_tree(); // `MacParams` let params = self.parse_token_tree(); // `MacParams`
let pspan = params.span(); let pspan = params.span();
if !self.check(&token::OpenDelim(Delimiter::Brace)) { if !self.check(&token::OpenDelim(Delimiter::Brace)) {
return self.unexpected(); self.unexpected()?;
} }
let body = self.parse_token_tree(); // `MacBody` let body = self.parse_token_tree(); // `MacBody`
// Convert `MacParams MacBody` into `{ MacParams => MacBody }`. // Convert `MacParams MacBody` into `{ MacParams => MacBody }`.
@ -2077,7 +2077,7 @@ impl<'a> Parser<'a> {
let dspan = DelimSpan::from_pair(pspan.shrink_to_lo(), bspan.shrink_to_hi()); let dspan = DelimSpan::from_pair(pspan.shrink_to_lo(), bspan.shrink_to_hi());
P(DelimArgs { dspan, delim: Delimiter::Brace, tokens }) P(DelimArgs { dspan, delim: Delimiter::Brace, tokens })
} else { } else {
return self.unexpected(); self.unexpected_any()?
}; };
self.psess.gated_spans.gate(sym::decl_macro, lo.to(self.prev_token.span)); self.psess.gated_spans.gate(sym::decl_macro, lo.to(self.prev_token.span));
@ -2692,7 +2692,7 @@ impl<'a> Parser<'a> {
debug!("parse_param_general parse_pat (is_name_required:{})", is_name_required); debug!("parse_param_general parse_pat (is_name_required:{})", is_name_required);
let (pat, colon) = this.parse_fn_param_pat_colon()?; let (pat, colon) = this.parse_fn_param_pat_colon()?;
if !colon { if !colon {
let mut err = this.unexpected::<()>().unwrap_err(); let mut err = this.unexpected().unwrap_err();
return if let Some(ident) = return if let Some(ident) =
this.parameter_without_type(&mut err, pat, is_name_required, first_param) this.parameter_without_type(&mut err, pat, is_name_required, first_param)
{ {
@ -2716,7 +2716,7 @@ impl<'a> Parser<'a> {
{ {
// This wasn't actually a type, but a pattern looking like a type, // This wasn't actually a type, but a pattern looking like a type,
// so we are going to rollback and re-parse for recovery. // so we are going to rollback and re-parse for recovery.
ty = this.unexpected(); ty = this.unexpected_any();
} }
match ty { match ty {
Ok(ty) => { Ok(ty) => {

View file

@ -465,7 +465,9 @@ impl<'a> Parser<'a> {
matches!(self.recovery, Recovery::Allowed) matches!(self.recovery, Recovery::Allowed)
} }
pub fn unexpected<T>(&mut self) -> PResult<'a, T> { /// Version of [`unexpected`](Parser::unexpected) that "returns" any type in the `Ok`
/// (both those functions never return "Ok", and so can lie like that in the type).
pub fn unexpected_any<T>(&mut self) -> PResult<'a, T> {
match self.expect_one_of(&[], &[]) { match self.expect_one_of(&[], &[]) {
Err(e) => Err(e), Err(e) => Err(e),
// We can get `Ok(true)` from `recover_closing_delimiter` // We can get `Ok(true)` from `recover_closing_delimiter`
@ -474,6 +476,10 @@ impl<'a> Parser<'a> {
} }
} }
pub fn unexpected(&mut self) -> PResult<'a, ()> {
self.unexpected_any()
}
/// Expects and consumes the token `t`. Signals an error if the next token is not `t`. /// Expects and consumes the token `t`. Signals an error if the next token is not `t`.
pub fn expect(&mut self, t: &TokenKind) -> PResult<'a, Recovered> { pub fn expect(&mut self, t: &TokenKind) -> PResult<'a, Recovered> {
if self.expected_tokens.is_empty() { if self.expected_tokens.is_empty() {
@ -1278,7 +1284,11 @@ impl<'a> Parser<'a> {
} }
fn parse_delim_args(&mut self) -> PResult<'a, P<DelimArgs>> { fn parse_delim_args(&mut self) -> PResult<'a, P<DelimArgs>> {
if let Some(args) = self.parse_delim_args_inner() { Ok(P(args)) } else { self.unexpected() } if let Some(args) = self.parse_delim_args_inner() {
Ok(P(args))
} else {
self.unexpected_any()
}
} }
fn parse_attr_args(&mut self) -> PResult<'a, AttrArgs> { fn parse_attr_args(&mut self) -> PResult<'a, AttrArgs> {

View file

@ -660,7 +660,7 @@ impl<'a> Parser<'a> {
// Add `>` to the list of expected tokens. // Add `>` to the list of expected tokens.
self.check(&token::Gt); self.check(&token::Gt);
// Handle `,` to `;` substitution // Handle `,` to `;` substitution
let mut err = self.unexpected::<()>().unwrap_err(); let mut err = self.unexpected().unwrap_err();
self.bump(); self.bump();
err.span_suggestion_verbose( err.span_suggestion_verbose(
self.prev_token.span.until(self.token.span), self.prev_token.span.until(self.token.span),