Bug 1943149 - chore(swgl): cargo +1.84 fmt r=gfx-reviewers,lsalzman

Differential Revision: https://phabricator.services.mozilla.com/D235502

Author: ErichDonGubler

swgl/build.rs

@@ -8,7 +8,7 @@ extern crate webrender_build;
 
 use std::collections::HashSet;
 use std::fmt::Write;
-use webrender_build::shader::{ShaderFeatureFlags, get_shader_features};
+use webrender_build::shader::{get_shader_features, ShaderFeatureFlags};
 
 // Shader key is in "name feature,feature" format.
 // File name needs to be formatted as "name_feature_feature".
@@ -23,22 +23,35 @@ fn write_load_shader(shader_keys: &[String]) {
     }
     load_shader.push_str("ProgramLoader load_shader(const char* name) {\n");
     for s in shader_keys {
-        let _ = write!(load_shader, "  if (!strcmp(name, \"{}\")) {{ return {}_program::loader; }}\n",
-                       s, shader_file(s));
+        let _ = write!(
+            load_shader,
+            "  if (!strcmp(name, \"{}\")) {{ return {}_program::loader; }}\n",
+            s,
+            shader_file(s)
+        );
     }
     load_shader.push_str("  return nullptr;\n}\n");
-    std::fs::write(std::env::var("OUT_DIR").unwrap() + "/load_shader.h", load_shader).unwrap();
+    std::fs::write(
+        std::env::var("OUT_DIR").unwrap() + "/load_shader.h",
+        load_shader,
+    )
+    .unwrap();
 }
 
-fn process_imports(shader_dir: &str, shader: &str, included: &mut HashSet<String>, output: &mut String) {
+fn process_imports(
+    shader_dir: &str,
+    shader: &str,
+    included: &mut HashSet<String>,
+    output: &mut String,
+) {
     if !included.insert(shader.into()) {
         return;
     }
     println!("cargo:rerun-if-changed={}/{}.glsl", shader_dir, shader);
     let source = std::fs::read_to_string(format!("{}/{}.glsl", shader_dir, shader)).unwrap();
     for line in source.lines() {
         if line.starts_with("#include ") {
-            let imports = line["#include ".len() ..].split(',');
+            let imports = line["#include ".len()..].split(',');
             for import in imports {
                 process_imports(shader_dir, import, included, output);
             }
@@ -57,8 +70,11 @@ fn translate_shader(
     suppressed_env_vars: &mut Option<Vec<EnvVarGuard>>,
 ) {
     let mut imported = String::from("#define SWGL 1\n#define __VERSION__ 150\n");
-    let _ = write!(imported, "#define WR_MAX_VERTEX_TEXTURE_WIDTH {}U\n",
-                   webrender_build::MAX_VERTEX_TEXTURE_WIDTH);
+    let _ = write!(
+        imported,
+        "#define WR_MAX_VERTEX_TEXTURE_WIDTH {}U\n",
+        webrender_build::MAX_VERTEX_TEXTURE_WIDTH
+    );
 
     let (basename, features) =
         shader_key.split_at(shader_key.find(' ').unwrap_or(shader_key.len()));
@@ -112,38 +128,36 @@ fn translate_shader(
         }
     }
     build.file(&imp_name);
-    let vs = build.clone()
-        .define("WR_VERTEX_SHADER", Some("1"))
-        .expand();
-    let fs = build.clone()
+    let vs = build.clone().define("WR_VERTEX_SHADER", Some("1")).expand();
+    let fs = build
+        .clone()
         .define("WR_FRAGMENT_SHADER", Some("1"))
         .expand();
     let vs_name = format!("{}/{}.vert", out_dir, shader);
     let fs_name = format!("{}/{}.frag", out_dir, shader);
     std::fs::write(&vs_name, vs).unwrap();
     std::fs::write(&fs_name, fs).unwrap();
 
-    let args = vec![
-        "glsl_to_cxx".to_string(),
-        vs_name,
-        fs_name,
-    ];
+    let args = vec!["glsl_to_cxx".to_string(), vs_name, fs_name];
     let result = glsl_to_cxx::translate(&mut args.into_iter());
     std::fs::write(format!("{}/{}.h", out_dir, shader), result).unwrap();
 }
 
 fn main() {
     let shader_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap() + "/../webrender/res";
 
-    let shader_flags =
-        ShaderFeatureFlags::GL |
-        ShaderFeatureFlags::DUAL_SOURCE_BLENDING |
-        ShaderFeatureFlags::ADVANCED_BLEND_EQUATION |
-        ShaderFeatureFlags::DEBUG;
+    let shader_flags = ShaderFeatureFlags::GL
+        | ShaderFeatureFlags::DUAL_SOURCE_BLENDING
+        | ShaderFeatureFlags::ADVANCED_BLEND_EQUATION
+        | ShaderFeatureFlags::DEBUG;
     let mut shaders: Vec<String> = Vec::new();
     for (name, features) in get_shader_features(shader_flags) {
         shaders.extend(features.iter().map(|f| {
-            if f.is_empty() { name.to_owned() } else { format!("{} {}", name, f) }
+            if f.is_empty() {
+                name.to_owned()
+            } else {
+                format!("{} {}", name, f)
+            }
         }));
     }
 
@@ -172,16 +186,18 @@ fn main() {
 
     if let Ok(tool) = build.try_get_compiler() {
         if tool.is_like_msvc() {
-            build.flag("/std:c++17")
-                 .flag("/EHs-")
-                 .flag("/GR-")
-                 .flag("/UMOZILLA_CONFIG_H");
+            build
+                .flag("/std:c++17")
+                .flag("/EHs-")
+                .flag("/GR-")
+                .flag("/UMOZILLA_CONFIG_H");
         } else {
-            build.flag("-std=c++17")
-                 .flag("-fno-exceptions")
-                 .flag("-fno-rtti")
-                 .flag("-fno-math-errno")
-                 .flag("-UMOZILLA_CONFIG_H");
+            build
+                .flag("-std=c++17")
+                .flag("-fno-exceptions")
+                .flag("-fno-rtti")
+                .flag("-fno-math-errno")
+                .flag("-UMOZILLA_CONFIG_H");
         }
         // SWGL relies heavily on inlining for performance so override -Oz with -O2
         if tool.args().contains(&"-Oz".into()) {
@@ -197,20 +213,23 @@ fn main() {
         // probably explicitly use reciprocal instructions and avoid the refinement step.
         // Also, allow checks for non-finite values which fast-math may disable.
         if tool.is_like_msvc() {
-            build.flag("/fp:fast")
-                 .flag("-Xclang")
-                 .flag("-mrecip=none")
-                 .flag("/clang:-fno-finite-math-only");
+            build
+                .flag("/fp:fast")
+                .flag("-Xclang")
+                .flag("-mrecip=none")
+                .flag("/clang:-fno-finite-math-only");
         } else if tool.is_like_clang() {
             // gcc only supports -mrecip=none on some targets so to keep
             // things simple we don't use -ffast-math with gcc at all
-            build.flag("-ffast-math")
-                 .flag("-mrecip=none")
-                 .flag("-fno-finite-math-only");
+            build
+                .flag("-ffast-math")
+                .flag("-mrecip=none")
+                .flag("-fno-finite-math-only");
         }
     }
 
-    build.file("src/gl.cc")
+    build
+        .file("src/gl.cc")
         .define("_GLIBCXX_USE_CXX11_ABI", Some("0"))
         .include(shader_dir)
         .include("src")