From c682aa162b0d41e21cc6748f4fecfe01efb69d1f Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 22 Sep 2024 19:05:04 -0400
Subject: Reformat using the new identifier sorting from rustfmt

---
 compiler/rustc_parse_format/src/lib.rs   |  84 ++--
 compiler/rustc_parse_format/src/tests.rs | 640 ++++++++++++++-----------------
 2 files changed, 323 insertions(+), 401 deletions(-)

(limited to 'compiler/rustc_parse_format/src')

diff --git a/compiler/rustc_parse_format/src/lib.rs b/compiler/rustc_parse_format/src/lib.rs
index 51084ef4441..e7ef4385baf 100644
--- a/compiler/rustc_parse_format/src/lib.rs
+++ b/compiler/rustc_parse_format/src/lib.rs
@@ -18,11 +18,11 @@
 
 use std::{iter, str, string};
 
-use rustc_lexer::unescape;
 pub use Alignment::*;
 pub use Count::*;
 pub use Piece::*;
 pub use Position::*;
+use rustc_lexer::unescape;
 
 // Note: copied from rustc_span
 /// Range inside of a `Span` used for diagnostics when we only have access to relative positions.
@@ -870,34 +870,28 @@ impl<'a> Parser<'a> {
         if let (Some(pos), Some(_)) = (self.consume_pos('?'), self.consume_pos(':')) {
             let word = self.word();
             let pos = self.to_span_index(pos);
-            self.errors.insert(
-                0,
-                ParseError {
-                    description: "expected format parameter to occur after `:`".to_owned(),
-                    note: Some(format!("`?` comes after `:`, try `{}:{}` instead", word, "?")),
-                    label: "expected `?` to occur after `:`".to_owned(),
-                    span: pos.to(pos),
-                    secondary_label: None,
-                    suggestion: Suggestion::None,
-                },
-            );
+            self.errors.insert(0, ParseError {
+                description: "expected format parameter to occur after `:`".to_owned(),
+                note: Some(format!("`?` comes after `:`, try `{}:{}` instead", word, "?")),
+                label: "expected `?` to occur after `:`".to_owned(),
+                span: pos.to(pos),
+                secondary_label: None,
+                suggestion: Suggestion::None,
+            });
         }
     }
 
     fn suggest_format_align(&mut self, alignment: char) {
         if let Some(pos) = self.consume_pos(alignment) {
             let pos = self.to_span_index(pos);
-            self.errors.insert(
-                0,
-                ParseError {
-                    description: "expected format parameter to occur after `:`".to_owned(),
-                    note: None,
-                    label: format!("expected `{}` to occur after `:`", alignment),
-                    span: pos.to(pos),
-                    secondary_label: None,
-                    suggestion: Suggestion::None,
-                },
-            );
+            self.errors.insert(0, ParseError {
+                description: "expected format parameter to occur after `:`".to_owned(),
+                note: None,
+                label: format!("expected `{}` to occur after `:`", alignment),
+                span: pos.to(pos),
+                secondary_label: None,
+                suggestion: Suggestion::None,
+            });
         }
     }
 
@@ -914,36 +908,24 @@ impl<'a> Parser<'a> {
             if let ArgumentNamed(_) = arg.position {
                 match field.position {
                     ArgumentNamed(_) => {
-                        self.errors.insert(
-                            0,
-                            ParseError {
-                                description: "field access isn't supported".to_string(),
-                                note: None,
-                                label: "not supported".to_string(),
-                                span: InnerSpan::new(
-                                    arg.position_span.start,
-                                    field.position_span.end,
-                                ),
-                                secondary_label: None,
-                                suggestion: Suggestion::UsePositional,
-                            },
-                        );
+                        self.errors.insert(0, ParseError {
+                            description: "field access isn't supported".to_string(),
+                            note: None,
+                            label: "not supported".to_string(),
+                            span: InnerSpan::new(arg.position_span.start, field.position_span.end),
+                            secondary_label: None,
+                            suggestion: Suggestion::UsePositional,
+                        });
                     }
                     ArgumentIs(_) => {
-                        self.errors.insert(
-                            0,
-                            ParseError {
-                                description: "tuple index access isn't supported".to_string(),
-                                note: None,
-                                label: "not supported".to_string(),
-                                span: InnerSpan::new(
-                                    arg.position_span.start,
-                                    field.position_span.end,
-                                ),
-                                secondary_label: None,
-                                suggestion: Suggestion::UsePositional,
-                            },
-                        );
+                        self.errors.insert(0, ParseError {
+                            description: "tuple index access isn't supported".to_string(),
+                            note: None,
+                            label: "not supported".to_string(),
+                            span: InnerSpan::new(arg.position_span.start, field.position_span.end),
+                            secondary_label: None,
+                            suggestion: Suggestion::UsePositional,
+                        });
                     }
                     _ => {}
                 };
diff --git a/compiler/rustc_parse_format/src/tests.rs b/compiler/rustc_parse_format/src/tests.rs
index 0c594f9104c..81e5bca0ba9 100644
--- a/compiler/rustc_parse_format/src/tests.rs
+++ b/compiler/rustc_parse_format/src/tests.rs
@@ -78,311 +78,307 @@ fn invalid_precision() {
 
 #[test]
 fn format_nothing() {
-    same(
-        "{}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 2 },
-            format: fmtdflt(),
-        }))],
-    );
+    same("{}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: fmtdflt(),
+    }))]);
 }
 #[test]
 fn format_position() {
-    same(
-        "{3}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentIs(3),
-            position_span: InnerSpan { start: 2, end: 3 },
-            format: fmtdflt(),
-        }))],
-    );
+    same("{3}", &[NextArgument(Box::new(Argument {
+        position: ArgumentIs(3),
+        position_span: InnerSpan { start: 2, end: 3 },
+        format: fmtdflt(),
+    }))]);
 }
 #[test]
 fn format_position_nothing_else() {
-    same(
-        "{3:}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentIs(3),
-            position_span: InnerSpan { start: 2, end: 3 },
-            format: fmtdflt(),
-        }))],
-    );
+    same("{3:}", &[NextArgument(Box::new(Argument {
+        position: ArgumentIs(3),
+        position_span: InnerSpan { start: 2, end: 3 },
+        format: fmtdflt(),
+    }))]);
 }
 #[test]
 fn format_named() {
-    same(
-        "{name}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentNamed("name"),
-            position_span: InnerSpan { start: 2, end: 6 },
-            format: fmtdflt(),
-        }))],
-    )
+    same("{name}", &[NextArgument(Box::new(Argument {
+        position: ArgumentNamed("name"),
+        position_span: InnerSpan { start: 2, end: 6 },
+        format: fmtdflt(),
+    }))])
 }
 #[test]
 fn format_type() {
-    same(
-        "{3:x}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentIs(3),
-            position_span: InnerSpan { start: 2, end: 3 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountImplied,
-                width: CountImplied,
-                precision_span: None,
-                width_span: None,
-                ty: "x",
-                ty_span: None,
-            },
-        }))],
-    );
+    same("{3:x}", &[NextArgument(Box::new(Argument {
+        position: ArgumentIs(3),
+        position_span: InnerSpan { start: 2, end: 3 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountImplied,
+            width: CountImplied,
+            precision_span: None,
+            width_span: None,
+            ty: "x",
+            ty_span: None,
+        },
+    }))]);
 }
 #[test]
 fn format_align_fill() {
-    same(
-        "{3:>}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentIs(3),
-            position_span: InnerSpan { start: 2, end: 3 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignRight,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountImplied,
-                width: CountImplied,
-                precision_span: None,
-                width_span: None,
-                ty: "",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{3:0<}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentIs(3),
-            position_span: InnerSpan { start: 2, end: 3 },
-            format: FormatSpec {
-                fill: Some('0'),
-                fill_span: Some(InnerSpan::new(4, 5)),
-                align: AlignLeft,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountImplied,
-                width: CountImplied,
-                precision_span: None,
-                width_span: None,
-                ty: "",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{3:*<abcd}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentIs(3),
-            position_span: InnerSpan { start: 2, end: 3 },
-            format: FormatSpec {
-                fill: Some('*'),
-                fill_span: Some(InnerSpan::new(4, 5)),
-                align: AlignLeft,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountImplied,
-                width: CountImplied,
-                precision_span: None,
-                width_span: None,
-                ty: "abcd",
-                ty_span: Some(InnerSpan::new(6, 10)),
-            },
-        }))],
-    );
+    same("{3:>}", &[NextArgument(Box::new(Argument {
+        position: ArgumentIs(3),
+        position_span: InnerSpan { start: 2, end: 3 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignRight,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountImplied,
+            width: CountImplied,
+            precision_span: None,
+            width_span: None,
+            ty: "",
+            ty_span: None,
+        },
+    }))]);
+    same("{3:0<}", &[NextArgument(Box::new(Argument {
+        position: ArgumentIs(3),
+        position_span: InnerSpan { start: 2, end: 3 },
+        format: FormatSpec {
+            fill: Some('0'),
+            fill_span: Some(InnerSpan::new(4, 5)),
+            align: AlignLeft,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountImplied,
+            width: CountImplied,
+            precision_span: None,
+            width_span: None,
+            ty: "",
+            ty_span: None,
+        },
+    }))]);
+    same("{3:*<abcd}", &[NextArgument(Box::new(Argument {
+        position: ArgumentIs(3),
+        position_span: InnerSpan { start: 2, end: 3 },
+        format: FormatSpec {
+            fill: Some('*'),
+            fill_span: Some(InnerSpan::new(4, 5)),
+            align: AlignLeft,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountImplied,
+            width: CountImplied,
+            precision_span: None,
+            width_span: None,
+            ty: "abcd",
+            ty_span: Some(InnerSpan::new(6, 10)),
+        },
+    }))]);
 }
 #[test]
 fn format_counts() {
-    same(
-        "{:10x}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 2 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountImplied,
-                precision_span: None,
-                width: CountIs(10),
-                width_span: Some(InnerSpan { start: 3, end: 5 }),
-                ty: "x",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{:10$.10x}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 2 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountIs(10),
-                precision_span: Some(InnerSpan { start: 6, end: 9 }),
-                width: CountIsParam(10),
-                width_span: Some(InnerSpan { start: 3, end: 6 }),
-                ty: "x",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{1:0$.10x}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentIs(1),
-            position_span: InnerSpan { start: 2, end: 3 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountIs(10),
-                precision_span: Some(InnerSpan { start: 6, end: 9 }),
-                width: CountIsParam(0),
-                width_span: Some(InnerSpan { start: 4, end: 6 }),
-                ty: "x",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{:.*x}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(1),
-            position_span: InnerSpan { start: 2, end: 2 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountIsStar(0),
-                precision_span: Some(InnerSpan { start: 3, end: 5 }),
-                width: CountImplied,
-                width_span: None,
-                ty: "x",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{:.10$x}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 2 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountIsParam(10),
-                width: CountImplied,
-                precision_span: Some(InnerSpan::new(3, 7)),
-                width_span: None,
-                ty: "x",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{:a$.b$?}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 2 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountIsName("b", InnerSpan { start: 6, end: 7 }),
-                precision_span: Some(InnerSpan { start: 5, end: 8 }),
-                width: CountIsName("a", InnerSpan { start: 3, end: 4 }),
-                width_span: Some(InnerSpan { start: 3, end: 5 }),
-                ty: "?",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{:.4}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 2 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: None,
-                alternate: false,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountIs(4),
-                precision_span: Some(InnerSpan { start: 3, end: 5 }),
-                width: CountImplied,
-                width_span: None,
-                ty: "",
-                ty_span: None,
-            },
-        }))],
-    )
+    same("{:10x}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountImplied,
+            precision_span: None,
+            width: CountIs(10),
+            width_span: Some(InnerSpan { start: 3, end: 5 }),
+            ty: "x",
+            ty_span: None,
+        },
+    }))]);
+    same("{:10$.10x}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountIs(10),
+            precision_span: Some(InnerSpan { start: 6, end: 9 }),
+            width: CountIsParam(10),
+            width_span: Some(InnerSpan { start: 3, end: 6 }),
+            ty: "x",
+            ty_span: None,
+        },
+    }))]);
+    same("{1:0$.10x}", &[NextArgument(Box::new(Argument {
+        position: ArgumentIs(1),
+        position_span: InnerSpan { start: 2, end: 3 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountIs(10),
+            precision_span: Some(InnerSpan { start: 6, end: 9 }),
+            width: CountIsParam(0),
+            width_span: Some(InnerSpan { start: 4, end: 6 }),
+            ty: "x",
+            ty_span: None,
+        },
+    }))]);
+    same("{:.*x}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(1),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountIsStar(0),
+            precision_span: Some(InnerSpan { start: 3, end: 5 }),
+            width: CountImplied,
+            width_span: None,
+            ty: "x",
+            ty_span: None,
+        },
+    }))]);
+    same("{:.10$x}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountIsParam(10),
+            width: CountImplied,
+            precision_span: Some(InnerSpan::new(3, 7)),
+            width_span: None,
+            ty: "x",
+            ty_span: None,
+        },
+    }))]);
+    same("{:a$.b$?}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountIsName("b", InnerSpan { start: 6, end: 7 }),
+            precision_span: Some(InnerSpan { start: 5, end: 8 }),
+            width: CountIsName("a", InnerSpan { start: 3, end: 4 }),
+            width_span: Some(InnerSpan { start: 3, end: 5 }),
+            ty: "?",
+            ty_span: None,
+        },
+    }))]);
+    same("{:.4}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: None,
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountIs(4),
+            precision_span: Some(InnerSpan { start: 3, end: 5 }),
+            width: CountImplied,
+            width_span: None,
+            ty: "",
+            ty_span: None,
+        },
+    }))])
 }
 #[test]
 fn format_flags() {
-    same(
-        "{:-}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 2 },
+    same("{:-}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: Some(Sign::Minus),
+            alternate: false,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountImplied,
+            width: CountImplied,
+            precision_span: None,
+            width_span: None,
+            ty: "",
+            ty_span: None,
+        },
+    }))]);
+    same("{:+#}", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 2 },
+        format: FormatSpec {
+            fill: None,
+            fill_span: None,
+            align: AlignUnknown,
+            sign: Some(Sign::Plus),
+            alternate: true,
+            zero_pad: false,
+            debug_hex: None,
+            precision: CountImplied,
+            width: CountImplied,
+            precision_span: None,
+            width_span: None,
+            ty: "",
+            ty_span: None,
+        },
+    }))]);
+}
+#[test]
+fn format_mixture() {
+    same("abcd {3:x} efg", &[
+        String("abcd "),
+        NextArgument(Box::new(Argument {
+            position: ArgumentIs(3),
+            position_span: InnerSpan { start: 7, end: 8 },
             format: FormatSpec {
                 fill: None,
                 fill_span: None,
                 align: AlignUnknown,
-                sign: Some(Sign::Minus),
+                sign: None,
                 alternate: false,
                 zero_pad: false,
                 debug_hex: None,
@@ -390,79 +386,23 @@ fn format_flags() {
                 width: CountImplied,
                 precision_span: None,
                 width_span: None,
-                ty: "",
-                ty_span: None,
-            },
-        }))],
-    );
-    same(
-        "{:+#}",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 2 },
-            format: FormatSpec {
-                fill: None,
-                fill_span: None,
-                align: AlignUnknown,
-                sign: Some(Sign::Plus),
-                alternate: true,
-                zero_pad: false,
-                debug_hex: None,
-                precision: CountImplied,
-                width: CountImplied,
-                precision_span: None,
-                width_span: None,
-                ty: "",
+                ty: "x",
                 ty_span: None,
             },
-        }))],
-    );
-}
-#[test]
-fn format_mixture() {
-    same(
-        "abcd {3:x} efg",
-        &[
-            String("abcd "),
-            NextArgument(Box::new(Argument {
-                position: ArgumentIs(3),
-                position_span: InnerSpan { start: 7, end: 8 },
-                format: FormatSpec {
-                    fill: None,
-                    fill_span: None,
-                    align: AlignUnknown,
-                    sign: None,
-                    alternate: false,
-                    zero_pad: false,
-                    debug_hex: None,
-                    precision: CountImplied,
-                    width: CountImplied,
-                    precision_span: None,
-                    width_span: None,
-                    ty: "x",
-                    ty_span: None,
-                },
-            })),
-            String(" efg"),
-        ],
-    );
+        })),
+        String(" efg"),
+    ]);
 }
 #[test]
 fn format_whitespace() {
-    same(
-        "{ }",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 3 },
-            format: fmtdflt(),
-        }))],
-    );
-    same(
-        "{  }",
-        &[NextArgument(Box::new(Argument {
-            position: ArgumentImplicitlyIs(0),
-            position_span: InnerSpan { start: 2, end: 4 },
-            format: fmtdflt(),
-        }))],
-    );
+    same("{ }", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 3 },
+        format: fmtdflt(),
+    }))]);
+    same("{  }", &[NextArgument(Box::new(Argument {
+        position: ArgumentImplicitlyIs(0),
+        position_span: InnerSpan { start: 2, end: 4 },
+        format: fmtdflt(),
+    }))]);
 }
-- 
cgit 1.4.1-3-g733a5