Don't run Cargo in a build script

Instead refactor things so webidl-tests can use the Rust-code-generation
as a library in a build script. Also fixes `cargo fmt` in the
repository.

Author: alexcrichton

crates/web-sys/src/lib.rs

@@ -14,6 +14,7 @@
 #![doc(html_root_url = "https://docs.rs/web-sys/0.2")]
 #![allow(deprecated)]
 
+#[allow(unused_imports, non_snake_case)]
 mod features;
 pub use features::*;
 

crates/webidl-tests/Cargo.toml

@@ -3,6 +3,7 @@ name = "webidl-tests"
 version = "0.1.0"
 authors = ["The wasm-bindgen Developers"]
 edition = "2018"
+publish = false
 
 [lib]
 test = false
@@ -13,6 +14,9 @@ path = 'lib.rs'
 js-sys = { path = '../js-sys' }
 wasm-bindgen = { path = '../..' }
 
+[build-dependencies]
+wasm-bindgen-webidl = { path = "../webidl" }
+
 [dev-dependencies]
 wasm-bindgen-test = { path = '../test' }
 

crates/webidl-tests/build.rs

@@ -1,18 +1,7 @@
-use std::io::Result;
-use std::process::Command;
+use std::env;
+use std::path::PathBuf;
 
-fn main() -> Result<()> {
-    let result = Command::new("cargo")
-        .arg("run")
-        .arg("--release")
-        .arg("--package")
-        .arg("wasm-bindgen-webidl")
-        .arg("webidls")
-        .arg("generated")
-        .arg("--no-features")
-        .status()?;
-
-    assert!(result.success());
-
-    Ok(())
+fn main() {
+    let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    wasm_bindgen_webidl::generate("webidls".as_ref(), &out_dir, false).unwrap();
 }

crates/webidl-tests/main.rs

@@ -15,7 +15,10 @@ fn keep() {
     noop();
 }
 
-mod generated;
+#[allow(unused_imports, non_snake_case)]
+mod generated {
+    include!(concat!(env!("OUT_DIR"), "/mod.rs"));
+}
 
 pub mod array;
 pub mod array_buffer;

crates/webidl/src/generator.rs

@@ -61,13 +61,11 @@ fn maybe_unstable_docs(unstable: bool) -> Option<proc_macro2::TokenStream> {
 }
 
 fn generate_arguments(arguments: &[(Ident, Type)], variadic: bool) -> Vec<TokenStream> {
-    let last = arguments.len() - 1;
-
     arguments
         .into_iter()
         .enumerate()
         .map(|(i, (name, ty))| {
-            if variadic && i == last {
+            if variadic && i + 1 == arguments.len() {
                 quote!( #name: &::js_sys::Array )
             } else {
                 quote!( #name: #ty )

crates/webidl/src/lib.rs

@@ -28,11 +28,17 @@ use crate::util::{
     camel_case_ident, is_structural, shouty_snake_case_ident, snake_case_ident, throws,
     webidl_const_v_to_backend_const_v, TypePosition,
 };
+use anyhow::Context;
 use anyhow::Result;
 use proc_macro2::{Ident, TokenStream};
 use quote::ToTokens;
+use sourcefile::SourceFile;
 use std::collections::{BTreeMap, BTreeSet};
+use std::ffi::OsStr;
 use std::fmt;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
 use wasm_bindgen_backend::util::rust_ident;
 use weedle::attribute::ExtendedAttributeList;
 use weedle::dictionary::DictionaryMember;
@@ -678,3 +684,127 @@ impl<'src> FirstPassRecord<'src> {
         .to_tokens(&mut program.tokens);
     }
 }
+
+/// Generates Rust source code with #[wasm_bindgen] annotations.
+///
+/// * Reads WebIDL files in `from`
+/// * Generates Rust source code in the directory `to`
+/// * `generate_features` indicates whether everything is gated by features or
+///   not
+///
+/// If features are enabled, returns a string that should be appended to
+/// `Cargo.toml` which lists all the known features.
+pub fn generate(from: &Path, to: &Path, generate_features: bool) -> Result<String> {
+    let source = read_source_from_path(&from.join("enabled"))?;
+    let unstable_source = read_source_from_path(&from.join("unstable"))?;
+
+    let features = parse_webidl(generate_features, source, unstable_source)?;
+
+    if to.exists() {
+        fs::remove_dir_all(&to).context("Removing features directory")?;
+    }
+
+    fs::create_dir_all(&to).context("Creating features directory")?;
+
+    for (name, feature) in features.iter() {
+        let out_file_path = to.join(format!("gen_{}.rs", name));
+
+        fs::write(&out_file_path, &feature.code)?;
+
+        rustfmt(&out_file_path, name)?;
+    }
+
+    let binding_file = features.keys().map(|name| {
+        if generate_features {
+            format!("#[cfg(feature = \"{name}\")] mod gen_{name};\n#[cfg(feature = \"{name}\")] pub use gen_{name}::*;", name = name)
+        } else {
+            format!("mod gen_{name};\npub use gen_{name}::*;", name = name)
+        }
+    }).collect::<Vec<_>>().join("\n\n");
+
+    fs::write(to.join("mod.rs"), binding_file)?;
+
+    rustfmt(&to.join("mod.rs"), "mod")?;
+
+    return if generate_features {
+        let features = features
+            .iter()
+            .map(|(name, feature)| {
+                let features = feature
+                    .required_features
+                    .iter()
+                    .map(|x| format!("\"{}\"", x))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("{} = [{}]", name, features)
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+        Ok(features)
+    } else {
+        Ok(String::new())
+    };
+
+    /// Read all WebIDL files in a directory into a single `SourceFile`
+    fn read_source_from_path(dir: &Path) -> Result<SourceFile> {
+        let entries = fs::read_dir(dir).context("reading webidls directory")?;
+        let mut source = SourceFile::default();
+        for entry in entries {
+            let entry = entry.context(format!("getting {}/*.webidl entry", dir.display()))?;
+            let path = entry.path();
+            if path.extension() != Some(OsStr::new("webidl")) {
+                continue;
+            }
+            source = source
+                .add_file(&path)
+                .with_context(|| format!("reading contents of file \"{}\"", path.display()))?;
+        }
+
+        Ok(source)
+    }
+
+    fn rustfmt(path: &PathBuf, name: &str) -> Result<()> {
+        // run rustfmt on the generated file - really handy for debugging
+        let result = Command::new("rustfmt")
+            .arg("--edition")
+            .arg("2018")
+            .arg(&path)
+            .status()
+            .context(format!("rustfmt on file {}", name))?;
+
+        assert!(result.success(), "rustfmt on file {}", name);
+
+        Ok(())
+    }
+
+    fn parse_webidl(
+        generate_features: bool,
+        enabled: SourceFile,
+        unstable: SourceFile,
+    ) -> Result<BTreeMap<String, Feature>> {
+        let options = Options {
+            features: generate_features,
+        };
+
+        match compile(&enabled.contents, &unstable.contents, options) {
+            Ok(features) => Ok(features),
+            Err(e) => {
+                if let Some(err) = e.downcast_ref::<WebIDLParseError>() {
+                    if let Some(pos) = enabled.resolve_offset(err.0) {
+                        let ctx = format!(
+                            "compiling WebIDL into wasm-bindgen bindings in file \
+                             \"{}\", line {} column {}",
+                            pos.filename,
+                            pos.line + 1,
+                            pos.col + 1
+                        );
+                        return Err(e.context(ctx));
+                    } else {
+                        return Err(e.context("compiling WebIDL into wasm-bindgen bindings"));
+                    }
+                }
+                return Err(e.context("compiling WebIDL into wasm-bindgen bindings"));
+            }
+        }
+    }
+}

crates/webidl/src/main.rs

@@ -24,131 +24,14 @@ struct Opt {
     no_features: bool,
 }
 
-/// Read all WebIDL files in a directory into a single `SourceFile`
-fn read_source_from_path(dir: &Path) -> Result<SourceFile> {
-    let entries = fs::read_dir(dir).context("reading webidls directory")?;
-    let mut source = SourceFile::default();
-    for entry in entries {
-        let entry = entry.context(format!("getting {}/*.webidl entry", dir.display()))?;
-        let path = entry.path();
-        if path.extension() != Some(OsStr::new("webidl")) {
-            continue;
-        }
-        source = source
-            .add_file(&path)
-            .with_context(|| format!("reading contents of file \"{}\"", path.display()))?;
-    }
-
-    Ok(source)
-}
-
-fn rustfmt(path: &PathBuf, name: &str) -> Result<()> {
-    // run rustfmt on the generated file - really handy for debugging
-    let result = Command::new("rustfmt")
-        .arg("--edition")
-        .arg("2018")
-        .arg(&path)
-        .status()
-        .context(format!("rustfmt on file {}", name))?;
-
-    assert!(result.success(), "rustfmt on file {}", name);
-
-    Ok(())
-}
-
-fn parse_webidl(
-    opt: &Opt,
-    enabled: SourceFile,
-    unstable: SourceFile,
-) -> Result<BTreeMap<String, Feature>> {
-    let options = wasm_bindgen_webidl::Options {
-        features: !opt.no_features,
-    };
-
-    match wasm_bindgen_webidl::compile(&enabled.contents, &unstable.contents, options) {
-        Ok(features) => Ok(features),
-        Err(e) => {
-            if let Some(err) = e.downcast_ref::<wasm_bindgen_webidl::WebIDLParseError>() {
-                if let Some(pos) = enabled.resolve_offset(err.0) {
-                    let ctx = format!(
-                        "compiling WebIDL into wasm-bindgen bindings in file \
-                         \"{}\", line {} column {}",
-                        pos.filename,
-                        pos.line + 1,
-                        pos.col + 1
-                    );
-                    return Err(e.context(ctx));
-                } else {
-                    return Err(e.context("compiling WebIDL into wasm-bindgen bindings"));
-                }
-            }
-            return Err(e.context("compiling WebIDL into wasm-bindgen bindings"));
-        }
-    }
-}
-
 fn main() -> Result<()> {
     env_logger::init();
 
     let opt = Opt::from_args();
-
-    let from = &opt.input_dir;
-    let to = &opt.output_dir;
-
-    let source = read_source_from_path(&from.join("enabled"))?;
-    let unstable_source = read_source_from_path(&from.join("unstable"))?;
-
-    let features = parse_webidl(&opt, source, unstable_source)?;
-
-    if to.exists() {
-        fs::remove_dir_all(&to).context("Removing features directory")?;
-    }
-
-    fs::create_dir_all(&to).context("Creating features directory")?;
-
-    for (name, feature) in features.iter() {
-        let out_file_path = to.join(format!("gen_{}.rs", name));
-
-        fs::write(&out_file_path, &feature.code)?;
-
-        rustfmt(&out_file_path, name)?;
-    }
-
-    let binding_file = features.keys().map(|name| {
-        if opt.no_features {
-            format!("mod gen_{name};\npub use gen_{name}::*;", name = name)
-        } else {
-            format!("#[cfg(feature = \"{name}\")] mod gen_{name};\n#[cfg(feature = \"{name}\")] pub use gen_{name}::*;", name = name)
-        }
-    }).collect::<Vec<_>>().join("\n\n");
-
-    fs::write(
-        to.join("mod.rs"),
-        format!(
-            "#![allow(non_snake_case, unused_imports)]\n\n{}",
-            binding_file
-        ),
-    )?;
-
-    rustfmt(&to.join("mod.rs"), "mod")?;
-
+    let features =
+        wasm_bindgen_webidl::generate(&opt.input_dir, &opt.output_dir, !opt.no_features)?;
     if !opt.no_features {
-        let features = features
-            .iter()
-            .map(|(name, feature)| {
-                let features = feature
-                    .required_features
-                    .iter()
-                    .map(|x| format!("\"{}\"", x))
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                format!("{} = [{}]", name, features)
-            })
-            .collect::<Vec<_>>()
-            .join("\n");
-
         fs::write(&"features", features).context("writing features to current directory")?;
     }
-
     Ok(())
 }