Rustfmt

11 files changed, 306 insertions, 230 deletions

diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
index feec2a7444f..c21bf82b852 100644
--- a/src/tools/build-manifest/src/main.rs
+++ b/src/tools/build-manifest/src/main.rs
@@ -603,11 +603,14 @@ impl Builder {
             })
             .collect();
 
-        dst.insert(pkg.manifest_component_name(), Package {
-            version: version_info.version.unwrap_or_default(),
-            git_commit_hash: version_info.git_commit,
-            target: targets,
-        });
+        dst.insert(
+            pkg.manifest_component_name(),
+            Package {
+                version: version_info.version.unwrap_or_default(),
+                git_commit_hash: version_info.git_commit,
+                target: targets,
+            },
+        );
     }
 
     fn url(&self, path: &Path) -> String {
diff --git a/src/tools/compiletest/src/header/tests.rs b/src/tools/compiletest/src/header/tests.rs
index ebba16d41f9..023658a3dd4 100644
--- a/src/tools/compiletest/src/header/tests.rs
+++ b/src/tools/compiletest/src/header/tests.rs
@@ -251,9 +251,10 @@ fn revisions() {
     let config: Config = cfg().build();
 
     assert_eq!(parse_rs(&config, "//@ revisions: a b c").revisions, vec!["a", "b", "c"],);
-    assert_eq!(parse_makefile(&config, "# revisions: hello there").revisions, vec![
-        "hello", "there"
-    ],);
+    assert_eq!(
+        parse_makefile(&config, "# revisions: hello there").revisions,
+        vec!["hello", "there"],
+    );
 }
 
 #[test]
diff --git a/src/tools/coverage-dump/src/covfun.rs b/src/tools/coverage-dump/src/covfun.rs
index 33fac3edccd..82ebd33d0d1 100644
--- a/src/tools/coverage-dump/src/covfun.rs
+++ b/src/tools/coverage-dump/src/covfun.rs
@@ -95,10 +95,13 @@ pub(crate) fn dump_covfun_mappings(
         // has increased or decreased the number of physical counters needed.
         // (It's possible for the generated code to have more counters that
         // aren't used by any mappings, but that should hopefully be rare.)
-        println!("Highest counter ID seen: {}", match max_counter {
-            Some(id) => format!("c{id}"),
-            None => "(none)".to_owned(),
-        });
+        println!(
+            "Highest counter ID seen: {}",
+            match max_counter {
+                Some(id) => format!("c{id}"),
+                None => "(none)".to_owned(),
+            }
+        );
         println!();
     }
     Ok(())
diff --git a/src/tools/generate-copyright/src/cargo_metadata.rs b/src/tools/generate-copyright/src/cargo_metadata.rs
index 420579372ac..51e353e9b22 100644
--- a/src/tools/generate-copyright/src/cargo_metadata.rs
+++ b/src/tools/generate-copyright/src/cargo_metadata.rs
@@ -98,12 +98,15 @@ pub fn get_metadata(
             }
             // otherwise it's an out-of-tree dependency
             let package_id = Package { name: package.name, version: package.version.to_string() };
-            output.insert(package_id, PackageMetadata {
-                license: package.license.unwrap_or_else(|| String::from("Unspecified")),
-                authors: package.authors,
-                notices: BTreeMap::new(),
-                is_in_libstd: None,
-            });
+            output.insert(
+                package_id,
+                PackageMetadata {
+                    license: package.license.unwrap_or_else(|| String::from("Unspecified")),
+                    authors: package.authors,
+                    notices: BTreeMap::new(),
+                    is_in_libstd: None,
+                },
+            );
         }
     }
 
diff --git a/src/tools/generate-copyright/src/main.rs b/src/tools/generate-copyright/src/main.rs
index 0a446ecff5b..7a014989e68 100644
--- a/src/tools/generate-copyright/src/main.rs
+++ b/src/tools/generate-copyright/src/main.rs
@@ -24,12 +24,16 @@ fn main() -> Result<(), Error> {
     let root_path = std::path::absolute(".")?;
 
     // Scan Cargo dependencies
-    let mut collected_cargo_metadata =
-        cargo_metadata::get_metadata_and_notices(&cargo, &out_dir.join("vendor"), &root_path, &[
+    let mut collected_cargo_metadata = cargo_metadata::get_metadata_and_notices(
+        &cargo,
+        &out_dir.join("vendor"),
+        &root_path,
+        &[
             Path::new("./Cargo.toml"),
             Path::new("./src/tools/cargo/Cargo.toml"),
             Path::new("./library/Cargo.toml"),
-        ])?;
+        ],
+    )?;
 
     let library_collected_cargo_metadata = cargo_metadata::get_metadata_and_notices(
         &cargo,
diff --git a/src/tools/jsondoclint/src/validator/tests.rs b/src/tools/jsondoclint/src/validator/tests.rs
index a37e6c2eb5c..28deb7e7cee 100644
--- a/src/tools/jsondoclint/src/validator/tests.rs
+++ b/src/tools/jsondoclint/src/validator/tests.rs
@@ -21,32 +21,42 @@ fn errors_on_missing_links() {
         root: Id(0),
         crate_version: None,
         includes_private: false,
-        index: FxHashMap::from_iter([(Id(0), Item {
-            name: Some("root".to_owned()),
-            id: Id(0),
-            crate_id: 0,
-            span: None,
-            visibility: Visibility::Public,
-            docs: None,
-            links: FxHashMap::from_iter([("Not Found".to_owned(), Id(1))]),
-            attrs: vec![],
-            deprecation: None,
-            inner: ItemEnum::Module(Module { is_crate: true, items: vec![], is_stripped: false }),
-        })]),
+        index: FxHashMap::from_iter([(
+            Id(0),
+            Item {
+                name: Some("root".to_owned()),
+                id: Id(0),
+                crate_id: 0,
+                span: None,
+                visibility: Visibility::Public,
+                docs: None,
+                links: FxHashMap::from_iter([("Not Found".to_owned(), Id(1))]),
+                attrs: vec![],
+                deprecation: None,
+                inner: ItemEnum::Module(Module {
+                    is_crate: true,
+                    items: vec![],
+                    is_stripped: false,
+                }),
+            },
+        )]),
         paths: FxHashMap::default(),
         external_crates: FxHashMap::default(),
         format_version: rustdoc_json_types::FORMAT_VERSION,
     };
 
-    check(&k, &[Error {
-        kind: ErrorKind::NotFound(vec![vec![
-            SelectorPart::Field("index".to_owned()),
-            SelectorPart::Field("0".to_owned()),
-            SelectorPart::Field("links".to_owned()),
-            SelectorPart::Field("Not Found".to_owned()),
-        ]]),
-        id: Id(1),
-    }]);
+    check(
+        &k,
+        &[Error {
+            kind: ErrorKind::NotFound(vec![vec![
+                SelectorPart::Field("index".to_owned()),
+                SelectorPart::Field("0".to_owned()),
+                SelectorPart::Field("links".to_owned()),
+                SelectorPart::Field("Not Found".to_owned()),
+            ]]),
+            id: Id(1),
+        }],
+    );
 }
 
 // Test we would catch
@@ -58,48 +68,60 @@ fn errors_on_local_in_paths_and_not_index() {
         crate_version: None,
         includes_private: false,
         index: FxHashMap::from_iter([
-            (Id(0), Item {
-                id: Id(0),
-                crate_id: 0,
-                name: Some("microcore".to_owned()),
-                span: None,
-                visibility: Visibility::Public,
-                docs: None,
-                links: FxHashMap::from_iter([(("prim@i32".to_owned(), Id(2)))]),
-                attrs: Vec::new(),
-                deprecation: None,
-                inner: ItemEnum::Module(Module {
-                    is_crate: true,
-                    items: vec![Id(1)],
-                    is_stripped: false,
-                }),
-            }),
-            (Id(1), Item {
-                id: Id(1),
-                crate_id: 0,
-                name: Some("i32".to_owned()),
-                span: None,
-                visibility: Visibility::Public,
-                docs: None,
-                links: FxHashMap::default(),
-                attrs: Vec::new(),
-                deprecation: None,
-                inner: ItemEnum::Primitive(Primitive { name: "i32".to_owned(), impls: vec![] }),
-            }),
+            (
+                Id(0),
+                Item {
+                    id: Id(0),
+                    crate_id: 0,
+                    name: Some("microcore".to_owned()),
+                    span: None,
+                    visibility: Visibility::Public,
+                    docs: None,
+                    links: FxHashMap::from_iter([(("prim@i32".to_owned(), Id(2)))]),
+                    attrs: Vec::new(),
+                    deprecation: None,
+                    inner: ItemEnum::Module(Module {
+                        is_crate: true,
+                        items: vec![Id(1)],
+                        is_stripped: false,
+                    }),
+                },
+            ),
+            (
+                Id(1),
+                Item {
+                    id: Id(1),
+                    crate_id: 0,
+                    name: Some("i32".to_owned()),
+                    span: None,
+                    visibility: Visibility::Public,
+                    docs: None,
+                    links: FxHashMap::default(),
+                    attrs: Vec::new(),
+                    deprecation: None,
+                    inner: ItemEnum::Primitive(Primitive { name: "i32".to_owned(), impls: vec![] }),
+                },
+            ),
         ]),
-        paths: FxHashMap::from_iter([(Id(2), ItemSummary {
-            crate_id: 0,
-            path: vec!["microcore".to_owned(), "i32".to_owned()],
-            kind: ItemKind::Primitive,
-        })]),
+        paths: FxHashMap::from_iter([(
+            Id(2),
+            ItemSummary {
+                crate_id: 0,
+                path: vec!["microcore".to_owned(), "i32".to_owned()],
+                kind: ItemKind::Primitive,
+            },
+        )]),
         external_crates: FxHashMap::default(),
         format_version: rustdoc_json_types::FORMAT_VERSION,
     };
 
-    check(&krate, &[Error {
-        id: Id(2),
-        kind: ErrorKind::Custom("Id for local item in `paths` but not in `index`".to_owned()),
-    }]);
+    check(
+        &krate,
+        &[Error {
+            id: Id(2),
+            kind: ErrorKind::Custom("Id for local item in `paths` but not in `index`".to_owned()),
+        }],
+    );
 }
 
 #[test]
@@ -117,84 +139,96 @@ fn errors_on_missing_path() {
         crate_version: None,
         includes_private: false,
         index: FxHashMap::from_iter([
-            (Id(0), Item {
-                id: Id(0),
-                crate_id: 0,
-                name: Some("foo".to_owned()),
-                span: None,
-                visibility: Visibility::Public,
-                docs: None,
-                links: FxHashMap::default(),
-                attrs: Vec::new(),
-                deprecation: None,
-                inner: ItemEnum::Module(Module {
-                    is_crate: true,
-                    items: vec![Id(1), Id(2)],
-                    is_stripped: false,
-                }),
-            }),
-            (Id(1), Item {
-                id: Id(0),
-                crate_id: 0,
-                name: Some("Bar".to_owned()),
-                span: None,
-                visibility: Visibility::Public,
-                docs: None,
-                links: FxHashMap::default(),
-                attrs: Vec::new(),
-                deprecation: None,
-                inner: ItemEnum::Struct(Struct {
-                    kind: StructKind::Unit,
-                    generics: generics.clone(),
-                    impls: vec![],
-                }),
-            }),
-            (Id(2), Item {
-                id: Id(0),
-                crate_id: 0,
-                name: Some("mk_bar".to_owned()),
-                span: None,
-                visibility: Visibility::Public,
-                docs: None,
-                links: FxHashMap::default(),
-                attrs: Vec::new(),
-                deprecation: None,
-                inner: ItemEnum::Function(Function {
-                    sig: FunctionSignature {
-                        inputs: vec![],
-                        output: Some(Type::ResolvedPath(Path {
-                            path: "Bar".to_owned(),
-                            id: Id(1),
-                            args: None,
-                        })),
-                        is_c_variadic: false,
-                    },
-                    generics,
-                    header: FunctionHeader {
-                        is_const: false,
-                        is_unsafe: false,
-                        is_async: false,
-                        abi: Abi::Rust,
-                    },
-                    has_body: true,
-                }),
-            }),
+            (
+                Id(0),
+                Item {
+                    id: Id(0),
+                    crate_id: 0,
+                    name: Some("foo".to_owned()),
+                    span: None,
+                    visibility: Visibility::Public,
+                    docs: None,
+                    links: FxHashMap::default(),
+                    attrs: Vec::new(),
+                    deprecation: None,
+                    inner: ItemEnum::Module(Module {
+                        is_crate: true,
+                        items: vec![Id(1), Id(2)],
+                        is_stripped: false,
+                    }),
+                },
+            ),
+            (
+                Id(1),
+                Item {
+                    id: Id(0),
+                    crate_id: 0,
+                    name: Some("Bar".to_owned()),
+                    span: None,
+                    visibility: Visibility::Public,
+                    docs: None,
+                    links: FxHashMap::default(),
+                    attrs: Vec::new(),
+                    deprecation: None,
+                    inner: ItemEnum::Struct(Struct {
+                        kind: StructKind::Unit,
+                        generics: generics.clone(),
+                        impls: vec![],
+                    }),
+                },
+            ),
+            (
+                Id(2),
+                Item {
+                    id: Id(0),
+                    crate_id: 0,
+                    name: Some("mk_bar".to_owned()),
+                    span: None,
+                    visibility: Visibility::Public,
+                    docs: None,
+                    links: FxHashMap::default(),
+                    attrs: Vec::new(),
+                    deprecation: None,
+                    inner: ItemEnum::Function(Function {
+                        sig: FunctionSignature {
+                            inputs: vec![],
+                            output: Some(Type::ResolvedPath(Path {
+                                path: "Bar".to_owned(),
+                                id: Id(1),
+                                args: None,
+                            })),
+                            is_c_variadic: false,
+                        },
+                        generics,
+                        header: FunctionHeader {
+                            is_const: false,
+                            is_unsafe: false,
+                            is_async: false,
+                            abi: Abi::Rust,
+                        },
+                        has_body: true,
+                    }),
+                },
+            ),
         ]),
-        paths: FxHashMap::from_iter([(Id(0), ItemSummary {
-            crate_id: 0,
-            path: vec!["foo".to_owned()],
-            kind: ItemKind::Module,
-        })]),
+        paths: FxHashMap::from_iter([(
+            Id(0),
+            ItemSummary { crate_id: 0, path: vec!["foo".to_owned()], kind: ItemKind::Module },
+        )]),
         external_crates: FxHashMap::default(),
         format_version: rustdoc_json_types::FORMAT_VERSION,
     };
 
-    check(&krate, &[Error {
-        kind: ErrorKind::Custom(
-            r#"No entry in '$.paths' for Path { path: "Bar", id: Id(1), args: None }"#.to_owned(),
-        ),
-        id: Id(1),
-    }]);
+    check(
+        &krate,
+        &[Error {
+            kind: ErrorKind::Custom(
+                r#"No entry in '$.paths' for Path { path: "Bar", id: Id(1), args: None }"#
+                    .to_owned(),
+            ),
+            id: Id(1),
+        }],
+    );
 }
 
 #[test]
@@ -204,18 +238,25 @@ fn checks_local_crate_id_is_correct() {
         root: Id(0),
         crate_version: None,
         includes_private: false,
-        index: FxHashMap::from_iter([(Id(0), Item {
-            id: Id(0),
-            crate_id: LOCAL_CRATE_ID.wrapping_add(1),
-            name: Some("irrelavent".to_owned()),
-            span: None,
-            visibility: Visibility::Public,
-            docs: None,
-            links: FxHashMap::default(),
-            attrs: Vec::new(),
-            deprecation: None,
-            inner: ItemEnum::Module(Module { is_crate: true, items: vec![], is_stripped: false }),
-        })]),
+        index: FxHashMap::from_iter([(
+            Id(0),
+            Item {
+                id: Id(0),
+                crate_id: LOCAL_CRATE_ID.wrapping_add(1),
+                name: Some("irrelavent".to_owned()),
+                span: None,
+                visibility: Visibility::Public,
+                docs: None,
+                links: FxHashMap::default(),
+                attrs: Vec::new(),
+                deprecation: None,
+                inner: ItemEnum::Module(Module {
+                    is_crate: true,
+                    items: vec![],
+                    is_stripped: false,
+                }),
+            },
+        )]),
         paths: FxHashMap::default(),
         external_crates: FxHashMap::default(),
         format_version: FORMAT_VERSION,
diff --git a/src/tools/lint-docs/src/lib.rs b/src/tools/lint-docs/src/lib.rs
index f6e84465780..9fd33e23204 100644
--- a/src/tools/lint-docs/src/lib.rs
+++ b/src/tools/lint-docs/src/lib.rs
@@ -19,24 +19,30 @@ mod groups;
 /// level of the lint, which will be more difficult to support, since rustc
 /// currently does not track that historical information.
 static RENAMES: &[(Level, &[(&str, &str)])] = &[
-    (Level::Allow, &[
-        ("single-use-lifetime", "single-use-lifetimes"),
-        ("elided-lifetime-in-path", "elided-lifetimes-in-paths"),
-        ("async-idents", "keyword-idents"),
-        ("disjoint-capture-migration", "rust-2021-incompatible-closure-captures"),
-        ("keyword-idents", "keyword-idents-2018"),
-        ("or-patterns-back-compat", "rust-2021-incompatible-or-patterns"),
-    ]),
-    (Level::Warn, &[
-        ("bare-trait-object", "bare-trait-objects"),
-        ("unstable-name-collision", "unstable-name-collisions"),
-        ("unused-doc-comment", "unused-doc-comments"),
-        ("redundant-semicolon", "redundant-semicolons"),
-        ("overlapping-patterns", "overlapping-range-endpoints"),
-        ("non-fmt-panic", "non-fmt-panics"),
-        ("unused-tuple-struct-fields", "dead-code"),
-        ("static-mut-ref", "static-mut-refs"),
-    ]),
+    (
+        Level::Allow,
+        &[
+            ("single-use-lifetime", "single-use-lifetimes"),
+            ("elided-lifetime-in-path", "elided-lifetimes-in-paths"),
+            ("async-idents", "keyword-idents"),
+            ("disjoint-capture-migration", "rust-2021-incompatible-closure-captures"),
+            ("keyword-idents", "keyword-idents-2018"),
+            ("or-patterns-back-compat", "rust-2021-incompatible-or-patterns"),
+        ],
+    ),
+    (
+        Level::Warn,
+        &[
+            ("bare-trait-object", "bare-trait-objects"),
+            ("unstable-name-collision", "unstable-name-collisions"),
+            ("unused-doc-comment", "unused-doc-comments"),
+            ("redundant-semicolon", "redundant-semicolons"),
+            ("overlapping-patterns", "overlapping-range-endpoints"),
+            ("non-fmt-panic", "non-fmt-panics"),
+            ("unused-tuple-struct-fields", "dead-code"),
+            ("static-mut-ref", "static-mut-refs"),
+        ],
+    ),
     (Level::Deny, &[("exceeding-bitshifts", "arithmetic-overflow")]),
 ];
 
diff --git a/src/tools/rust-installer/src/compression.rs b/src/tools/rust-installer/src/compression.rs
index 96c48657c46..df3a98ae789 100644
--- a/src/tools/rust-installer/src/compression.rs
+++ b/src/tools/rust-installer/src/compression.rs
@@ -81,14 +81,17 @@ impl CompressionFormat {
         let file = crate::util::create_new_file(path)?;
 
         Ok(match self {
-            CompressionFormat::Gz => Box::new(GzEncoder::new(file, match profile {
-                CompressionProfile::Fast => flate2::Compression::fast(),
-                CompressionProfile::Balanced => flate2::Compression::new(6),
-                CompressionProfile::Best => flate2::Compression::best(),
-                CompressionProfile::NoOp => panic!(
-                    "compression profile 'no-op' should not call `CompressionFormat::encode`."
-                ),
-            })),
+            CompressionFormat::Gz => Box::new(GzEncoder::new(
+                file,
+                match profile {
+                    CompressionProfile::Fast => flate2::Compression::fast(),
+                    CompressionProfile::Balanced => flate2::Compression::new(6),
+                    CompressionProfile::Best => flate2::Compression::best(),
+                    CompressionProfile::NoOp => panic!(
+                        "compression profile 'no-op' should not call `CompressionFormat::encode`."
+                    ),
+                },
+            )),
             CompressionFormat::Xz => {
                 let encoder = match profile {
                     CompressionProfile::NoOp => panic!(
diff --git a/src/tools/tidy/src/ext_tool_checks.rs b/src/tools/tidy/src/ext_tool_checks.rs
index 2a4cff1d12e..4f9a20fa9e2 100644
--- a/src/tools/tidy/src/ext_tool_checks.rs
+++ b/src/tools/tidy/src/ext_tool_checks.rs
@@ -95,10 +95,14 @@ fn check_impl(
         if res.is_err() && show_diff {
             eprintln!("\npython linting failed! Printing diff suggestions:");
 
-            let _ = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, &[
-                "check".as_ref(),
-                "--diff".as_ref(),
-            ]);
+            let _ = run_ruff(
+                root_path,
+                outdir,
+                py_path,
+                &cfg_args,
+                &file_args,
+                &["check".as_ref(), "--diff".as_ref()],
+            );
         }
         // Rethrow error
         let _ = res?;
@@ -120,10 +124,14 @@ fn check_impl(
             if show_diff {
                 eprintln!("\npython formatting does not match! Printing diff:");
 
-                let _ = run_ruff(root_path, outdir, py_path, &cfg_args, &file_args, &[
-                    "format".as_ref(),
-                    "--diff".as_ref(),
-                ]);
+                let _ = run_ruff(
+                    root_path,
+                    outdir,
+                    py_path,
+                    &cfg_args,
+                    &file_args,
+                    &["format".as_ref(), "--diff".as_ref()],
+                );
             }
             eprintln!("rerun tidy with `--extra-checks=py:fmt --bless` to reformat Python code");
         }
@@ -148,10 +156,11 @@ fn check_impl(
         let files;
         if file_args_clang_format.is_empty() {
             let llvm_wrapper = root_path.join("compiler/rustc_llvm/llvm-wrapper");
-            files = find_with_extension(root_path, Some(llvm_wrapper.as_path()), &[
-                OsStr::new("h"),
-                OsStr::new("cpp"),
-            ])?;
+            files = find_with_extension(
+                root_path,
+                Some(llvm_wrapper.as_path()),
+                &[OsStr::new("h"), OsStr::new("cpp")],
+            )?;
             file_args_clang_format.extend(files.iter().map(|p| p.as_os_str()));
         }
         let args = merge_args(&cfg_args_clang_format, &file_args_clang_format);
diff --git a/src/tools/tidy/src/known_bug.rs b/src/tools/tidy/src/known_bug.rs
index a8771654144..e1921715ab9 100644
--- a/src/tools/tidy/src/known_bug.rs
+++ b/src/tools/tidy/src/known_bug.rs
@@ -14,13 +14,10 @@ pub fn check(filepath: &Path, bad: &mut bool) {
         let test_path_segments_str =
             test_path_segments.iter().map(|s| s.as_str()).collect::<Vec<&str>>();
 
-        if !matches!(test_path_segments_str[..], [
-            ..,
-            "tests",
-            "crashes",
-            "auxiliary",
-            _aux_file_rs
-        ]) && !contents.lines().any(|line| line.starts_with("//@ known-bug: "))
+        if !matches!(
+            test_path_segments_str[..],
+            [.., "tests", "crashes", "auxiliary", _aux_file_rs]
+        ) && !contents.lines().any(|line| line.starts_with("//@ known-bug: "))
         {
             tidy_error!(
                 bad,
diff --git a/src/tools/unicode-table-generator/src/raw_emitter.rs b/src/tools/unicode-table-generator/src/raw_emitter.rs
index 46010692fe5..ee94d3c93a6 100644
--- a/src/tools/unicode-table-generator/src/raw_emitter.rs
+++ b/src/tools/unicode-table-generator/src/raw_emitter.rs
@@ -355,12 +355,15 @@ impl Canonicalized {
         let unique_mapping = unique_mapping
             .into_iter()
             .map(|(key, value)| {
-                (key, match value {
-                    UniqueMapping::Canonicalized(idx) => {
-                        u8::try_from(canonical_words.len() + idx).unwrap()
-                    }
-                    UniqueMapping::Canonical(idx) => u8::try_from(idx).unwrap(),
-                })
+                (
+                    key,
+                    match value {
+                        UniqueMapping::Canonicalized(idx) => {
+                            u8::try_from(canonical_words.len() + idx).unwrap()
+                        }
+                        UniqueMapping::Canonical(idx) => u8::try_from(idx).unwrap(),
+                    },
+                )
             })
             .collect::<HashMap<_, _>>();
 
@@ -375,21 +378,24 @@ impl Canonicalized {
         let canonicalized_words = canonicalized_words
             .into_iter()
             .map(|v| {
-                (u8::try_from(v.0).unwrap(), match v.1 {
-                    Mapping::RotateAndInvert(amount) => {
-                        assert_eq!(amount, amount & LOWER_6);
-                        1 << 6 | (amount as u8)
-                    }
-                    Mapping::Rotate(amount) => {
-                        assert_eq!(amount, amount & LOWER_6);
-                        amount as u8
-                    }
-                    Mapping::Invert => 1 << 6,
-                    Mapping::ShiftRight(shift_by) => {
-                        assert_eq!(shift_by, shift_by & LOWER_6);
-                        1 << 7 | (shift_by as u8)
-                    }
-                })
+                (
+                    u8::try_from(v.0).unwrap(),
+                    match v.1 {
+                        Mapping::RotateAndInvert(amount) => {
+                            assert_eq!(amount, amount & LOWER_6);
+                            1 << 6 | (amount as u8)
+                        }
+                        Mapping::Rotate(amount) => {
+                            assert_eq!(amount, amount & LOWER_6);
+                            amount as u8
+                        }
+                        Mapping::Invert => 1 << 6,
+                        Mapping::ShiftRight(shift_by) => {
+                            assert_eq!(shift_by, shift_by & LOWER_6);
+                            1 << 7 | (shift_by as u8)
+                        }
+                    },
+                )
             })
             .collect::<Vec<(u8, u8)>>();
         Canonicalized { unique_mapping, canonical_words, canonicalized_words }