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

Remove ParseSess methods that duplicate DiagCtxt methods.

Browse source 
Also add missing `#[track_caller]` attributes to `DiagCtxt` methods as
necessary to keep tests working.
This commit is contained in:
Nicholas Nethercote 2023-12-18 21:14:02 +11:00
parent ec9af0d6cb
commit d51db05d7e
22 changed files with 256 additions and 308 deletions
Download patch file Download diff file Expand all files Collapse all files

36
compiler/rustc_parse/src/parser/ty.rs
View file

@ -213,7 +213,7 @@ impl<'a> Parser<'a> {
// Don't `eat` to prevent `=>` from being added as an expected token which isn't
// actually expected and could only confuse users
self.bump();
self.sess.emit_err(ReturnTypesUseThinArrow { span: self.prev_token.span });
self.dcx().emit_err(ReturnTypesUseThinArrow { span: self.prev_token.span });
let ty = self.parse_ty_common(
allow_plus,
AllowCVariadic::No,
@ -288,7 +288,7 @@ impl<'a> Parser<'a> {
let parse_plus = allow_plus == AllowPlus::Yes && self.check_plus();
let kind =
self.parse_remaining_bounds_path(lifetime_defs, path, lo, parse_plus)?;
let mut err = self.sess.create_err(errors::TransposeDynOrImpl {
let mut err = self.dcx().create_err(errors::TransposeDynOrImpl {
span: kw.span,
kw: kw.name.as_str(),
sugg: errors::TransposeDynOrImplSugg {
@ -335,7 +335,7 @@ impl<'a> Parser<'a> {
AllowCVariadic::No => {
// FIXME(Centril): Should we just allow `...` syntactically
// anywhere in a type and use semantic restrictions instead?
self.sess.emit_err(NestedCVariadicType { span: lo.to(self.prev_token.span) });
self.dcx().emit_err(NestedCVariadicType { span: lo.to(self.prev_token.span) });
TyKind::Err
}
}
@ -426,7 +426,7 @@ impl<'a> Parser<'a> {
let lt_no_plus = self.check_lifetime() && !self.look_ahead(1, |t| t.is_like_plus());
let bounds = self.parse_generic_bounds_common(allow_plus)?;
if lt_no_plus {
self.sess.emit_err(NeedPlusAfterTraitObjectLifetime { span: lo });
self.dcx().emit_err(NeedPlusAfterTraitObjectLifetime { span: lo });
}
Ok(TyKind::TraitObject(bounds, TraitObjectSyntax::None))
}
@ -460,7 +460,7 @@ impl<'a> Parser<'a> {
fn parse_ty_ptr(&mut self) -> PResult<'a, TyKind> {
let mutbl = self.parse_const_or_mut().unwrap_or_else(|| {
let span = self.prev_token.span;
self.sess.emit_err(ExpectedMutOrConstInRawPointerType {
self.dcx().emit_err(ExpectedMutOrConstInRawPointerType {
span,
after_asterisk: span.shrink_to_hi(),
});
@ -523,7 +523,7 @@ impl<'a> Parser<'a> {
} else {
(None, String::new())
};
self.sess.emit_err(LifetimeAfterMut { span, suggest_lifetime, snippet });
self.dcx().emit_err(LifetimeAfterMut { span, suggest_lifetime, snippet });
opt_lifetime = Some(self.expect_lifetime());
}
@ -533,7 +533,7 @@ impl<'a> Parser<'a> {
{
// We have `&dyn mut ...`, which is invalid and should be `&mut dyn ...`.
let span = and_span.to(self.look_ahead(1, |t| t.span));
self.sess.emit_err(DynAfterMut { span });
self.dcx().emit_err(DynAfterMut { span });
// Recovery
mutbl = Mutability::Mut;
@ -587,10 +587,10 @@ impl<'a> Parser<'a> {
// If we ever start to allow `const fn()`, then update
// feature gating for `#![feature(const_extern_fn)]` to
// cover it.
self.sess.emit_err(FnPointerCannotBeConst { span: whole_span, qualifier: span });
self.dcx().emit_err(FnPointerCannotBeConst { span: whole_span, qualifier: span });
}
if let Some(ast::CoroutineKind::Async { span, .. }) = coroutine_kind {
self.sess.emit_err(FnPointerCannotBeAsync { span: whole_span, qualifier: span });
self.dcx().emit_err(FnPointerCannotBeAsync { span: whole_span, qualifier: span });
}
// FIXME(gen_blocks): emit a similar error for `gen fn()`
let decl_span = span_start.to(self.token.span);
@ -634,7 +634,7 @@ impl<'a> Parser<'a> {
None
};
self.sess.emit_err(FnPtrWithGenerics { span: generics.span, sugg });
self.dcx().emit_err(FnPtrWithGenerics { span: generics.span, sugg });
params.append(&mut lifetimes);
Ok(())
}
@ -647,7 +647,7 @@ impl<'a> Parser<'a> {
if let token::Ident(sym, _) = t.kind {
// parse pattern with "'a Sized" we're supposed to give suggestion like
// "'a + Sized"
self.sess.emit_err(errors::MissingPlusBounds {
self.dcx().emit_err(errors::MissingPlusBounds {
span: self.token.span,
hi: self.token.span.shrink_to_hi(),
sym,
@ -739,7 +739,7 @@ impl<'a> Parser<'a> {
{
if self.token.is_keyword(kw::Dyn) {
// Account for `&dyn Trait + dyn Other`.
self.sess.emit_err(InvalidDynKeyword { span: self.token.span });
self.dcx().emit_err(InvalidDynKeyword { span: self.token.span });
self.bump();
}
bounds.push(self.parse_generic_bound()?);
@ -813,14 +813,14 @@ impl<'a> Parser<'a> {
match modifiers.constness {
BoundConstness::Never => {}
BoundConstness::Maybe(span) => {
self.sess.emit_err(errors::TildeConstLifetime { span });
self.dcx().emit_err(errors::TildeConstLifetime { span });
}
}
match modifiers.polarity {
BoundPolarity::Positive => {}
BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => {
self.sess.emit_err(errors::ModifierLifetime {
self.dcx().emit_err(errors::ModifierLifetime {
span,
sigil: modifiers.polarity.as_str(),
});
@ -839,7 +839,7 @@ impl<'a> Parser<'a> {
(None, String::new())
};
self.sess.emit_err(errors::ParenthesizedLifetime { span, sugg, snippet });
self.dcx().emit_err(errors::ParenthesizedLifetime { span, sugg, snippet });
Ok(())
}
@ -860,7 +860,7 @@ impl<'a> Parser<'a> {
} else if self.eat_keyword(kw::Const) {
let span = self.prev_token.span;
self.sess.gated_spans.gate(sym::const_trait_impl, span);
self.sess.emit_err(errors::ConstMissingTilde { span, start: span.shrink_to_lo() });
self.dcx().emit_err(errors::ConstMissingTilde { span, start: span.shrink_to_lo() });
BoundConstness::Maybe(span)
} else {
@ -960,7 +960,7 @@ impl<'a> Parser<'a> {
let bounds = vec![];
self.parse_remaining_bounds(bounds, true)?;
self.expect(&token::CloseDelim(Delimiter::Parenthesis))?;
self.sess.emit_err(errors::IncorrectParensTraitBounds {
self.dcx().emit_err(errors::IncorrectParensTraitBounds {
span: vec![lo, self.prev_token.span],
sugg: errors::IncorrectParensTraitBoundsSugg {
wrong_span: leading_token.span.shrink_to_hi().to(lo),
@ -984,7 +984,7 @@ impl<'a> Parser<'a> {
let snapshot = self.create_snapshot_for_diagnostic();
match self.parse_fn_decl(|_| false, AllowPlus::No, RecoverReturnSign::OnlyFatArrow) {
Ok(decl) => {
self.sess.emit_err(ExpectedFnPathFoundFnKeyword { fn_token_span });
self.dcx().emit_err(ExpectedFnPathFoundFnKeyword { fn_token_span });
Some(ast::Path {
span: fn_token_span.to(self.prev_token.span),
segments: thin_vec![ast::PathSegment {