style(rust): Format all Rust code with rustfmt r/3791

Change-Id: Iab7e00cc26a4f9727d3ab98691ef379921a33052
Reviewed-on: https://cl.tvl.fyi/c/depot/+/5240
Tested-by: BuildkiteCI
Reviewed-by: kanepyork <rikingcoding@gmail.com>
Reviewed-by: Profpatsch <mail@profpatsch.de>
Reviewed-by: grfn <grfn@gws.fyi>
Reviewed-by: tazjin <tazjin@tvl.su>

4 files changed, 84 insertions, 30 deletions

diff --git a/tools/cheddar/build.rs b/tools/cheddar/build.rs
index b63b2e3378..f70818d801 100644
--- a/tools/cheddar/build.rs
+++ b/tools/cheddar/build.rs
@@ -28,14 +28,19 @@ fn main() {
 
     // Otherwise ask Nix to build it and inject the result.
     let output = Command::new("nix-build")
-        .arg("-A").arg("third_party.bat_syntaxes")
+        .arg("-A")
+        .arg("third_party.bat_syntaxes")
         // ... assuming cheddar is at //tools/cheddar ...
         .arg("../..")
         .output()
         .expect(ERROR_MESSAGE);
 
     if !output.status.success() {
-        eprintln!("{}\nNix output: {}", ERROR_MESSAGE, String::from_utf8_lossy(&output.stderr));
+        eprintln!(
+            "{}\nNix output: {}",
+            ERROR_MESSAGE,
+            String::from_utf8_lossy(&output.stderr)
+        );
         return;
     }
 
diff --git a/tools/cheddar/src/bin/cheddar.rs b/tools/cheddar/src/bin/cheddar.rs
index 58ef32a1b4..48c504d535 100644
--- a/tools/cheddar/src/bin/cheddar.rs
+++ b/tools/cheddar/src/bin/cheddar.rs
@@ -5,14 +5,13 @@
 //! 2. As a long-running HTTP server that handles rendering requests
 //!    (matching the SourceGraph protocol).
 use clap::{App, Arg};
-use rouille::Response;
-use rouille::{router, try_or_400};
+use rouille::{router, try_or_400, Response};
 use serde::Deserialize;
 use serde_json::json;
 use std::collections::HashMap;
 use std::io;
 
-use cheddar::{THEMES, format_code, format_markdown};
+use cheddar::{format_code, format_markdown, THEMES};
 
 // Server endpoint for rendering the syntax of source code. This
 // replaces the 'syntect_server' component of Sourcegraph.
diff --git a/tools/cheddar/src/lib.rs b/tools/cheddar/src/lib.rs
index da0eace175..851bd743db 100644
--- a/tools/cheddar/src/lib.rs
+++ b/tools/cheddar/src/lib.rs
@@ -8,12 +8,10 @@ use lazy_static::lazy_static;
 use regex::Regex;
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::env;
 use std::ffi::OsStr;
-use std::io;
-use std::io::BufRead;
-use std::io::Write;
+use std::io::{BufRead, Write};
 use std::path::Path;
+use std::{env, io};
 use syntect::dumps::from_binary;
 use syntect::easy::HighlightLines;
 use syntect::highlighting::{Theme, ThemeSet};
diff --git a/tools/rust-crates-advisory/check-security-advisory.rs b/tools/rust-crates-advisory/check-security-advisory.rs
index 3fd9bc2dd9..e76b090abc 100644
--- a/tools/rust-crates-advisory/check-security-advisory.rs
+++ b/tools/rust-crates-advisory/check-security-advisory.rs
@@ -14,42 +14,89 @@ use std::io::Write;
 fn main() {
     let mut args = std::env::args_os();
     let file = args.nth(1).expect("security advisory md file is $1");
-    let crate_version =
-        args.nth(0).expect("crate version is $2")
-        .into_string().expect("crate version string not utf8")
-        ;
-    let crate_version = semver::Version::parse(&crate_version).expect(&format!("this is not a semver version: {}", &crate_version));
+    let crate_version = args
+        .nth(0)
+        .expect("crate version is $2")
+        .into_string()
+        .expect("crate version string not utf8");
+    let crate_version = semver::Version::parse(&crate_version)
+        .expect(&format!("this is not a semver version: {}", &crate_version));
     let filename = file.to_string_lossy();
 
     let content = std::fs::read(&file).expect(&format!("could not read {}", filename));
-    let content =
-        std::str::from_utf8(&content).expect(&format!("file {} was not encoded as utf-8", filename));
+    let content = std::str::from_utf8(&content)
+        .expect(&format!("file {} was not encoded as utf-8", filename));
     let content = content.trim_start();
 
     let toml_start = content
-        .strip_prefix("```toml").expect(&format!("file did not start with ```toml: {}", filename));
-    let toml_end_index = toml_start.find("```").expect(&format!("the toml section did not end, no `` found: {}", filename));
+        .strip_prefix("```toml")
+        .expect(&format!("file did not start with ```toml: {}", filename));
+    let toml_end_index = toml_start.find("```").expect(&format!(
+        "the toml section did not end, no `` found: {}",
+        filename
+    ));
     let toml = &toml_start[..toml_end_index];
-    let toml : toml::Value = toml::de::from_slice(toml.as_bytes()).expect(&format!("could not parse toml: {}", filename));
+    let toml: toml::Value = toml::de::from_slice(toml.as_bytes())
+        .expect(&format!("could not parse toml: {}", filename));
 
     let versions = toml
-        .as_table().expect(&format!("the toml is not a table: {}", filename))
-        .get("versions").expect(&format!("the toml does not contain the versions field: {}", filename))
-        .as_table().expect(&format!("the toml versions field must be a table: {}", filename));
+        .as_table()
+        .expect(&format!("the toml is not a table: {}", filename))
+        .get("versions")
+        .expect(&format!(
+            "the toml does not contain the versions field: {}",
+            filename
+        ))
+        .as_table()
+        .expect(&format!(
+            "the toml versions field must be a table: {}",
+            filename
+        ));
 
     let unaffected = match versions.get("unaffected") {
         Some(u) => u
-            .as_array().expect(&format!("the toml versions.unaffected field must be a list of semvers: {}", filename))
+            .as_array()
+            .expect(&format!(
+                "the toml versions.unaffected field must be a list of semvers: {}",
+                filename
+            ))
             .iter()
-            .map(|v| semver::VersionReq::parse(v.as_str().expect(&format!("the version field {} is not a string", v))).expect(&format!("the version field {} is not a valid semver VersionReq", v)))
+            .map(|v| {
+                semver::VersionReq::parse(
+                    v.as_str()
+                        .expect(&format!("the version field {} is not a string", v)),
+                )
+                .expect(&format!(
+                    "the version field {} is not a valid semver VersionReq",
+                    v
+                ))
+            })
             .collect(),
-        None => vec![]
+        None => vec![],
     };
 
-    let mut patched : Vec<semver::VersionReq> = versions.get("patched").expect(&format!("the toml versions.patched field must exist: {}", filename))
-        .as_array().expect(&format!("the toml versions.patched field must be a list of semvers: {}", filename))
+    let mut patched: Vec<semver::VersionReq> = versions
+        .get("patched")
+        .expect(&format!(
+            "the toml versions.patched field must exist: {}",
+            filename
+        ))
+        .as_array()
+        .expect(&format!(
+            "the toml versions.patched field must be a list of semvers: {}",
+            filename
+        ))
         .iter()
-        .map(|v| semver::VersionReq::parse(v.as_str().expect(&format!("the version field {} is not a string", v))).expect(&format!("the version field {} is not a valid semver VersionReq", v)))
+        .map(|v| {
+            semver::VersionReq::parse(
+                v.as_str()
+                    .expect(&format!("the version field {} is not a string", v)),
+            )
+            .expect(&format!(
+                "the version field {} is not a valid semver VersionReq",
+                v
+            ))
+        })
         .collect();
 
     patched.extend_from_slice(&unaffected[..]);
@@ -59,9 +106,14 @@ fn main() {
         std::process::exit(0);
     } else {
         if std::env::var_os("PRINT_ADVISORY").is_some() {
-            write!(std::io::stderr(), "Advisory {} matched!\n{}\n", filename, content).unwrap();
+            write!(
+                std::io::stderr(),
+                "Advisory {} matched!\n{}\n",
+                filename,
+                content
+            )
+            .unwrap();
         }
         std::process::exit(1);
     }
-
 }