parse_format optimize import use

Author: hkBst

compiler/rustc_builtin_macros/src/asm.rs

@@ -651,7 +651,7 @@ fn expand_preparsed_asm(
             .map(|span| template_span.from_inner(InnerSpan::new(span.start, span.end)));
         for piece in unverified_pieces {
             match piece {
-                parse::Piece::String(s) => {
+                parse::Piece::Lit(s) => {
                     template.push(ast::InlineAsmTemplatePiece::String(s.to_string().into()))
                 }
                 parse::Piece::NextArgument(arg) => {

compiler/rustc_builtin_macros/src/format.rs

@@ -405,7 +405,7 @@ fn make_format_args(
 
     for piece in &pieces {
         match *piece {
-            parse::Piece::String(s) => {
+            parse::Piece::Lit(s) => {
                 unfinished_literal.push_str(s);
             }
             parse::Piece::NextArgument(box parse::Argument { position, position_span, format }) => {

compiler/rustc_parse_format/src/lib.rs

@@ -16,11 +16,8 @@
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
-use std::{iter, str, string};
-
 pub use Alignment::*;
 pub use Count::*;
-pub use Piece::*;
 pub use Position::*;
 use rustc_lexer::unescape;
 
@@ -86,7 +83,7 @@ impl InnerOffset {
 #[derive(Clone, Debug, PartialEq)]
 pub enum Piece<'a> {
     /// A literal string which should directly be emitted
-    String(&'a str),
+    Lit(&'a str),
     /// This describes that formatting should process the next argument (as
     /// specified inside) for emission.
     NextArgument(Box<Argument<'a>>),
@@ -205,11 +202,11 @@ pub enum Count<'a> {
 }
 
 pub struct ParseError {
-    pub description: string::String,
-    pub note: Option<string::String>,
-    pub label: string::String,
+    pub description: String,
+    pub note: Option<String>,
+    pub label: String,
     pub span: InnerSpan,
-    pub secondary_label: Option<(string::String, InnerSpan)>,
+    pub secondary_label: Option<(String, InnerSpan)>,
     pub suggestion: Suggestion,
 }
 
@@ -225,7 +222,7 @@ pub enum Suggestion {
     /// `format!("{foo:?#}")` -> `format!("{foo:#?}")`
     /// `format!("{foo:?x}")` -> `format!("{foo:x?}")`
     /// `format!("{foo:?X}")` -> `format!("{foo:X?}")`
-    ReorderFormatParameter(InnerSpan, string::String),
+    ReorderFormatParameter(InnerSpan, String),
 }
 
 /// The parser structure for interpreting the input format string. This is
@@ -237,7 +234,7 @@ pub enum Suggestion {
 pub struct Parser<'a> {
     mode: ParseMode,
     input: &'a str,
-    cur: iter::Peekable<str::CharIndices<'a>>,
+    cur: std::iter::Peekable<std::str::CharIndices<'a>>,
     /// Error messages accumulated during parsing
     pub errors: Vec<ParseError>,
     /// Current position of implicit positional argument pointer
@@ -278,7 +275,7 @@ impl<'a> Iterator for Parser<'a> {
                     if self.consume('{') {
                         self.last_opening_brace = curr_last_brace;
 
-                        Some(String(self.string(pos + 1)))
+                        Some(Piece::Lit(self.string(pos + 1)))
                     } else {
                         let arg = self.argument(lbrace_end);
                         if let Some(rbrace_pos) = self.consume_closing_brace(&arg) {
@@ -299,13 +296,13 @@ impl<'a> Iterator for Parser<'a> {
                                 _ => self.suggest_positional_arg_instead_of_captured_arg(arg),
                             }
                         }
-                        Some(NextArgument(Box::new(arg)))
+                        Some(Piece::NextArgument(Box::new(arg)))
                     }
                 }
                 '}' => {
                     self.cur.next();
                     if self.consume('}') {
-                        Some(String(self.string(pos + 1)))
+                        Some(Piece::Lit(self.string(pos + 1)))
                     } else {
                         let err_pos = self.to_span_index(pos);
                         self.err_with_note(
@@ -317,7 +314,7 @@ impl<'a> Iterator for Parser<'a> {
                         None
                     }
                 }
-                _ => Some(String(self.string(pos))),
+                _ => Some(Piece::Lit(self.string(pos))),
             }
         } else {
             if self.is_source_literal {
@@ -336,7 +333,7 @@ impl<'a> Parser<'a> {
     pub fn new(
         s: &'a str,
         style: Option<usize>,
-        snippet: Option<string::String>,
+        snippet: Option<String>,
         append_newline: bool,
         mode: ParseMode,
     ) -> Parser<'a> {
@@ -366,7 +363,7 @@ impl<'a> Parser<'a> {
     /// Notifies of an error. The message doesn't actually need to be of type
     /// String, but I think it does when this eventually uses conditions so it
     /// might as well start using it now.
-    fn err<S1: Into<string::String>, S2: Into<string::String>>(
+    fn err<S1: Into<String>, S2: Into<String>>(
         &mut self,
         description: S1,
         label: S2,
@@ -385,11 +382,7 @@ impl<'a> Parser<'a> {
     /// Notifies of an error. The message doesn't actually need to be of type
     /// String, but I think it does when this eventually uses conditions so it
     /// might as well start using it now.
-    fn err_with_note<
-        S1: Into<string::String>,
-        S2: Into<string::String>,
-        S3: Into<string::String>,
-    >(
+    fn err_with_note<S1: Into<String>, S2: Into<String>, S3: Into<String>>(
         &mut self,
         description: S1,
         label: S2,
@@ -974,7 +967,7 @@ impl<'a> Parser<'a> {
 /// in order to properly synthesise the intra-string `Span`s for error diagnostics.
 fn find_width_map_from_snippet(
     input: &str,
-    snippet: Option<string::String>,
+    snippet: Option<String>,
     str_style: Option<usize>,
 ) -> InputStringKind {
     let snippet = match snippet {
@@ -1089,8 +1082,8 @@ fn find_width_map_from_snippet(
     InputStringKind::Literal { width_mappings }
 }
 
-fn unescape_string(string: &str) -> Option<string::String> {
-    let mut buf = string::String::new();
+fn unescape_string(string: &str) -> Option<String> {
+    let mut buf = String::new();
     let mut ok = true;
     unescape::unescape_unicode(string, unescape::Mode::Str, &mut |_, unescaped_char| {
         match unescaped_char {

compiler/rustc_parse_format/src/tests.rs

@@ -1,3 +1,5 @@
+use Piece::*;
+
 use super::*;
 
 #[track_caller]
@@ -32,12 +34,12 @@ fn musterr(s: &str) {
 
 #[test]
 fn simple() {
-    same("asdf", &[String("asdf")]);
-    same("a{{b", &[String("a"), String("{b")]);
-    same("a}}b", &[String("a"), String("}b")]);
-    same("a}}", &[String("a"), String("}")]);
-    same("}}", &[String("}")]);
-    same("\\}}", &[String("\\"), String("}")]);
+    same("asdf", &[Lit("asdf")]);
+    same("a{{b", &[Lit("a"), Lit("{b")]);
+    same("a}}b", &[Lit("a"), Lit("}b")]);
+    same("a}}", &[Lit("a"), Lit("}")]);
+    same("}}", &[Lit("}")]);
+    same("\\}}", &[Lit("\\"), Lit("}")]);
 }
 
 #[test]
@@ -370,7 +372,7 @@ fn format_flags() {
 #[test]
 fn format_mixture() {
     same("abcd {3:x} efg", &[
-        String("abcd "),
+        Lit("abcd "),
         NextArgument(Box::new(Argument {
             position: ArgumentIs(3),
             position_span: InnerSpan { start: 7, end: 8 },
@@ -390,7 +392,7 @@ fn format_mixture() {
                 ty_span: None,
             },
         })),
-        String(" efg"),
+        Lit(" efg"),
     ]);
 }
 #[test]

compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs

@@ -799,7 +799,7 @@ impl<'tcx> OnUnimplementedFormatString {
         let mut result = Ok(());
         for token in &mut parser {
             match token {
-                Piece::String(_) => (), // Normal string, no need to check it
+                Piece::Lit(_) => (), // Normal string, no need to check it
                 Piece::NextArgument(a) => {
                     let format_spec = a.format;
                     if self.is_diagnostic_namespace_variant
@@ -946,7 +946,7 @@ impl<'tcx> OnUnimplementedFormatString {
         let item_context = (options.get(&sym::ItemContext)).unwrap_or(&empty_string);
         let constructed_message = (&mut parser)
             .map(|p| match p {
-                Piece::String(s) => s.to_owned(),
+                Piece::Lit(s) => s.to_owned(),
                 Piece::NextArgument(a) => match a.position {
                     Position::ArgumentNamed(arg) => {
                         let s = Symbol::intern(arg);

src/tools/rust-analyzer/crates/hir-def/src/body/lower/asm.rs

@@ -229,7 +229,7 @@ impl ExprCollector<'_> {
                     };
                     for piece in unverified_pieces {
                         match piece {
-                            rustc_parse_format::Piece::String(_) => {}
+                            rustc_parse_format::Piece::Lit(_) => {}
                             rustc_parse_format::Piece::NextArgument(arg) => {
                                 // let span = arg_spans.next();
 

src/tools/rust-analyzer/crates/hir-def/src/hir/format_args.rs

@@ -287,7 +287,7 @@ pub(crate) fn parse(
 
     for piece in pieces {
         match piece {
-            parse::Piece::String(s) => {
+            parse::Piece::Lit(s) => {
                 unfinished_literal.push_str(s);
             }
             parse::Piece::NextArgument(arg) => {