nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 08:13:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add ErrorGuaranteed to ast::LitKind::Err, token::LitKind::Err.

Browse Source 
This mostly works well, and eliminates a couple of delayed bugs.

One annoying thing is that we should really also add an
`ErrorGuaranteed` to `proc_macro::bridge::LitKind::Err`. But that's
difficult because `proc_macro` doesn't have access to `ErrorGuaranteed`,
so we have to fake it.
This commit is contained in:
Nicholas Nethercote 2024-02-14 20:12:05 +11:00
parent 332c57723a
commit 25ed6e43b0
26 changed files with 85 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_ast/src/ast.rs
View File

@ -1846,7 +1846,7 @@ pub enum LitKind {
/// A boolean literal (`true`, `false`).
Bool(bool),
/// Placeholder for a literal that wasn't well-formed in some way.
Err,
Err(ErrorGuaranteed),
}
impl LitKind {
@ -1893,7 +1893,7 @@ impl LitKind {
| LitKind::Int(_, LitIntType::Unsuffixed)
| LitKind::Float(_, LitFloatType::Unsuffixed)
| LitKind::Bool(..)
| LitKind::Err => false,
| LitKind::Err(_) => false,
}
}
}

12
compiler/rustc_ast/src/token.rs
View File

@ -13,7 +13,7 @@ use rustc_macros::HashStable_Generic;
use rustc_span::symbol::{kw, sym};
#[allow(hidden_glob_reexports)]
use rustc_span::symbol::{Ident, Symbol};
use rustc_span::{edition::Edition, Span, DUMMY_SP};
use rustc_span::{edition::Edition, ErrorGuaranteed, Span, DUMMY_SP};
use std::borrow::Cow;
use std::fmt;
@ -75,7 +75,7 @@ pub enum LitKind {
ByteStrRaw(u8), // raw byte string delimited by `n` hash symbols
CStr,
CStrRaw(u8),
Err,
Err(ErrorGuaranteed),
}
/// A literal token.
@ -144,7 +144,7 @@ impl fmt::Display for Lit {
CStrRaw(n) => {
write!(f, "cr{delim}\"{symbol}\"{delim}", delim = "#".repeat(n as usize))?
}
Integer | Float | Bool | Err => write!(f, "{symbol}")?,
Integer | Float | Bool | Err(_) => write!(f, "{symbol}")?,
}
if let Some(suffix) = suffix {
@ -159,7 +159,7 @@ impl LitKind {
/// An English article for the literal token kind.
pub fn article(self) -> &'static str {
match self {
Integer | Err => "an",
Integer | Err(_) => "an",
_ => "a",
}
}
@ -174,12 +174,12 @@ impl LitKind {
Str | StrRaw(..) => "string",
ByteStr | ByteStrRaw(..) => "byte string",
CStr | CStrRaw(..) => "C string",
Err => "error",
Err(_) => "error",
}
}
pub(crate) fn may_have_suffix(self) -> bool {
matches!(self, Integer | Float | Err)
matches!(self, Integer | Float | Err(_))
}
}

6
compiler/rustc_ast/src/util/literal.rs
View File

@ -144,7 +144,7 @@ impl LitKind {
buf.push(0);
LitKind::CStr(buf.into(), StrStyle::Raw(n))
}
token::Err => LitKind::Err,
token::Err(guar) => LitKind::Err(guar),
})
}
}
@ -201,7 +201,7 @@ impl fmt::Display for LitKind {
}
}
LitKind::Bool(b) => write!(f, "{}", if b { "true" } else { "false" })?,
LitKind::Err => {
LitKind::Err(_) => {
// This only shows up in places like `-Zunpretty=hir` output, so we
// don't bother to produce something useful.
write!(f, "<bad-literal>")?;
@ -237,7 +237,7 @@ impl MetaItemLit {
LitKind::Char(_) => token::Char,
LitKind::Int(..) => token::Integer,
LitKind::Float(..) => token::Float,
LitKind::Err => token::Err,
LitKind::Err(guar) => token::Err(guar),
};
token::Lit::new(kind, self.symbol, self.suffix)

9
compiler/rustc_ast_lowering/src/expr.rs
View File

@ -124,8 +124,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
let lit_kind = match LitKind::from_token_lit(*token_lit) {
Ok(lit_kind) => lit_kind,
Err(err) => {
report_lit_error(&self.tcx.sess.parse_sess, err, *token_lit, e.span);
LitKind::Err
let guar = report_lit_error(
&self.tcx.sess.parse_sess,
err,
*token_lit,
e.span,
);
LitKind::Err(guar)
}
};
let lit = self.arena.alloc(respan(self.lower_span(e.span), lit_kind));

3
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -966,10 +966,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
{
lit
} else {
let guar = self.dcx().has_errors().unwrap();
MetaItemLit {
symbol: kw::Empty,
suffix: None,
kind: LitKind::Err,
kind: LitKind::Err(guar),
span: DUMMY_SP,
}
};

2
compiler/rustc_ast_pretty/src/pprust/state.rs
View File

@ -254,7 +254,7 @@ fn literal_to_string(lit: token::Lit) -> String {
token::CStrRaw(n) => {
format!("cr{delim}\"{symbol}\"{delim}", delim = "#".repeat(n as usize))
}
token::Integer | token::Float | token::Bool | token::Err => symbol.to_string(),
token::Integer | token::Float | token::Bool | token::Err(_) => symbol.to_string(),
};
if let Some(suffix) = suffix {

2
compiler/rustc_builtin_macros/src/concat.rs
View File

@ -40,7 +40,7 @@ pub fn expand_concat(
cx.dcx().emit_err(errors::ConcatBytestr { span: e.span });
has_errors = true;
}
Ok(ast::LitKind::Err) => {
Ok(ast::LitKind::Err(_)) => {
has_errors = true;
}
Err(err) => {

2
compiler/rustc_builtin_macros/src/concat_bytes.rs
View File

@ -44,7 +44,7 @@ fn invalid_type_err(
Ok(ast::LitKind::Bool(_)) => {
dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "boolean", sugg: None });
}
Ok(ast::LitKind::Err) => {}
Ok(ast::LitKind::Err(_)) => {}
Ok(ast::LitKind::Int(_, _)) if !is_nested => {
let sugg =
snippet.map(|snippet| ConcatBytesInvalidSuggestion::IntLit { span: span, snippet });

2
compiler/rustc_expand/src/base.rs
View File

@ -1266,7 +1266,7 @@ pub fn expr_to_spanned_string<'a>(
);
Some((err, true))
}
Ok(ast::LitKind::Err) => None,
Ok(ast::LitKind::Err(_)) => None,
Err(err) => {
report_lit_error(&cx.sess.parse_sess, err, token_lit, expr.span);
None

22
compiler/rustc_expand/src/proc_macro_server.rs
View File

@ -10,7 +10,7 @@ use rustc_ast::util::literal::escape_byte_str_symbol;
use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sync::Lrc;
use rustc_errors::{MultiSpan, PResult};
use rustc_errors::{ErrorGuaranteed, MultiSpan, PResult};
use rustc_parse::lexer::nfc_normalize;
use rustc_parse::parse_stream_from_source_str;
use rustc_session::parse::ParseSess;
@ -63,7 +63,12 @@ impl FromInternal<token::LitKind> for LitKind {
token::ByteStrRaw(n) => LitKind::ByteStrRaw(n),
token::CStr => LitKind::CStr,
token::CStrRaw(n) => LitKind::CStrRaw(n),
token::Err => LitKind::Err,
token::Err(_guar) => {
// This is the only place a `pm::bridge::LitKind::ErrWithGuar`
// is constructed. Note that an `ErrorGuaranteed` is available,
// as required. See the comment in `to_internal`.
LitKind::ErrWithGuar
}
token::Bool => unreachable!(),
}
}
@ -82,7 +87,16 @@ impl ToInternal<token::LitKind> for LitKind {
LitKind::ByteStrRaw(n) => token::ByteStrRaw(n),
LitKind::CStr => token::CStr,
LitKind::CStrRaw(n) => token::CStrRaw(n),
LitKind::Err => token::Err,
LitKind::ErrWithGuar => {
// This is annoying but valid. `LitKind::ErrWithGuar` would
// have an `ErrorGuaranteed` except that type isn't available
// in that crate. So we have to fake one. And we don't want to
// use a delayed bug because there might be lots of these,
// which would be expensive.
#[allow(deprecated)]
let guar = ErrorGuaranteed::unchecked_error_guaranteed();
token::Err(guar)
}
}
}
}
@ -477,7 +491,7 @@ impl server::FreeFunctions for Rustc<'_, '_> {
| token::LitKind::ByteStrRaw(_)
| token::LitKind::CStr
| token::LitKind::CStrRaw(_)
| token::LitKind::Err => return Err(()),
| token::LitKind::Err(_) => return Err(()),
token::LitKind::Integer | token::LitKind::Float => {}
}

2
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -1319,7 +1319,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
tcx.type_of(tcx.require_lang_item(hir::LangItem::CStr, Some(lit.span)))
.skip_binder(),
),
ast::LitKind::Err => Ty::new_misc_error(tcx),
ast::LitKind::Err(guar) => Ty::new_error(tcx, guar),
}
}

6
compiler/rustc_mir_build/src/build/expr/as_constant.rs
View File

@ -164,11 +164,7 @@ fn lit_to_mir_constant<'tcx>(
})?,
(ast::LitKind::Bool(b), ty::Bool) => ConstValue::Scalar(Scalar::from_bool(*b)),
(ast::LitKind::Char(c), ty::Char) => ConstValue::Scalar(Scalar::from_char(*c)),
(ast::LitKind::Err, _) => {
return Err(LitToConstError::Reported(
tcx.dcx().delayed_bug("encountered LitKind::Err during mir build"),
));
}
(ast::LitKind::Err(guar), _) => return Err(LitToConstError::Reported(*guar)),
_ => return Err(LitToConstError::TypeError),
};

6
compiler/rustc_mir_build/src/thir/constant.rs
View File

@ -71,11 +71,7 @@ pub(crate) fn lit_to_const<'tcx>(
ty::ValTree::from_scalar_int(bits)
}
(ast::LitKind::Char(c), ty::Char) => ty::ValTree::from_scalar_int((*c).into()),
(ast::LitKind::Err, _) => {
return Err(LitToConstError::Reported(
tcx.dcx().delayed_bug("encountered LitKind::Err during mir build"),
));
}
(ast::LitKind::Err(guar), _) => return Err(LitToConstError::Reported(*guar)),
_ => return Err(LitToConstError::TypeError),
};

12
compiler/rustc_mir_build/src/thir/cx/expr.rs
View File

@ -897,12 +897,14 @@ impl<'tcx> Cx<'tcx> {
let hir_id = self.tcx.local_def_id_to_hir_id(def_id.expect_local());
let generics = self.tcx.generics_of(hir_id.owner);
let Some(&index) = generics.param_def_id_to_index.get(&def_id) else {
self.tcx.dcx().has_errors().unwrap();
let guar = self.tcx.dcx().has_errors().unwrap();
// We already errored about a late bound const
return ExprKind::Literal {
lit: &Spanned { span: DUMMY_SP, node: LitKind::Err },
neg: false,
};
let lit = self
.tcx
.hir_arena
.alloc(Spanned { span: DUMMY_SP, node: LitKind::Err(guar) });
return ExprKind::Literal { lit, neg: false };
};
let name = self.tcx.hir().name(hir_id);
let param = ty::ParamConst::new(index, name);

22
compiler/rustc_parse/src/lexer/mod.rs
View File

@ -481,8 +481,8 @@ impl<'sess, 'src> StringReader<'sess, 'src> {
let mut kind = token::Integer;
if empty_int {
let span = self.mk_sp(start, end);
self.dcx().emit_err(errors::NoDigitsLiteral { span });
kind = token::Err;
let guar = self.dcx().emit_err(errors::NoDigitsLiteral { span });
kind = token::Err(guar);
} else if matches!(base, Base::Binary | Base::Octal) {
let base = base as u32;
let s = self.str_from_to(start + BytePos(2), end);
@ -492,8 +492,9 @@ impl<'sess, 'src> StringReader<'sess, 'src> {
start + BytePos::from_usize(2 + idx + c.len_utf8()),
);
if c != '_' && c.to_digit(base).is_none() {
self.dcx().emit_err(errors::InvalidDigitLiteral { span, base });
kind = token::Err;
let guar =
self.dcx().emit_err(errors::InvalidDigitLiteral { span, base });
kind = token::Err(guar);
}
}
}
@ -711,7 +712,7 @@ impl<'sess, 'src> StringReader<'sess, 'src> {
let hi = lo + BytePos(end - start);
let span = self.mk_sp(lo, hi);
let is_fatal = err.is_fatal();
if let Some(_guar) = emit_unescape_error(
if let Some(guar) = emit_unescape_error(
self.dcx(),
lit_content,
span_with_quotes,
@ -721,18 +722,19 @@ impl<'sess, 'src> StringReader<'sess, 'src> {
err,
) {
assert!(is_fatal);
kind = token::Err;
kind = token::Err(guar);
}
}
});
// We normally exclude the quotes for the symbol, but for errors we
// include it because it results in clearer error messages.
if kind != token::Err {
(kind, Symbol::intern(lit_content))
let sym = if !matches!(kind, token::Err(_)) {
Symbol::intern(lit_content)
} else {
(token::Err, self.symbol_from_to(start, end))
}
self.symbol_from_to(start, end)
};
(kind, sym)
}
fn cook_unicode(

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

@ -2140,12 +2140,12 @@ impl<'a> Parser<'a> {
Err(err) => {
let span = token.uninterpolated_span();
self.bump();
report_lit_error(self.sess, err, lit, span);
let guar = report_lit_error(self.sess, err, lit, span);
// Pack possible quotes and prefixes from the original literal into
// the error literal's symbol so they can be pretty-printed faithfully.
let suffixless_lit = token::Lit::new(lit.kind, lit.symbol, None);
let symbol = Symbol::intern(&suffixless_lit.to_string());
let lit = token::Lit::new(token::Err, symbol, lit.suffix);
let lit = token::Lit::new(token::Err(guar), symbol, lit.suffix);
Some(
MetaItemLit::from_token_lit(lit, span)
.unwrap_or_else(|_| unreachable!()),

2
compiler/rustc_parse/src/parser/mod.rs
View File

@ -1459,7 +1459,7 @@ impl<'a> Parser<'a> {
match self.parse_str_lit() {
Ok(str_lit) => Some(str_lit),
Err(Some(lit)) => match lit.kind {
ast::LitKind::Err => None,
ast::LitKind::Err(_) => None,
_ => {
self.dcx().emit_err(NonStringAbiLiteral { span: lit.span });
None

4
compiler/rustc_parse/src/validate_attr.rs
View File

@ -70,11 +70,11 @@ pub fn parse_meta<'a>(sess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Meta
}
}
Err(err) => {
report_lit_error(sess, err, token_lit, expr.span);
let guar = report_lit_error(sess, err, token_lit, expr.span);
let lit = ast::MetaItemLit {
symbol: token_lit.symbol,
suffix: token_lit.suffix,
kind: ast::LitKind::Err,
kind: ast::LitKind::Err(guar),
span: expr.span,
};
MetaItemKind::NameValue(lit)

8
library/proc_macro/src/bridge/mod.rs
View File

@ -337,7 +337,11 @@ pub enum LitKind {
ByteStrRaw(u8),
CStr,
CStrRaw(u8),
Err,
// This should have an `ErrorGuaranteed`, except that type isn't available
// in this crate. (Imagine it is there.) Hence the `WithGuar` suffix. Must
// only be constructed in `LitKind::from_internal`, where an
// `ErrorGuaranteed` is available.
ErrWithGuar,
}
rpc_encode_decode!(
@ -352,7 +356,7 @@ rpc_encode_decode!(
ByteStrRaw(n),
CStr,
CStrRaw(n),
Err,
ErrWithGuar,
}
);

2
library/proc_macro/src/lib.rs
View File

@ -1451,7 +1451,7 @@ impl Literal {
f(&["cr", hashes, "\"", symbol, "\"", hashes, suffix])
}
bridge::LitKind::Integer | bridge::LitKind::Float | bridge::LitKind::Err => {
bridge::LitKind::Integer | bridge::LitKind::Float | bridge::LitKind::ErrWithGuar => {
f(&[symbol, suffix])
}
})

3
src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
View File

@ -295,7 +295,8 @@ impl<'a> NormalizedPat<'a> {
LitKind::Char(val) => Self::LitInt(val.into()),
LitKind::Int(val, _) => Self::LitInt(val.get()),
LitKind::Bool(val) => Self::LitBool(val),
LitKind::Float(..) | LitKind::Err => Self::Wild,
LitKind::Float(..) => Self::Wild,
LitKind::Err(guar) => Self::Err(guar),
},
_ => Self::Wild,
},

2
src/tools/clippy/clippy_lints/src/redundant_type_annotations.rs
View File

@ -200,7 +200,7 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
}
},
LitKind::Err => (),
LitKind::Err(_) => (),
LitKind::ByteStr(..) => {
// We only lint if the type annotation is an array type (e.g. &[u8; 4]).
// If instead it is a slice (e.g. &[u8]) it may not be redundant, so we

2
src/tools/clippy/clippy_lints/src/utils/author.rs
View File

@ -279,7 +279,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
match lit.value.node {
LitKind::Bool(val) => kind!("Bool({val:?})"),
LitKind::Char(c) => kind!("Char({c:?})"),
LitKind::Err => kind!("Err"),
LitKind::Err(_) => kind!("Err"),
LitKind::Byte(b) => kind!("Byte({b})"),
LitKind::Int(i, suffix) => {
let int_ty = match suffix {

2
src/tools/clippy/clippy_utils/src/consts.rs
View File

@ -286,7 +286,7 @@ pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constan
_ => bug!(),
},
LitKind::Bool(b) => Constant::Bool(b),
LitKind::Err => Constant::Err,
LitKind::Err(_) => Constant::Err,
}
}

4
src/tools/rust-analyzer/crates/proc-macro-srv/src/server/rust_analyzer_span.rs
View File

@ -72,7 +72,7 @@ impl server::FreeFunctions for RaSpanServer {
) -> Result<bridge::Literal<Self::Span, Self::Symbol>, ()> {
// FIXME: keep track of LitKind and Suffix
Ok(bridge::Literal {
kind: bridge::LitKind::Err,
kind: bridge::LitKind::Integer, // dummy
symbol: Symbol::intern(self.interner, s),
suffix: None,
span: self.call_site,
@ -202,7 +202,7 @@ impl server::TokenStream for RaSpanServer {
tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => {
bridge::TokenTree::Literal(bridge::Literal {
// FIXME: handle literal kinds
kind: bridge::LitKind::Err,
kind: bridge::LitKind::Integer, // dummy
symbol: Symbol::intern(self.interner, &lit.text),
// FIXME: handle suffixes
suffix: None,

4
src/tools/rust-analyzer/crates/proc-macro-srv/src/server/token_id.rs
View File

@ -64,7 +64,7 @@ impl server::FreeFunctions for TokenIdServer {
) -> Result<bridge::Literal<Self::Span, Self::Symbol>, ()> {
// FIXME: keep track of LitKind and Suffix
Ok(bridge::Literal {
kind: bridge::LitKind::Err,
kind: bridge::LitKind::Integer, // dummy
symbol: Symbol::intern(self.interner, s),
suffix: None,
span: self.call_site,
@ -187,7 +187,7 @@ impl server::TokenStream for TokenIdServer {
tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => {
bridge::TokenTree::Literal(bridge::Literal {
// FIXME: handle literal kinds
kind: bridge::LitKind::Err,
kind: bridge::LitKind::Integer, // dummy
symbol: Symbol::intern(self.interner, &lit.text),
// FIXME: handle suffixes
suffix: None,