bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

inline format!() args up to and including rustc_middle

Browse source
This commit is contained in:
Matthias Krüger 2023-07-25 22:00:13 +02:00
parent 2e0136a131
commit 23815467a2
87 changed files with 378 additions and 437 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_parse/src/lexer/diagnostics.rs
View file

@ -46,7 +46,7 @@ pub fn report_missing_open_delim(
};
err.span_label(
unmatch_brace.found_span.shrink_to_lo(),
format!("missing open `{}` for this delimiter", missed_open),
format!("missing open `{missed_open}` for this delimiter"),
);
reported_missing_open = true;
}

2
compiler/rustc_parse/src/lexer/tokentrees.rs
View file

@ -198,7 +198,7 @@ impl<'a> TokenTreesReader<'a> {
// An unexpected closing delimiter (i.e., there is no
// matching opening delimiter).
let token_str = token_to_string(&self.token);
let msg = format!("unexpected closing delimiter: `{}`", token_str);
let msg = format!("unexpected closing delimiter: `{token_str}`");
let mut err = self.string_reader.sess.span_diagnostic.struct_span_err(self.token.span, msg);
report_suspicious_mismatch_block(

15
compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
View file

@ -135,7 +135,7 @@ pub(crate) fn emit_unescape_error(
"unknown character escape"
};
let ec = escaped_char(c);
let mut diag = handler.struct_span_err(span, format!("{}: `{}`", label, ec));
let mut diag = handler.struct_span_err(span, format!("{label}: `{ec}`"));
diag.span_label(span, label);
if c == '{' || c == '}' && matches!(mode, Mode::Str | Mode::RawStr) {
diag.help(
@ -151,7 +151,7 @@ pub(crate) fn emit_unescape_error(
diag.span_suggestion(
span_with_quotes,
"if you meant to write a literal backslash (perhaps escaping in a regular expression), consider a raw string literal",
format!("r\"{}\"", lit),
format!("r\"{lit}\""),
Applicability::MaybeIncorrect,
);
}
@ -180,21 +180,20 @@ pub(crate) fn emit_unescape_error(
Mode::RawByteStr => "raw byte string literal",
_ => panic!("non-is_byte literal paired with NonAsciiCharInByte"),
};
let mut err = handler.struct_span_err(span, format!("non-ASCII character in {}", desc));
let mut err = handler.struct_span_err(span, format!("non-ASCII character in {desc}"));
let postfix = if unicode_width::UnicodeWidthChar::width(c).unwrap_or(1) == 0 {
format!(" but is {:?}", c)
format!(" but is {c:?}")
} else {
String::new()
};
err.span_label(span, format!("must be ASCII{}", postfix));
err.span_label(span, format!("must be ASCII{postfix}"));
// Note: the \\xHH suggestions are not given for raw byte string
// literals, because they are araw and so cannot use any escapes.
if (c as u32) <= 0xFF && mode != Mode::RawByteStr {
err.span_suggestion(
span,
format!(
"if you meant to use the unicode code point for {:?}, use a \\xHH escape",
c
"if you meant to use the unicode code point for {c:?}, use a \\xHH escape"
),
format!("\\x{:X}", c as u32),
Applicability::MaybeIncorrect,
@ -206,7 +205,7 @@ pub(crate) fn emit_unescape_error(
utf8.push(c);
err.span_suggestion(
span,
format!("if you meant to use the UTF-8 encoding of {:?}, use \\xHH escapes", c),
format!("if you meant to use the UTF-8 encoding of {c:?}, use \\xHH escapes"),
utf8.as_bytes()
.iter()
.map(|b: &u8| format!("\\x{:X}", *b))

2
compiler/rustc_parse/src/lexer/unicode_chars.rs
View file

@ -349,7 +349,7 @@ pub(super) fn check_for_substitution(
let span = Span::with_root_ctxt(pos, pos + Pos::from_usize(ch.len_utf8() * count));
let Some((_, ascii_name, token)) = ASCII_ARRAY.iter().find(|&&(s, _, _)| s == ascii_str) else {
let msg = format!("substitution character not found for '{}'", ch);
let msg = format!("substitution character not found for '{ch}'");
reader.sess.span_diagnostic.span_bug_no_panic(span, msg);
return (None, None);
};

2
compiler/rustc_parse/src/lib.rs
View file

@ -247,7 +247,7 @@ pub fn parse_cfg_attr(
match parse_in(parse_sess, tokens.clone(), "`cfg_attr` input", |p| p.parse_cfg_attr()) {
Ok(r) => return Some(r),
Err(mut e) => {
e.help(format!("the valid syntax is `{}`", CFG_ATTR_GRAMMAR_HELP))
e.help(format!("the valid syntax is `{CFG_ATTR_GRAMMAR_HELP}`"))
.note(CFG_ATTR_NOTE_REF)
.emit();
}

17
compiler/rustc_parse/src/parser/attr_wrapper.rs
View file

@ -145,13 +145,11 @@ impl ToAttrTokenStream for LazyAttrTokenStreamImpl {
// another replace range will capture the *replaced* tokens for the inner
// range, not the original tokens.
for (range, new_tokens) in replace_ranges.into_iter().rev() {
assert!(!range.is_empty(), "Cannot replace an empty range: {:?}", range);
assert!(!range.is_empty(), "Cannot replace an empty range: {range:?}");
// Replace ranges are only allowed to decrease the number of tokens.
assert!(
range.len() >= new_tokens.len(),
"Range {:?} has greater len than {:?}",
range,
new_tokens
"Range {range:?} has greater len than {new_tokens:?}"
);
// Replace any removed tokens with `FlatToken::Empty`.
@ -409,22 +407,19 @@ fn make_token_stream(
FlatToken::Token(Token { kind: TokenKind::CloseDelim(delim), span }) => {
let frame_data = stack
.pop()
.unwrap_or_else(|| panic!("Token stack was empty for token: {:?}", token));
.unwrap_or_else(|| panic!("Token stack was empty for token: {token:?}"));
let (open_delim, open_sp) = frame_data.open_delim_sp.unwrap();
assert_eq!(
open_delim, delim,
"Mismatched open/close delims: open={:?} close={:?}",
open_delim, span
"Mismatched open/close delims: open={open_delim:?} close={span:?}"
);
let dspan = DelimSpan::from_pair(open_sp, span);
let stream = AttrTokenStream::new(frame_data.inner);
let delimited = AttrTokenTree::Delimited(dspan, delim, stream);
stack
.last_mut()
.unwrap_or_else(|| {
panic!("Bottom token frame is missing for token: {:?}", token)
})
.unwrap_or_else(|| panic!("Bottom token frame is missing for token: {token:?}"))
.inner
.push(delimited);
}
@ -456,7 +451,7 @@ fn make_token_stream(
.inner
.push(AttrTokenTree::Token(Token::new(unglued_first, first_span), spacing));
} else {
panic!("Unexpected last token {:?}", last_token)
panic!("Unexpected last token {last_token:?}")
}
}
AttrTokenStream::new(final_buf.inner)

4
compiler/rustc_parse/src/parser/diagnostics.rs
View file

@ -612,13 +612,13 @@ impl<'a> Parser<'a> {
if let TokenKind::Ident(prev, _) = &self.prev_token.kind
&& let TokenKind::Ident(cur, _) = &self.token.kind
{
let concat = Symbol::intern(&format!("{}{}", prev, cur));
let concat = Symbol::intern(&format!("{prev}{cur}"));
let ident = Ident::new(concat, DUMMY_SP);
if ident.is_used_keyword() || ident.is_reserved() || ident.is_raw_guess() {
let span = self.prev_token.span.to(self.token.span);
err.span_suggestion_verbose(
span,
format!("consider removing the space to spell keyword `{}`", concat),
format!("consider removing the space to spell keyword `{concat}`"),
concat,
Applicability::MachineApplicable,
);

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

@ -1052,7 +1052,7 @@ impl<'a> Parser<'a> {
}
components.push(Punct(c));
} else {
panic!("unexpected character in a float token: {:?}", c)
panic!("unexpected character in a float token: {c:?}")
}
}
if !ident_like.is_empty() {
@ -1113,7 +1113,7 @@ impl<'a> Parser<'a> {
self.error_unexpected_after_dot();
DestructuredFloat::Error
}
_ => panic!("unexpected components in a float token: {:?}", components),
_ => panic!("unexpected components in a float token: {components:?}"),
}
}

6
compiler/rustc_parse/src/parser/mod.rs
View file

@ -375,7 +375,7 @@ impl TokenType {
fn to_string(&self) -> String {
match self {
TokenType::Token(t) => format!("`{}`", pprust::token_kind_to_string(t)),
TokenType::Keyword(kw) => format!("`{}`", kw),
TokenType::Keyword(kw) => format!("`{kw}`"),
TokenType::Operator => "an operator".to_string(),
TokenType::Lifetime => "lifetime".to_string(),
TokenType::Ident => "identifier".to_string(),
@ -445,7 +445,7 @@ pub(super) fn token_descr(token: &Token) -> String {
TokenDescription::DocComment => "doc comment",
});
if let Some(kind) = kind { format!("{} `{}`", kind, name) } else { format!("`{}`", name) }
if let Some(kind) = kind { format!("{kind} `{name}`") } else { format!("`{name}`") }
}
impl<'a> Parser<'a> {
@ -929,7 +929,7 @@ impl<'a> Parser<'a> {
expect_err
.span_suggestion_short(
sp,
format!("missing `{}`", token_str),
format!("missing `{token_str}`"),
token_str,
Applicability::MaybeIncorrect,
)

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

@ -428,7 +428,7 @@ impl<'a> Parser<'a> {
);
let mut err = self_.struct_span_err(self_.token.span, msg);
err.span_label(self_.token.span, format!("expected {}", expected));
err.span_label(self_.token.span, format!("expected {expected}"));
err
});
PatKind::Lit(self.mk_expr(lo, ExprKind::Lit(lit)))
@ -664,7 +664,7 @@ impl<'a> Parser<'a> {
let msg = format!("expected {}, found {}", expected, super::token_descr(&self.token));
let mut err = self.struct_span_err(self.token.span, msg);
err.span_label(self.token.span, format!("expected {}", expected));
err.span_label(self.token.span, format!("expected {expected}"));
let sp = self.sess.source_map().start_point(self.token.span);
if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow().get(&sp) {
@ -977,7 +977,7 @@ impl<'a> Parser<'a> {
break;
}
let token_str = super::token_descr(&self.token);
let msg = format!("expected `}}`, found {}", token_str);
let msg = format!("expected `}}`, found {token_str}");
let mut err = self.struct_span_err(self.token.span, msg);
err.span_label(self.token.span, "expected `}`");

2
compiler/rustc_parse/src/parser/path.rs
View file

@ -679,7 +679,7 @@ impl<'a> Parser<'a> {
);
err.span_suggestion(
eq.to(before_next),
format!("remove the `=` if `{}` is a type", ident),
format!("remove the `=` if `{ident}` is a type"),
"",
Applicability::MaybeIncorrect,
)

9
compiler/rustc_parse/src/parser/stmt.rs
View file

@ -300,7 +300,7 @@ impl<'a> Parser<'a> {
Ok(ty) => (None, Some(ty)),
Err(mut err) => {
if let Ok(snip) = self.span_to_snippet(pat.span) {
err.span_label(pat.span, format!("while parsing the type for `{}`", snip));
err.span_label(pat.span, format!("while parsing the type for `{snip}`"));
}
// we use noexpect here because we don't actually expect Eq to be here
// but we are still checking for it in order to be able to handle it if
@ -502,7 +502,7 @@ impl<'a> Parser<'a> {
fn error_block_no_opening_brace<T>(&mut self) -> PResult<'a, T> {
let tok = super::token_descr(&self.token);
let msg = format!("expected `{{`, found {}", tok);
let msg = format!("expected `{{`, found {tok}");
Err(self.error_block_no_opening_brace_msg(Cow::from(msg)))
}
@ -638,10 +638,9 @@ impl<'a> Parser<'a> {
e.span_suggestion(
sp.with_hi(sp.lo() + BytePos(marker.len() as u32)),
format!(
"add a space before `{}` to use a regular comment",
doc_comment_marker,
"add a space before `{doc_comment_marker}` to use a regular comment",
),
format!("{} {}", comment_marker, doc_comment_marker),
format!("{comment_marker} {doc_comment_marker}"),
Applicability::MaybeIncorrect,
);
}