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

42
compiler/rustc_parse/src/parser/pat.rs
View file

@ -241,7 +241,7 @@ impl<'a> Parser<'a> {
Some(TopLevelOrPatternNotAllowedSugg::WrapInParens { span, pat })
};
let mut err = self.sess.create_err(match syntax_loc {
let mut err = self.dcx().create_err(match syntax_loc {
PatternLocation::LetBinding => {
TopLevelOrPatternNotAllowed::LetBinding { span, sub }
}
@ -268,7 +268,7 @@ impl<'a> Parser<'a> {
// a leading `||` probably doesn't indicate an or-pattern attempt, so we handle that
// separately.
if let token::OrOr = self.token.kind {
self.sess.emit_err(UnexpectedVertVertBeforeFunctionParam { span: self.token.span });
self.dcx().emit_err(UnexpectedVertVertBeforeFunctionParam { span: self.token.span });
self.bump();
}
@ -286,7 +286,7 @@ impl<'a> Parser<'a> {
EatOrResult::TrailingVert
} else if matches!(self.token.kind, token::OrOr) {
// Found `||`; Recover and pretend we parsed `|`.
self.sess.emit_err(UnexpectedVertVertInPattern { span: self.token.span, start: lo });
self.dcx().emit_err(UnexpectedVertVertInPattern { span: self.token.span, start: lo });
self.bump();
EatOrResult::AteOr
} else if self.eat(&token::BinOp(token::Or)) {
@ -321,7 +321,7 @@ impl<'a> Parser<'a> {
match (is_end_ahead, &self.token.kind) {
(true, token::BinOp(token::Or) | token::OrOr) => {
// A `|` or possibly `||` token shouldn't be here. Ban it.
self.sess.emit_err(TrailingVertNotAllowed {
self.dcx().emit_err(TrailingVertNotAllowed {
span: self.token.span,
start: lo,
token: self.token.clone(),
@ -349,7 +349,7 @@ impl<'a> Parser<'a> {
if self.token.is_keyword(kw::Let) && self.look_ahead(1, |tok| tok.can_begin_pattern()) {
self.bump();
self.sess.emit_err(RemoveLet { span: lo });
self.dcx().emit_err(RemoveLet { span: lo });
lo = self.token.span;
}
@ -390,7 +390,7 @@ impl<'a> Parser<'a> {
// Suggest `box ref`.
let span = self.prev_token.span.to(self.token.span);
self.bump();
self.sess.emit_err(SwitchRefBoxOrder { span });
self.dcx().emit_err(SwitchRefBoxOrder { span });
}
// Parse ref ident @ pat / ref mut ident @ pat
let mutbl = self.parse_mutability();
@ -493,7 +493,7 @@ impl<'a> Parser<'a> {
self.bump(); // `...`
// The user probably mistook `...` for a rest pattern `..`.
self.sess.emit_err(DotDotDotRestPattern { span: lo });
self.dcx().emit_err(DotDotDotRestPattern { span: lo });
PatKind::Rest
}
@ -527,7 +527,7 @@ impl<'a> Parser<'a> {
// The RHS is now the full pattern.
*sub = Some(lhs);
self.sess.emit_err(PatternOnWrongSideOfAt {
self.dcx().emit_err(PatternOnWrongSideOfAt {
whole_span,
whole_pat: pprust::pat_to_string(&rhs),
pattern: lhs_span,
@ -536,7 +536,7 @@ impl<'a> Parser<'a> {
} else {
// The special case above doesn't apply so we may have e.g. `A(x) @ B(y)`.
rhs.kind = PatKind::Wild;
self.sess.emit_err(ExpectedBindingLeftOfAt {
self.dcx().emit_err(ExpectedBindingLeftOfAt {
whole_span,
lhs: lhs.span,
rhs: rhs.span,
@ -558,7 +558,7 @@ impl<'a> Parser<'a> {
_ => return,
}
self.sess
self.dcx()
.emit_err(AmbiguousRangePattern { span: pat.span, pat: pprust::pat_to_string(pat) });
}
@ -568,7 +568,7 @@ impl<'a> Parser<'a> {
if let token::Lifetime(name) = self.token.kind {
self.bump(); // `'a`
self.sess
self.dcx()
.emit_err(UnexpectedLifetimeInPattern { span: self.prev_token.span, symbol: name });
}
@ -602,7 +602,7 @@ impl<'a> Parser<'a> {
let mut_span = self.prev_token.span;
if self.eat_keyword(kw::Ref) {
self.sess.emit_err(RefMutOrderIncorrect { span: mut_span.to(self.prev_token.span) });
self.dcx().emit_err(RefMutOrderIncorrect { span: mut_span.to(self.prev_token.span) });
return self.parse_pat_ident(BindingAnnotation::REF_MUT, syntax_loc);
}
@ -656,7 +656,7 @@ impl<'a> Parser<'a> {
/// Error on `mut $pat` where `$pat` is not an ident.
fn ban_mut_general_pat(&self, lo: Span, pat: &Pat, changed_any_binding: bool) {
self.sess.emit_err(if changed_any_binding {
self.dcx().emit_err(if changed_any_binding {
InvalidMutInPattern::NestedIdent {
span: lo.to(pat.span),
pat: pprust::pat_to_string(pat),
@ -674,7 +674,7 @@ impl<'a> Parser<'a> {
return;
}
self.sess.emit_err(RepeatedMutInPattern { span: lo.to(self.prev_token.span) });
self.dcx().emit_err(RepeatedMutInPattern { span: lo.to(self.prev_token.span) });
}
/// Parse macro invocation
@ -760,14 +760,14 @@ impl<'a> Parser<'a> {
let _ = self.parse_pat_range_end().map_err(|e| e.cancel());
}
self.sess.emit_err(InclusiveRangeExtraEquals { span: span_with_eq });
self.dcx().emit_err(InclusiveRangeExtraEquals { span: span_with_eq });
}
token::Gt if no_space => {
let after_pat = span.with_hi(span.hi() - rustc_span::BytePos(1)).shrink_to_hi();
self.sess.emit_err(InclusiveRangeMatchArrow { span, arrow: tok.span, after_pat });
self.dcx().emit_err(InclusiveRangeMatchArrow { span, arrow: tok.span, after_pat });
}
_ => {
self.sess.emit_err(InclusiveRangeNoEnd { span });
self.dcx().emit_err(InclusiveRangeNoEnd { span });
}
}
}
@ -780,7 +780,7 @@ impl<'a> Parser<'a> {
let end = self.parse_pat_range_end()?;
if let RangeEnd::Included(syn @ RangeSyntax::DotDotDot) = &mut re.node {
*syn = RangeSyntax::DotDotEq;
self.sess.emit_err(DotDotDotRangeToPatternNotAllowed { span: re.span });
self.dcx().emit_err(DotDotDotRangeToPatternNotAllowed { span: re.span });
}
Ok(PatKind::Range(None, Some(end), re))
}
@ -854,7 +854,7 @@ impl<'a> Parser<'a> {
&& self.check_noexpect(&token::Lt)
&& self.look_ahead(1, |t| t.can_begin_type())
{
return Err(self.sess.create_err(GenericArgsInPatRequireTurbofishSyntax {
return Err(self.dcx().create_err(GenericArgsInPatRequireTurbofishSyntax {
span: self.token.span,
suggest_turbofish: self.token.span.shrink_to_lo(),
}));
@ -942,7 +942,7 @@ impl<'a> Parser<'a> {
if self.isnt_pattern_start() {
let descr = super::token_descr(&self.token);
self.sess.emit_err(errors::BoxNotPat {
self.dcx().emit_err(errors::BoxNotPat {
span: self.token.span,
kw: box_span,
lo: box_span.shrink_to_lo(),
@ -1170,7 +1170,7 @@ impl<'a> Parser<'a> {
}
let token_str = pprust::token_to_string(&self.token);
self.sess.emit_err(DotDotDotForRemainingFields { span: self.token.span, token_str });
self.dcx().emit_err(DotDotDotForRemainingFields { span: self.token.span, token_str });
}
fn parse_pat_field(&mut self, lo: Span, attrs: AttrVec) -> PResult<'a, PatField> {