Merge pull request #14 from dhil/wasmfx-merge

Merge with upstream

Author: dhil

Cargo.lock

@@ -27,6 +27,8 @@ heck = { version = "0.5" }
 pulldown-cmark = { version = "0.9", default-features = false }
 clap = { version = "4.3.19", features = ["derive"] }
 indexmap = "2.0.0"
+prettyplease = "0.2.20"
+syn = { version = "2.0", features = ["printing"] }
 
 wasmparser    = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "v1.209.0" }
 wasm-metadata = { git = "https://github.com/wasmfx/wasmfx-tools", tag = "v1.209.0" }

Cargo.toml

@@ -118,6 +118,10 @@ impl Source {
     pub fn as_mut_string(&mut self) -> &mut String {
         &mut self.s
     }
+
+    pub fn as_str(&self) -> &str {
+        &self.s
+    }
 }
 
 impl Write for Source {

crates/core/src/source.rs

@@ -17,8 +17,10 @@ test = false
 
 [dependencies]
 proc-macro2 = "1.0"
-syn = { version = "2.0", features = ["printing"] }
 quote = "1"
 wit-bindgen-core = { workspace = true }
 wit-bindgen-rust = { workspace = true }
 anyhow = { workspace = true }
+syn = { workspace = true }
+prettyplease = { workspace = true }
+

crates/guest-rust/macro/Cargo.toml

@@ -191,15 +191,12 @@ impl Config {
             let n = INVOCATION.fetch_add(1, Relaxed);
             let path = root.join(format!("{world_name}{n}.rs"));
 
-            std::fs::write(&path, &src).unwrap();
-
             // optimistically format the code but don't require success
-            drop(
-                std::process::Command::new("rustfmt")
-                    .arg(&path)
-                    .arg("--edition=2021")
-                    .output(),
-            );
+            let contents = match fmt(&src) {
+                Ok(formatted) => formatted,
+                Err(_) => src.clone(),
+            };
+            std::fs::write(&path, contents.as_bytes()).unwrap();
 
             src = format!("include!({path:?});");
         }
@@ -472,3 +469,9 @@ fn with_field_parse(input: ParseStream<'_>) -> Result<(String, String)> {
 
     Ok((interface, buf))
 }
+
+/// Format a valid Rust string
+fn fmt(input: &str) -> Result<String> {
+    let syntax_tree = syn::parse_file(&input)?;
+    Ok(prettyplease::unparse(&syntax_tree))
+}

crates/guest-rust/macro/src/lib.rs

@@ -23,6 +23,8 @@ wasm-metadata = { workspace = true }
 heck = { workspace = true }
 clap = { workspace = true, optional = true }
 indexmap = { workspace = true }
+syn = { workspace = true }
+prettyplease = { workspace = true }
 
 [dev-dependencies]
 wit-bindgen = { path = '../guest-rust' }

crates/rust/Cargo.toml

@@ -4,9 +4,7 @@ use heck::*;
 use indexmap::IndexSet;
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fmt::{self, Write as _};
-use std::io::{Read, Write};
 use std::mem;
-use std::process::{Command, Stdio};
 use std::str::FromStr;
 use wit_bindgen_core::abi::{Bitcast, WasmType};
 use wit_bindgen_core::{
@@ -86,9 +84,9 @@ fn parse_with(s: &str) -> Result<(String, String), String> {
 #[derive(Default, Debug, Clone)]
 #[cfg_attr(feature = "clap", derive(clap::Args))]
 pub struct Opts {
-    /// Whether or not `rustfmt` is executed to format generated code.
+    /// Whether or not a formatter is executed to format generated code.
     #[cfg_attr(feature = "clap", arg(long))]
-    pub rustfmt: bool,
+    pub format: bool,
 
     /// If true, code generation should qualify any features that depend on
     /// `std` with `cfg(feature = "std")`.
@@ -1022,28 +1020,9 @@ impl WorldGenerator for RustWasm {
         }
 
         let mut src = mem::take(&mut self.src);
-        if self.opts.rustfmt {
-            let mut child = Command::new("rustfmt")
-                .arg("--edition=2018")
-                .stdin(Stdio::piped())
-                .stdout(Stdio::piped())
-                .spawn()
-                .expect("failed to spawn `rustfmt`");
-            child
-                .stdin
-                .take()
-                .unwrap()
-                .write_all(src.as_bytes())
-                .unwrap();
-            src.as_mut_string().truncate(0);
-            child
-                .stdout
-                .take()
-                .unwrap()
-                .read_to_string(src.as_mut_string())
-                .unwrap();
-            let status = child.wait().unwrap();
-            assert!(status.success());
+        if self.opts.format {
+            let syntax_tree = syn::parse_file(src.as_str()).unwrap();
+            *src.as_mut_string() = prettyplease::unparse(&syntax_tree);
         }
 
         let module_name = name.to_snake_case();

crates/rust/src/lib.rs

@@ -72,14 +72,24 @@ struct Common {
     #[clap(long = "out-dir")]
     out_dir: Option<PathBuf>,
 
-    /// WIT document to generate bindings for.
-    #[clap(value_name = "DOCUMENT", index = 1)]
+    /// Location of WIT file(s) to generate bindings for.
+    ///
+    /// This path can be either a directory containing `*.wit` files, a `*.wit`
+    /// file itself, or a `*.wasm` file which is a wasm-encoded WIT package.
+    /// Most of the time it's likely to be a directory containing `*.wit` files
+    /// with an optional `deps` folder inside of it.
+    #[clap(value_name = "WIT", index = 1)]
     wit: PathBuf,
 
-    /// World within the WIT document specified to generate bindings for.
+    /// Optionally specified world that bindings are generated for.
     ///
-    /// This can either be `foo` which is the default world in document `foo` or
-    /// it's `foo.bar` which is the world named `bar` within document `foo`.
+    /// Bindings are always generated for a world but this option can be omitted
+    /// when the WIT package pointed to by the `WIT` option only has a single
+    /// world. If there's more than one world in the package then this option
+    /// must be specified to name the world that bindings are generated for.
+    /// This option can also use the fully qualified syntax such as
+    /// `wasi:http/proxy` to select a world from a dependency of the main WIT
+    /// package.
     #[clap(short, long)]
     world: Option<String>,