nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-02 07:22:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use Session::diagnostic in more places.

Browse Source
This commit is contained in:
Nicholas Nethercote 2023-12-01 13:45:29 +11:00
parent a179a53565
commit 31ac4efb31
7 changed files with 33 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_parse/src/parser/attr.rs
View File

@ -56,7 +56,7 @@ impl<'a> Parser<'a> {
} else if let token::DocComment(comment_kind, attr_style, data) = self.token.kind {
if attr_style != ast::AttrStyle::Outer {
let span = self.token.span;
let mut err = self.sess.span_diagnostic.struct_span_err_with_code(
let mut err = self.diagnostic().struct_span_err_with_code(
span,
fluent::parse_inner_doc_comment_not_permitted,
error_code!(E0753),
@ -418,7 +418,7 @@ impl<'a> Parser<'a> {
}
Err(InvalidMetaItem { span: self.token.span, token: self.token.clone() }
.into_diagnostic(&self.sess.span_diagnostic))
.into_diagnostic(self.diagnostic()))
}
}

3
compiler/rustc_parse/src/parser/attr_wrapper.rs
View File

@ -266,8 +266,7 @@ impl<'a> Parser<'a> {
if let Some(attr_range) = self.capture_state.inner_attr_ranges.remove(&inner_attr.id) {
inner_attr_replace_ranges.push(attr_range);
} else {
self.sess
.span_diagnostic
self.diagnostic()
.span_delayed_bug(inner_attr.span, "Missing token range for attribute");
}
}

19
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -247,11 +247,11 @@ impl<'a> Parser<'a> {
sp: S,
m: impl Into<DiagnosticMessage>,
) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
self.sess.span_diagnostic.struct_span_err(sp, m)
self.diagnostic().struct_span_err(sp, m)
}
pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: impl Into<String>) -> ! {
self.sess.span_diagnostic.span_bug(sp, m)
self.diagnostic().span_bug(sp, m)
}
pub(super) fn diagnostic(&self) -> &'a Handler {
@ -285,7 +285,7 @@ impl<'a> Parser<'a> {
span: self.prev_token.span,
missing_comma: None,
}
.into_diagnostic(&self.sess.span_diagnostic));
.into_diagnostic(self.diagnostic()));
}
let valid_follow = &[
@ -348,7 +348,7 @@ impl<'a> Parser<'a> {
suggest_remove_comma,
help_cannot_start_number,
};
let mut err = err.into_diagnostic(&self.sess.span_diagnostic);
let mut err = err.into_diagnostic(self.diagnostic());
// if the token we have is a `<`
// it *might* be a misplaced generic
@ -1426,7 +1426,7 @@ impl<'a> Parser<'a> {
// Not entirely sure now, but we bubble the error up with the
// suggestion.
self.restore_snapshot(snapshot);
Err(err.into_diagnostic(&self.sess.span_diagnostic))
Err(err.into_diagnostic(self.diagnostic()))
}
}
} else if token::OpenDelim(Delimiter::Parenthesis) == self.token.kind {
@ -1441,7 +1441,7 @@ impl<'a> Parser<'a> {
}
// Consume the fn call arguments.
match self.consume_fn_args() {
Err(()) => Err(err.into_diagnostic(&self.sess.span_diagnostic)),
Err(()) => Err(err.into_diagnostic(self.diagnostic())),
Ok(()) => {
self.sess.emit_err(err);
// FIXME: actually check that the two expressions in the binop are
@ -1467,7 +1467,7 @@ impl<'a> Parser<'a> {
mk_err_expr(self, inner_op.span.to(self.prev_token.span))
} else {
// These cases cause too many knock-down errors, bail out (#61329).
Err(err.into_diagnostic(&self.sess.span_diagnostic))
Err(err.into_diagnostic(self.diagnostic()))
}
};
}
@ -2522,8 +2522,7 @@ impl<'a> Parser<'a> {
Ok(Some(GenericArg::Const(self.parse_const_arg()?)))
} else {
let after_kw_const = self.token.span;
self.recover_const_arg(after_kw_const, err.into_diagnostic(&self.sess.span_diagnostic))
.map(Some)
self.recover_const_arg(after_kw_const, err.into_diagnostic(self.diagnostic())).map(Some)
}
}
@ -2886,7 +2885,7 @@ impl<'a> Parser<'a> {
span: path.span.shrink_to_hi(),
between: between_span,
}
.into_diagnostic(&self.sess.span_diagnostic));
.into_diagnostic(self.diagnostic()));
}
}
}

18
compiler/rustc_parse/src/parser/expr.rs
View File

@ -1269,7 +1269,7 @@ impl<'a> Parser<'a> {
.collect(),
},
}
.into_diagnostic(&self.sess.span_diagnostic);
.into_diagnostic(self.diagnostic());
replacement_err.emit();
let old_err = mem::replace(err, replacement_err);
@ -1691,7 +1691,7 @@ impl<'a> Parser<'a> {
err: impl FnOnce(&Self) -> DiagnosticBuilder<'a, ErrorGuaranteed>,
) -> L {
if let Some(mut diag) =
self.sess.span_diagnostic.steal_diagnostic(lifetime.span, StashKey::LifetimeIsChar)
self.diagnostic().steal_diagnostic(lifetime.span, StashKey::LifetimeIsChar)
{
diag.span_suggestion_verbose(
lifetime.span.shrink_to_hi(),
@ -1882,7 +1882,7 @@ impl<'a> Parser<'a> {
let Some((ident, false)) = self.token.ident() else {
let err = errors::ExpectedBuiltinIdent { span: self.token.span }
.into_diagnostic(&self.sess.span_diagnostic);
.into_diagnostic(self.diagnostic());
return Err(err);
};
self.sess.gated_spans.gate(sym::builtin_syntax, ident.span);
@ -1893,7 +1893,7 @@ impl<'a> Parser<'a> {
Ok(res)
} else {
let err = errors::UnknownBuiltinConstruct { span: lo.to(ident.span), name: ident.name }
.into_diagnostic(&self.sess.span_diagnostic);
.into_diagnostic(self.diagnostic());
return Err(err);
};
self.expect(&TokenKind::CloseDelim(Delimiter::Parenthesis))?;
@ -1957,7 +1957,7 @@ impl<'a> Parser<'a> {
&& matches!(e.kind, ExprKind::Err)
{
let mut err = errors::InvalidInterpolatedExpression { span: self.token.span }
.into_diagnostic(&self.sess.span_diagnostic);
.into_diagnostic(self.diagnostic());
err.downgrade_to_delayed_bug();
return Err(err);
}
@ -2169,7 +2169,7 @@ impl<'a> Parser<'a> {
return Err(errors::MissingSemicolonBeforeArray {
open_delim: open_delim_span,
semicolon: prev_span.shrink_to_hi(),
}.into_diagnostic(&self.sess.span_diagnostic));
}.into_diagnostic(self.diagnostic()));
}
Ok(_) => (),
Err(err) => err.cancel(),
@ -2309,7 +2309,7 @@ impl<'a> Parser<'a> {
if self.check_keyword(kw::Async) {
let move_async_span = self.token.span.with_lo(self.prev_token.span.data().lo);
Err(errors::AsyncMoveOrderIncorrect { span: move_async_span }
.into_diagnostic(&self.sess.span_diagnostic))
.into_diagnostic(self.diagnostic()))
} else {
Ok(CaptureBy::Value { move_kw: move_kw_span })
}
@ -2499,7 +2499,7 @@ impl<'a> Parser<'a> {
};
if self.prev_token.kind == token::BinOp(token::Or) {
// This was part of a closure, the that part of the parser recover.
return Err(err.into_diagnostic(&self.sess.span_diagnostic));
return Err(err.into_diagnostic(self.diagnostic()));
} else {
Some(self.sess.emit_err(err))
}
@ -3148,7 +3148,7 @@ impl<'a> Parser<'a> {
let (attrs, body) = self.parse_inner_attrs_and_block()?;
if self.eat_keyword(kw::Catch) {
Err(errors::CatchAfterTry { span: self.prev_token.span }
.into_diagnostic(&self.sess.span_diagnostic))
.into_diagnostic(self.diagnostic()))
} else {
let span = span_lo.to(body.span);
self.sess.gated_spans.gate(sym::try_blocks, span);

17
compiler/rustc_parse/src/parser/item.rs
View File

@ -444,11 +444,7 @@ impl<'a> Parser<'a> {
None
};
if let Some(err) = err {
Err(err.into_diagnostic(&self.sess.span_diagnostic))
} else {
Ok(())
}
if let Some(err) = err { Err(err.into_diagnostic(self.diagnostic())) } else { Ok(()) }
}
fn parse_item_builtin(&mut self) -> PResult<'a, Option<ItemInfo>> {
@ -1382,8 +1378,7 @@ impl<'a> Parser<'a> {
let span = self.prev_token.span.shrink_to_hi();
let err: DiagnosticBuilder<'_, ErrorGuaranteed> =
errors::MissingConstType { span, colon, kind }
.into_diagnostic(&self.sess.span_diagnostic);
errors::MissingConstType { span, colon, kind }.into_diagnostic(self.diagnostic());
err.stash(span, StashKey::ItemNoType);
// The user intended that the type be inferred,
@ -1400,7 +1395,7 @@ impl<'a> Parser<'a> {
self.bump();
self.sess.emit_err(err);
} else {
return Err(err.into_diagnostic(&self.sess.span_diagnostic));
return Err(err.into_diagnostic(self.diagnostic()));
}
}
@ -1600,7 +1595,7 @@ impl<'a> Parser<'a> {
} else {
let err =
errors::UnexpectedTokenAfterStructName::new(self.token.span, self.token.clone());
return Err(err.into_diagnostic(&self.sess.span_diagnostic));
return Err(err.into_diagnostic(self.diagnostic()));
};
Ok((class_name, ItemKind::Struct(vdata, generics)))
@ -1796,7 +1791,7 @@ impl<'a> Parser<'a> {
let sp = previous_span.shrink_to_hi();
err.missing_comma = Some(sp);
}
return Err(err.into_diagnostic(&self.sess.span_diagnostic));
return Err(err.into_diagnostic(self.diagnostic()));
}
}
_ => {
@ -1846,7 +1841,7 @@ impl<'a> Parser<'a> {
// Make sure an error was emitted (either by recovering an angle bracket,
// or by finding an identifier as the next token), since we're
// going to continue parsing
assert!(self.sess.span_diagnostic.has_errors().is_some());
assert!(self.diagnostic().has_errors().is_some());
} else {
return Err(err);
}

8
compiler/rustc_parse/src/parser/nonterminal.rs
View File

@ -115,7 +115,7 @@ impl<'a> Parser<'a> {
Some(item) => NtItem(item),
None => {
return Err(UnexpectedNonterminal::Item(self.token.span)
.into_diagnostic(&self.sess.span_diagnostic));
.into_diagnostic(self.diagnostic()));
}
},
NonterminalKind::Block => {
@ -127,7 +127,7 @@ impl<'a> Parser<'a> {
Some(s) => NtStmt(P(s)),
None => {
return Err(UnexpectedNonterminal::Statement(self.token.span)
.into_diagnostic(&self.sess.span_diagnostic));
.into_diagnostic(self.diagnostic()));
}
},
NonterminalKind::PatParam { .. } | NonterminalKind::PatWithOr => {
@ -163,7 +163,7 @@ impl<'a> Parser<'a> {
span: self.token.span,
token: self.token.clone(),
}
.into_diagnostic(&self.sess.span_diagnostic));
.into_diagnostic(self.diagnostic()));
}
NonterminalKind::Path => {
NtPath(P(self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?))
@ -181,7 +181,7 @@ impl<'a> Parser<'a> {
span: self.token.span,
token: self.token.clone(),
}
.into_diagnostic(&self.sess.span_diagnostic));
.into_diagnostic(self.diagnostic()));
}
}
};

4
compiler/rustc_parse/src/parser/pat.rs
View File

@ -877,7 +877,7 @@ impl<'a> Parser<'a> {
// will direct us over to `parse_enum_variant()`.
if self.token == token::OpenDelim(Delimiter::Parenthesis) {
return Err(EnumPatternInsteadOfIdentifier { span: self.prev_token.span }
.into_diagnostic(&self.sess.span_diagnostic));
.into_diagnostic(self.diagnostic()));
}
Ok(PatKind::Ident(binding_annotation, ident, sub))
@ -991,7 +991,7 @@ impl<'a> Parser<'a> {
// check that a comma comes after every field
if !ate_comma {
let mut err = ExpectedCommaAfterPatternField { span: self.token.span }
.into_diagnostic(&self.sess.span_diagnostic);
.into_diagnostic(self.diagnostic());
if let Some(mut delayed) = delayed_err {
delayed.emit();
}