bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add an ErrorGuaranteed to ast::TyKind::Err.

Browse source 
This makes it more like `hir::TyKind::Err`, and avoids a
`span_delayed_bug` call in `LoweringContext::lower_ty_direct`.

It also requires adding `ast::TyKind::Dummy`, now that
`ast::TyKind::Err` can't be used for that purpose in the absence of an
error emission.

There are a couple of cases that aren't as neat as I would have liked,
marked with `FIXME` comments.
This commit is contained in:
Nicholas Nethercote 2024-02-14 14:50:49 +11:00
parent 502ce8287b
commit 5233bc91da
14 changed files with 75 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

26
compiler/rustc_parse/src/parser/item.rs
View file

@ -591,7 +591,23 @@ impl<'a> Parser<'a> {
let ty_second = if self.token == token::DotDot {
// We need to report this error after `cfg` expansion for compatibility reasons
self.bump(); // `..`, do not add it to expected tokens
Some(self.mk_ty(self.prev_token.span, TyKind::Err))
// FIXME(nnethercote): AST validation later detects this
// `TyKind::Err` and emits an errors. So why the unchecked
// ErrorGuaranteed?
// - A `span_delayed_bug` doesn't work here, because rustfmt can
// hit this path but then not hit the follow-up path in the AST
// validator that issues the error, which results in ICEs.
// - `TyKind::Dummy` doesn't work, because it ends up reaching HIR
// lowering, which results in ICEs. Changing `TyKind::Dummy` to
// `TyKind::Err` during AST validation might fix that, but that's
// not possible because AST validation doesn't allow mutability.
//
// #121072 will hopefully remove all this special handling of the
// obsolete `impl Trait for ..` and then this can go away.
#[allow(deprecated)]
let guar = rustc_errors::ErrorGuaranteed::unchecked_error_guaranteed();
Some(self.mk_ty(self.prev_token.span, TyKind::Err(guar)))
} else if has_for || self.token.can_begin_type() {
Some(self.parse_ty()?)
} else {
@ -2628,13 +2644,13 @@ impl<'a> Parser<'a> {
p.recover_diff_marker();
let snapshot = p.create_snapshot_for_diagnostic();
let param = p.parse_param_general(req_name, first_param).or_else(|e| {
e.emit();
let guar = e.emit();
let lo = p.prev_token.span;
p.restore_snapshot(snapshot);
// Skip every token until next possible arg or end.
p.eat_to_tokens(&[&token::Comma, &token::CloseDelim(Delimiter::Parenthesis)]);
// Create a placeholder argument for proper arg count (issue #34264).
Ok(dummy_arg(Ident::new(kw::Empty, lo.to(p.prev_token.span))))
Ok(dummy_arg(Ident::new(kw::Empty, lo.to(p.prev_token.span)), guar))
});
// ...now that we've parsed the first argument, `self` is no longer allowed.
first_param = false;
@ -2671,8 +2687,8 @@ impl<'a> Parser<'a> {
return if let Some(ident) =
this.parameter_without_type(&mut err, pat, is_name_required, first_param)
{
err.emit();
Ok((dummy_arg(ident), TrailingToken::None))
let guar = err.emit();
Ok((dummy_arg(ident, guar), TrailingToken::None))
} else {
Err(err)
};