From 896b113ec3b777c72fd240c24a47792c90e65be4 Mon Sep 17 00:00:00 2001 From: Takayuki Maeda Date: Tue, 15 Mar 2022 19:13:56 +0900 Subject: [PATCH] use `format_args_capture` in some parts of rustc_parse --- compiler/rustc_parse/src/parser/attr.rs | 4 +- .../rustc_parse/src/parser/diagnostics.rs | 28 +++++----- compiler/rustc_parse/src/parser/expr.rs | 36 ++++++------- compiler/rustc_parse/src/parser/item.rs | 53 +++++++++---------- 4 files changed, 60 insertions(+), 61 deletions(-) diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs index 379e47077ea18..8f759ae84fa69 100644 --- a/compiler/rustc_parse/src/parser/attr.rs +++ b/compiler/rustc_parse/src/parser/attr.rs @@ -139,7 +139,7 @@ impl<'a> Parser<'a> { Ok(attr::mk_attr_from_item(item, None, style, attr_sp)) } else { let token_str = pprust::token_to_string(&this.token); - let msg = &format!("expected `#`, found `{}`", token_str); + let msg = &format!("expected `#`, found `{token_str}`"); Err(this.struct_span_err(this.token.span, msg)) } }) @@ -421,7 +421,7 @@ impl<'a> Parser<'a> { } let found = pprust::token_to_string(&self.token); - let msg = format!("expected unsuffixed literal or identifier, found `{}`", found); + let msg = format!("expected unsuffixed literal or identifier, found `{found}`"); Err(self.struct_span_err(self.token.span, &msg)) } } diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs index 21d5bec65f03a..1909e9ee74949 100644 --- a/compiler/rustc_parse/src/parser/diagnostics.rs +++ b/compiler/rustc_parse/src/parser/diagnostics.rs @@ -327,8 +327,8 @@ impl<'a> Parser<'a> { expect.clone() }; ( - format!("expected one of {}, found {}", expect, actual), - (self.prev_token.span.shrink_to_hi(), format!("expected one of {}", short_expect)), + format!("expected one of {expect}, found {actual}"), + (self.prev_token.span.shrink_to_hi(), format!("expected one of {short_expect}")), ) } else if expected.is_empty() { ( @@ -337,8 +337,8 @@ impl<'a> Parser<'a> { ) } else { ( - format!("expected {}, found {}", expect, actual), - (self.prev_token.span.shrink_to_hi(), format!("expected {}", expect)), + format!("expected {expect}, found {actual}"), + (self.prev_token.span.shrink_to_hi(), format!("expected {expect}")), ) }; self.last_unexpected_token_span = Some(self.token.span); @@ -421,7 +421,7 @@ impl<'a> Parser<'a> { String::new(), Applicability::MachineApplicable, ); - err.note(&format!("the raw string started with {} `#`s", n_hashes)); + err.note(&format!("the raw string started with {n_hashes} `#`s")); true } _ => false, @@ -1191,7 +1191,7 @@ impl<'a> Parser<'a> { _ => None, }; if let Some(name) = previous_item_kind_name { - err.help(&format!("{} declarations are not followed by a semicolon", name)); + err.help(&format!("{name} declarations are not followed by a semicolon")); } } err.emit(); @@ -1226,12 +1226,12 @@ impl<'a> Parser<'a> { "expected `{}`, found {}", token_str, match (&self.token.kind, self.subparser_name) { - (token::Eof, Some(origin)) => format!("end of {}", origin), + (token::Eof, Some(origin)) => format!("end of {origin}"), _ => this_token_str, }, ); let mut err = self.struct_span_err(sp, &msg); - let label_exp = format!("expected `{}`", token_str); + let label_exp = format!("expected `{token_str}`"); match self.recover_closing_delimiter(&[t.clone()], err) { Err(e) => err = e, Ok(recovered) => { @@ -1368,7 +1368,7 @@ impl<'a> Parser<'a> { Applicability::MachineApplicable, ); } - err.span_suggestion(lo.shrink_to_lo(), &format!("{}you can still access the deprecated `try!()` macro using the \"raw identifier\" syntax", prefix), "r#".to_string(), Applicability::MachineApplicable); + err.span_suggestion(lo.shrink_to_lo(), &format!("{prefix}you can still access the deprecated `try!()` macro using the \"raw identifier\" syntax"), "r#".to_string(), Applicability::MachineApplicable); err.emit(); Ok(self.mk_expr_err(lo.to(hi))) } else { @@ -1504,7 +1504,7 @@ impl<'a> Parser<'a> { delim.retain(|c| c != '`'); err.span_suggestion_short( self.prev_token.span.shrink_to_hi(), - &format!("`{}` may belong here", delim), + &format!("`{delim}` may belong here"), delim, Applicability::MaybeIncorrect, ); @@ -1698,7 +1698,7 @@ impl<'a> Parser<'a> { ( ident, "self: ".to_string(), - format!("{}: &{}TypeName", ident, mutab), + format!("{ident}: &{mutab}TypeName"), "_: ".to_string(), pat.span.shrink_to_lo(), pat.span, @@ -1826,7 +1826,7 @@ impl<'a> Parser<'a> { let (span, msg) = match (&self.token.kind, self.subparser_name) { (&token::Eof, Some(origin)) => { let sp = self.sess.source_map().next_point(self.prev_token.span); - (sp, format!("expected expression, found end of {}", origin)) + (sp, format!("expected expression, found end of {origin}")) } _ => ( self.token.span, @@ -1975,8 +1975,8 @@ impl<'a> Parser<'a> { (ty_generics, self.sess.source_map().span_to_snippet(param.span())) { let (span, sugg) = match &generics.params[..] { - [] => (generics.span, format!("<{}>", snippet)), - [.., generic] => (generic.span().shrink_to_hi(), format!(", {}", snippet)), + [] => (generics.span, format!("<{snippet}>")), + [.., generic] => (generic.span().shrink_to_hi(), format!(", {snippet}")), }; err.multipart_suggestion( "`const` parameters must be declared for the `impl`", diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs index b993d48c995b4..550d79a898c11 100644 --- a/compiler/rustc_parse/src/parser/expr.rs +++ b/compiler/rustc_parse/src/parser/expr.rs @@ -223,7 +223,7 @@ impl<'a> Parser<'a> { AssocOp::NotEqual => "!=", _ => unreachable!(), }; - self.struct_span_err(sp, &format!("invalid comparison operator `{}=`", sugg)) + self.struct_span_err(sp, &format!("invalid comparison operator `{sugg}=`")) .span_suggestion_short( sp, &format!("`{s}=` is not a valid comparison operator, use `{s}`", s = sugg), @@ -441,10 +441,10 @@ impl<'a> Parser<'a> { /// Error on `and` and `or` suggesting `&&` and `||` respectively. fn error_bad_logical_op(&self, bad: &str, good: &str, english: &str) { - self.struct_span_err(self.token.span, &format!("`{}` is not a logical operator", bad)) + self.struct_span_err(self.token.span, &format!("`{bad}` is not a logical operator")) .span_suggestion_short( self.token.span, - &format!("use `{}` to perform logical {}", good, english), + &format!("use `{good}` to perform logical {english}"), good.to_string(), Applicability::MachineApplicable, ) @@ -766,9 +766,9 @@ impl<'a> Parser<'a> { self.look_ahead(1, |t| t.span).to(span_after_type), "interpreted as generic arguments", ) - .span_label(self.token.span, format!("not interpreted as {}", op_noun)) + .span_label(self.token.span, format!("not interpreted as {op_noun}")) .multipart_suggestion( - &format!("try {} the cast value", op_verb), + &format!("try {op_verb} the cast value"), vec![ (expr.span.shrink_to_lo(), "(".to_string()), (expr.span.shrink_to_hi(), ")".to_string()), @@ -970,7 +970,7 @@ impl<'a> Parser<'a> { fn error_unexpected_after_dot(&self) { // FIXME Could factor this out into non_fatal_unexpected or something. let actual = pprust::token_to_string(&self.token); - self.struct_span_err(self.token.span, &format!("unexpected token: `{}`", actual)).emit(); + self.struct_span_err(self.token.span, &format!("unexpected token: `{actual}`")).emit(); } // We need an identifier or integer, but the next token is a float. @@ -1151,7 +1151,7 @@ impl<'a> Parser<'a> { mem::replace(err, replacement_err).cancel(); err.multipart_suggestion( - &format!("if `{}` is a struct, use braces as delimiters", name), + &format!("if `{name}` is a struct, use braces as delimiters"), vec![ (open_paren, " { ".to_string()), (close_paren, " }".to_string()), @@ -1159,7 +1159,7 @@ impl<'a> Parser<'a> { Applicability::MaybeIncorrect, ); err.multipart_suggestion( - &format!("if `{}` is a function, use the arguments directly", name), + &format!("if `{name}` is a function, use the arguments directly"), fields .into_iter() .map(|field| (field.span.until(field.expr.span), String::new())) @@ -1776,9 +1776,9 @@ impl<'a> Parser<'a> { ) .emit(); } else { - let msg = format!("invalid suffix `{}` for number literal", suf); + let msg = format!("invalid suffix `{suf}` for number literal"); self.struct_span_err(span, &msg) - .span_label(span, format!("invalid suffix `{}`", suf)) + .span_label(span, format!("invalid suffix `{suf}`")) .help("the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)") .emit(); } @@ -1791,9 +1791,9 @@ impl<'a> Parser<'a> { let msg = format!("invalid width `{}` for float literal", &suf[1..]); self.struct_span_err(span, &msg).help("valid widths are 32 and 64").emit(); } else { - let msg = format!("invalid suffix `{}` for float literal", suf); + let msg = format!("invalid suffix `{suf}` for float literal"); self.struct_span_err(span, &msg) - .span_label(span, format!("invalid suffix `{}`", suf)) + .span_label(span, format!("invalid suffix `{suf}`")) .help("valid suffixes are `f32` and `f64`") .emit(); } @@ -1805,7 +1805,7 @@ impl<'a> Parser<'a> { 2 => "binary", _ => unreachable!(), }; - self.struct_span_err(span, &format!("{} float literal is not supported", descr)) + self.struct_span_err(span, &format!("{descr} float literal is not supported")) .span_label(span, "not supported") .emit(); } @@ -1825,7 +1825,7 @@ impl<'a> Parser<'a> { let mut err = self .sess .span_diagnostic - .struct_span_warn(sp, &format!("suffixes on {} are invalid", kind)); + .struct_span_warn(sp, &format!("suffixes on {kind} are invalid")); err.note(&format!( "`{}` is *temporarily* accepted on tuple index fields as it was \ incorrectly accepted on stable for a few releases", @@ -1842,10 +1842,10 @@ impl<'a> Parser<'a> { ); err } else { - self.struct_span_err(sp, &format!("suffixes on {} are invalid", kind)) + self.struct_span_err(sp, &format!("suffixes on {kind} are invalid")) .forget_guarantee() }; - err.span_label(sp, format!("invalid suffix `{}`", suf)); + err.span_label(sp, format!("invalid suffix `{suf}`")); err.emit(); } } @@ -2211,7 +2211,7 @@ impl<'a> Parser<'a> { let ctx = if is_ctx_else { "else" } else { "if" }; self.struct_span_err(last, "outer attributes are not allowed on `if` and `else` branches") .span_label(branch_span, "the attributes are attached to this branch") - .span_label(ctx_span, format!("the branch belongs to this `{}`", ctx)) + .span_label(ctx_span, format!("the branch belongs to this `{ctx}`")) .span_suggestion( span, "remove the attributes", @@ -2391,7 +2391,7 @@ impl<'a> Parser<'a> { err.span_label(arrow_span, "while parsing the `match` arm starting here"); if stmts.len() > 1 { err.multipart_suggestion( - &format!("surround the statement{} with a body", s), + &format!("surround the statement{s} with a body"), vec![ (span.shrink_to_lo(), "{ ".to_string()), (span.shrink_to_hi(), " }".to_string()), diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs index 178bb62e0b25a..b582f060395c3 100644 --- a/compiler/rustc_parse/src/parser/item.rs +++ b/compiler/rustc_parse/src/parser/item.rs @@ -66,7 +66,7 @@ impl<'a> Parser<'a> { if !self.eat(term) { let token_str = super::token_descr(&self.token); if !self.maybe_consume_incorrect_semicolon(&items) { - let msg = &format!("expected item, found {}", token_str); + let msg = &format!("expected item, found {token_str}"); let mut err = self.struct_span_err(self.token.span, msg); err.span_label(self.token.span, "expected item"); return Err(err); @@ -163,9 +163,9 @@ impl<'a> Parser<'a> { } let vs = pprust::vis_to_string(&vis); let vs = vs.trim_end(); - self.struct_span_err(vis.span, &format!("visibility `{}` is not followed by an item", vs)) + self.struct_span_err(vis.span, &format!("visibility `{vs}` is not followed by an item")) .span_label(vis.span, "the visibility") - .help(&format!("you likely meant to define an item, e.g., `{} fn foo() {{}}`", vs)) + .help(&format!("you likely meant to define an item, e.g., `{vs} fn foo() {{}}`")) .emit(); } @@ -327,7 +327,7 @@ impl<'a> Parser<'a> { if self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) { // possible public struct definition where `struct` was forgotten let ident = self.parse_ident().unwrap(); - let msg = format!("add `struct` here to parse `{}` as a public struct", ident); + let msg = format!("add `struct` here to parse `{ident}` as a public struct"); let mut err = self.struct_span_err(sp, "missing `struct` for struct definition"); err.span_suggestion_short( sp, @@ -355,16 +355,16 @@ impl<'a> Parser<'a> { ("fn` or `struct", "function or struct", true) }; - let msg = format!("missing `{}` for {} definition", kw, kw_name); + let msg = format!("missing `{kw}` for {kw_name} definition"); let mut err = self.struct_span_err(sp, &msg); if !ambiguous { self.consume_block(token::Brace, ConsumeClosingDelim::Yes); let suggestion = - format!("add `{}` here to parse `{}` as a public {}", kw, ident, kw_name); + format!("add `{kw}` here to parse `{ident}` as a public {kw_name}"); err.span_suggestion_short( sp, &suggestion, - format!(" {} ", kw), + format!(" {kw} "), Applicability::MachineApplicable, ); } else if let Ok(snippet) = self.span_to_snippet(ident_sp) { @@ -393,12 +393,12 @@ impl<'a> Parser<'a> { } else { ("fn` or `struct", "function or struct", true) }; - let msg = format!("missing `{}` for {} definition", kw, kw_name); + let msg = format!("missing `{kw}` for {kw_name} definition"); let mut err = self.struct_span_err(sp, &msg); if !ambiguous { err.span_suggestion_short( sp, - &format!("add `{}` here to parse `{}` as a public {}", kw, ident, kw_name), + &format!("add `{kw}` here to parse `{ident}` as a public {kw_name}"), format!(" {} ", kw), Applicability::MachineApplicable, ); @@ -1031,8 +1031,8 @@ impl<'a> Parser<'a> { fn error_bad_item_kind(&self, span: Span, kind: &ItemKind, ctx: &str) -> Option { let span = self.sess.source_map().guess_head_span(span); let descr = kind.descr(); - self.struct_span_err(span, &format!("{} is not supported in {}", descr, ctx)) - .help(&format!("consider moving the {} out to a nearby module scope", descr)) + self.struct_span_err(span, &format!("{descr} is not supported in {ctx}")) + .help(&format!("consider moving the {descr} out to a nearby module scope")) .emit(); None } @@ -1161,11 +1161,11 @@ impl<'a> Parser<'a> { Some(Mutability::Not) => "static", None => "const", }; - let mut err = self.struct_span_err(id.span, &format!("missing type for `{}` item", kind)); + let mut err = self.struct_span_err(id.span, &format!("missing type for `{kind}` item")); err.span_suggestion( id.span, "provide a type for the item", - format!("{}: ", id), + format!("{id}: "), Applicability::HasPlaceholders, ); err.stash(id.span, StashKey::ItemNoType); @@ -1282,8 +1282,7 @@ impl<'a> Parser<'a> { } else { let token_str = super::token_descr(&self.token); let msg = &format!( - "expected `where`, `{{`, `(`, or `;` after struct name, found {}", - token_str + "expected `where`, `{{`, `(`, or `;` after struct name, found {token_str}" ); let mut err = self.struct_span_err(self.token.span, msg); err.span_label(self.token.span, "expected `where`, `{`, `(`, or `;` after struct name"); @@ -1310,7 +1309,7 @@ impl<'a> Parser<'a> { VariantData::Struct(fields, recovered) } else { let token_str = super::token_descr(&self.token); - let msg = &format!("expected `where` or `{{` after union name, found {}", token_str); + let msg = &format!("expected `where` or `{{` after union name, found {token_str}"); let mut err = self.struct_span_err(self.token.span, msg); err.span_label(self.token.span, "expected `where` or `{` after union name"); return Err(err); @@ -1591,7 +1590,7 @@ impl<'a> Parser<'a> { } let mut err = self.struct_span_err( lo.to(self.prev_token.span), - &format!("functions are not allowed in {} definitions", adt_ty), + &format!("functions are not allowed in {adt_ty} definitions"), ); err.help("unlike in C++, Java, and C#, functions are declared in `impl` blocks"); err.help("see https://doc.rust-lang.org/book/ch05-03-method-syntax.html for more information"); @@ -1706,7 +1705,7 @@ impl<'a> Parser<'a> { let vstr = pprust::vis_to_string(vis); let vstr = vstr.trim_end(); if macro_rules { - let msg = format!("can't qualify macro_rules invocation with `{}`", vstr); + let msg = format!("can't qualify macro_rules invocation with `{vstr}`"); self.struct_span_err(vis.span, &msg) .span_suggestion( vis.span, @@ -1723,7 +1722,7 @@ impl<'a> Parser<'a> { String::new(), Applicability::MachineApplicable, ) - .help(&format!("try adjusting the macro to put `{}` inside the invocation", vstr)) + .help(&format!("try adjusting the macro to put `{vstr}` inside the invocation")) .emit(); } } @@ -1781,11 +1780,11 @@ impl<'a> Parser<'a> { self.struct_span_err( kw_token.span, - &format!("`{}` definition cannot be nested inside `{}`", kw_str, keyword), + &format!("`{kw_str}` definition cannot be nested inside `{keyword}`"), ) .span_suggestion( item.unwrap().span, - &format!("consider creating a new `{}` definition instead of nesting", kw_str), + &format!("consider creating a new `{kw_str}` definition instead of nesting"), String::new(), Applicability::MaybeIncorrect, ) @@ -2045,11 +2044,11 @@ impl<'a> Parser<'a> { err.span_suggestion( self.token.uninterpolated_span(), - &format!("`{}` already used earlier, remove this one", original_kw), + &format!("`{original_kw}` already used earlier, remove this one"), "".to_string(), Applicability::MachineApplicable, ) - .span_note(original_sp, &format!("`{}` first seen here", original_kw)); + .span_note(original_sp, &format!("`{original_kw}` first seen here")); } // The keyword has not been seen yet, suggest correct placement in the function front matter else if let Some(WrongKw::Misplaced(correct_pos_sp)) = wrong_kw { @@ -2060,8 +2059,8 @@ impl<'a> Parser<'a> { err.span_suggestion( correct_pos_sp.to(misplaced_qual_sp), - &format!("`{}` must come before `{}`", misplaced_qual, current_qual), - format!("{} {}", misplaced_qual, current_qual), + &format!("`{misplaced_qual}` must come before `{current_qual}`"), + format!("{misplaced_qual} {current_qual}"), Applicability::MachineApplicable, ).note("keyword order for functions declaration is `default`, `pub`, `const`, `async`, `unsafe`, `extern`"); } @@ -2084,8 +2083,8 @@ impl<'a> Parser<'a> { if matches!(orig_vis.kind, VisibilityKind::Inherited) { err.span_suggestion( sp_start.to(self.prev_token.span), - &format!("visibility `{}` must come before `{}`", vs, snippet), - format!("{} {}", vs, snippet), + &format!("visibility `{vs}` must come before `{snippet}`"), + format!("{vs} {snippet}"), Applicability::MachineApplicable, ); }