Fix Rust code formatting

Author: tschneidereit

crates/spidermonkey-embedding-splicer/src/bin/splicer.rs

@@ -3,8 +3,8 @@ use clap::{Parser, Subcommand};
 use std::fs;
 use std::path::PathBuf;
 
-use spidermonkey_embedding_splicer::{splice, stub_wasi};
 use spidermonkey_embedding_splicer::wit::Features;
+use spidermonkey_embedding_splicer::{splice, stub_wasi};
 
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
@@ -129,14 +129,8 @@ fn main() -> Result<()> {
 
             let wit_path_str = wit_path.as_ref().map(|p| p.to_string_lossy().to_string());
 
-            let result = splice::splice_bindings(
-                engine,
-                world_name,
-                wit_path_str,
-                None,
-                debug,
-            )
-            .map_err(|e| anyhow::anyhow!(e))?;
+            let result = splice::splice_bindings(engine, world_name, wit_path_str, None, debug)
+                .map_err(|e| anyhow::anyhow!(e))?;
             fs::write(&out_dir.join("component.wasm"), result.wasm).with_context(|| {
                 format!(
                     "Failed to write output file: {}",

crates/spidermonkey-embedding-splicer/src/bindgen.rs

@@ -129,10 +129,7 @@ pub struct Componentization {
     pub resource_imports: Vec<(String, String, u32)>,
 }
 
-pub fn componentize_bindgen(
-    resolve: &Resolve,
-    wid: WorldId,
-) -> Result<Componentization> {
+pub fn componentize_bindgen(resolve: &Resolve, wid: WorldId) -> Result<Componentization> {
     let mut bindgen = JsBindgen {
         src: Source::default(),
         esm_bindgen: EsmBindgen::default(),
@@ -222,9 +219,7 @@ pub fn componentize_bindgen(
         let joined_bindings = specifier_list.join(",\n\t");
         import_wrappers.push((
             specifier.to_string(),
-            format!(
-                "defineBuiltinModule('{specifier}', {{\n\t{joined_bindings}\n}});"
-            ),
+            format!("defineBuiltinModule('{specifier}', {{\n\t{joined_bindings}\n}});"),
         ));
     }
 
@@ -374,13 +369,13 @@ pub fn componentize_bindgen(
     output.push_str(&js_intrinsics);
     output.push_str(&bindgen.src);
 
-    import_wrappers.iter().for_each(|(_, src)| output.push_str(&format!("\n\n{src}")));
+    import_wrappers
+        .iter()
+        .for_each(|(_, src)| output.push_str(&format!("\n\n{src}")));
 
-    bindgen.esm_bindgen.render_export_imports(
-        &mut output,
-        "$source_mod",
-        &mut bindgen.local_names,
-    );
+    bindgen
+        .esm_bindgen
+        .render_export_imports(&mut output, "$source_mod", &mut bindgen.local_names);
 
     Ok(Componentization {
         js_bindings: output.to_string(),
@@ -1206,10 +1201,12 @@ impl EsmBindgen {
         }
 
         let mut bind_exports = Source::default();
-        bind_exports.push_str("let __sourceName;
+        bind_exports.push_str(
+            "let __sourceName;
                                    function bindExports(sourceName) {
                                    __sourceName = sourceName;
-                                   let __iface;");
+                                   let __iface;",
+        );
         for (export_name, binding) in &self.exports {
             match binding {
                 Binding::Interface(bindings) => {
@@ -1275,19 +1272,25 @@ impl EsmBindgen {
                     }
                 }
                 Binding::Resource(local_name) => {
-                    uwriteln!(output, "
+                    uwriteln!(
+                        output,
+                        "
                         let {local_name};
-                    ");
+                    "
+                    );
                     uwriteln!(bind_exports, "
                         {local_name} = {imports_object}.{export_name};
                         if (typeof {local_name} !== 'function')
                             throw new BindingsError('{export_name}', 'function', '', `export function {export_name} () {{}};\n`);
                     ");
                 }
                 Binding::Local(local_name) => {
-                    uwriteln!(output, "
+                    uwriteln!(
+                        output,
+                        "
                         let {local_name};
-                    ");
+                    "
+                    );
                     uwriteln!(bind_exports, "
                         {local_name} = {imports_object}.{export_name};
                         if (typeof {local_name} !== 'function')

crates/spidermonkey-embedding-splicer/src/lib.rs

@@ -1,12 +1,12 @@
-use std::path::Path;
 use anyhow::{bail, Context, Result};
+use std::path::Path;
 
 pub mod bindgen;
 pub mod splice;
 pub mod stub_wasi;
 
-use wit_parser::{PackageId, Resolve};
 use crate::wit::{CoreFn, CoreTy};
+use wit_parser::{PackageId, Resolve};
 
 pub mod wit {
     wit_bindgen::generate!({
@@ -85,4 +85,3 @@ fn parse_wit(path: &Path) -> Result<(Resolve, PackageId)> {
     };
     Ok((resolve, id))
 }
-

crates/spidermonkey-embedding-splicer/src/splice.rs

@@ -1,22 +1,22 @@
+use crate::bindgen::BindingItem;
+use crate::wit::{CoreFn, CoreTy, SpliceResult};
+use crate::{bindgen, map_core_fn, parse_wit, splice};
 use anyhow::Result;
-use wasm_encoder::{Encode, Section};
-use std::path::PathBuf;
 use orca_wasm::ir::function::{FunctionBuilder, FunctionModifier};
 use orca_wasm::ir::id::{ExportsID, FunctionID, LocalID};
 use orca_wasm::ir::module::Module;
 use orca_wasm::ir::types::{BlockType, ElementItems, InstrumentationMode};
 use orca_wasm::module_builder::AddLocal;
 use orca_wasm::opcode::{Inject, InjectAt};
 use orca_wasm::{DataType, Opcode};
+use std::path::PathBuf;
+use wasm_encoder::{Encode, Section};
 use wasmparser::ExternalKind;
 use wasmparser::MemArg;
 use wasmparser::Operator;
 use wit_component::metadata::{decode, Bindgen};
 use wit_component::StringEncoding;
 use wit_parser::Resolve;
-use crate::{bindgen, map_core_fn, parse_wit, splice};
-use crate::bindgen::BindingItem;
-use crate::wit::{CoreFn, CoreTy, SpliceResult};
 
 // Returns
 // pub struct SpliceResult {
@@ -53,14 +53,14 @@ pub fn splice_bindings(
 
     // merge the engine world with the target world, retaining the engine producers
     let (engine_world, producers) = if let Ok((
-                                                  _,
-                                                  Bindgen {
-                                                      resolve: mut engine_resolve,
-                                                      world: engine_world,
-                                                      metadata: _,
-                                                      producers,
-                                                  },
-                                              )) = decode(&engine)
+        _,
+        Bindgen {
+            resolve: mut engine_resolve,
+            world: engine_world,
+            metadata: _,
+            producers,
+        },
+    )) = decode(&engine)
     {
         // we disable the engine run and incoming handler as we recreate these exports
         // when needed, so remove these from the world before initiating the merge
@@ -104,23 +104,16 @@ pub fn splice_bindings(
         unreachable!();
     };
 
-    let componentized = bindgen::componentize_bindgen(
-        &resolve,
-        world,
-    )
-        .map_err(|err| err.to_string())?;
+    let componentized =
+        bindgen::componentize_bindgen(&resolve, world).map_err(|err| err.to_string())?;
 
     resolve
         .merge_worlds(engine_world, world)
         .expect("unable to merge with engine world");
 
-    let encoded = wit_component::metadata::encode(
-        &resolve,
-        world,
-        StringEncoding::UTF8,
-        producers.as_ref(),
-    )
-        .map_err(|e| e.to_string())?;
+    let encoded =
+        wit_component::metadata::encode(&resolve, world, StringEncoding::UTF8, producers.as_ref())
+            .map_err(|e| e.to_string())?;
 
     let section = wasm_encoder::CustomSection {
         name: "component-type".into(),
@@ -254,9 +247,6 @@ pub fn splice_bindings(
         ));
     }
 
-    // println!("{:?}", &componentized.imports);
-    // println!("{:?}", &componentized.resource_imports);
-    // println!("{:?}", &exports);
     let mut wasm =
         splice::splice(engine, imports, exports, debug).map_err(|e| format!("{:?}", e))?;
 
@@ -271,27 +261,27 @@ pub fn splice_bindings(
             .iter()
             .map(
                 |(
-                     _,
-                     BindingItem {
-                         binding_name, func, ..
-                     },
-                 )| { (binding_name.to_string(), map_core_fn(&func)) },
+                    _,
+                    BindingItem {
+                        binding_name, func, ..
+                    },
+                )| { (binding_name.to_string(), map_core_fn(&func)) },
             )
             .collect(),
         imports: componentized
             .imports
             .iter()
             .map(
                 |(
-                     specifier,
-                     BindingItem {
-                         name,
-                         iface,
-                         func,
-                         resource,
-                         ..
-                     },
-                 )| {
+                    specifier,
+                    BindingItem {
+                        name,
+                        iface,
+                        func,
+                        resource,
+                        ..
+                    },
+                )| {
                     (
                         if *iface {
                             specifier.to_string()

crates/spidermonkey-embedding-splicer/src/stub_wasi.rs

@@ -1,3 +1,5 @@
+use crate::parse_wit;
+use crate::wit::Features;
 use anyhow::{bail, Result};
 use orca_wasm::ir::function::FunctionBuilder;
 use orca_wasm::ir::id::{FunctionID, LocalID};
@@ -12,8 +14,6 @@ use std::{
 };
 use wasmparser::{MemArg, TypeRef};
 use wit_parser::Resolve;
-use crate::parse_wit;
-use crate::wit::Features;
 
 const WASI_VERSIONS: [&str; 4] = ["0.2.0", "0.2.1", "0.2.2", "0.2.3"];
 

crates/splicer-component/src/lib.rs

@@ -1,6 +1,6 @@
-use spidermonkey_embedding_splicer::{splice, wit};
-use spidermonkey_embedding_splicer::wit::{export, Features, Guest, SpliceResult};
 use spidermonkey_embedding_splicer::stub_wasi::stub_wasi;
+use spidermonkey_embedding_splicer::wit::{export, Features, Guest, SpliceResult};
+use spidermonkey_embedding_splicer::{splice, wit};
 
 struct SpidermonkeyEmbeddingSplicerComponent;