Create the web-sys crate mechanically from WebIDL

.travis.yml

@@ -58,6 +58,17 @@ matrix:
              ./build.sh) || exit 1;
           done
 
+    # The `web-sys` crate's tests pass on nightly.
+    - rust: nightly
+      env: JOB=test-web-sys
+      before_install: *INSTALL_NODE_VIA_NVM
+      install:
+        - npm install
+      script:
+        - (cd crates/web-sys && cargo test)
+      addons:
+        firefox: latest
+
     # Tests pass on nightly using yarn
     - rust: nightly
       env: JOB=test-yarn-smoke

Cargo.toml

@@ -40,6 +40,7 @@ members = [
   "crates/cli",
   "crates/typescript",
   "crates/webidl",
+  "crates/web-sys",
   "examples/hello_world",
   "examples/smorgasboard",
   "examples/console_log",

crates/backend/src/defined.rs

@@ -0,0 +1,256 @@
+use ast;
+use proc_macro2::Ident;
+use syn;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ImportedTypeKind {
+    /// The definition of an imported type.
+    Definition,
+    /// A reference to an imported type.
+    Reference,
+}
+
+/// Iterate over definitions of and references to imported types in the AST.
+pub trait ImportedTypes {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind);
+}
+
+/// Iterate over definitions of imported types in the AST.
+pub trait ImportedTypeDefinitions {
+    fn imported_type_definitions<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident);
+}
+
+impl<T> ImportedTypeDefinitions for T
+where
+    T: ImportedTypes,
+{
+    fn imported_type_definitions<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident),
+    {
+        self.imported_types(&mut |id, kind| {
+            if let ImportedTypeKind::Definition = kind {
+                f(id);
+            }
+        });
+    }
+}
+
+/// Iterate over references to imported types in the AST.
+pub trait ImportedTypeReferences {
+    fn imported_type_references<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident);
+}
+
+impl<T> ImportedTypeReferences for T
+where
+    T: ImportedTypes,
+{
+    fn imported_type_references<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident),
+    {
+        self.imported_types(&mut |id, kind| {
+            if let ImportedTypeKind::Reference = kind {
+                f(id);
+            }
+        });
+    }
+}
+
+impl ImportedTypes for ast::Program {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        self.imports.imported_types(f);
+        self.type_aliases.imported_types(f);
+    }
+}
+
+impl<T> ImportedTypes for Vec<T>
+where
+    T: ImportedTypes,
+{
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        for x in self {
+            x.imported_types(f);
+        }
+    }
+}
+
+impl ImportedTypes for ast::Import {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        self.kind.imported_types(f)
+    }
+}
+
+impl ImportedTypes for ast::ImportKind {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        match self {
+            ast::ImportKind::Static(s) => s.imported_types(f),
+            ast::ImportKind::Function(fun) => fun.imported_types(f),
+            ast::ImportKind::Type(ty) => ty.imported_types(f),
+        }
+    }
+}
+
+impl ImportedTypes for ast::ImportStatic {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        self.ty.imported_types(f);
+    }
+}
+
+impl ImportedTypes for syn::Type {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        match self {
+            syn::Type::Reference(ref r) => r.imported_types(f),
+            syn::Type::Path(ref p) => p.imported_types(f),
+            _ => {}
+        }
+    }
+}
+
+impl ImportedTypes for syn::TypeReference {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        self.elem.imported_types(f);
+    }
+}
+
+impl ImportedTypes for syn::TypePath {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        if self.qself.is_some()
+            || self.path.leading_colon.is_some()
+            || self.path.segments.len() != 1
+        {
+            return;
+        }
+        f(
+            &self.path.segments.last().unwrap().value().ident,
+            ImportedTypeKind::Reference,
+        );
+    }
+}
+
+impl ImportedTypes for ast::ImportFunction {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        self.function.imported_types(f);
+        self.kind.imported_types(f);
+    }
+}
+
+impl ImportedTypes for ast::ImportFunctionKind {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        match self {
+            ast::ImportFunctionKind::Method { ty, .. } => ty.imported_types(f),
+            ast::ImportFunctionKind::Normal => {}
+        }
+    }
+}
+
+impl ImportedTypes for ast::Function {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        self.arguments.imported_types(f);
+        if let Some(ref r) = self.ret {
+            r.imported_types(f);
+        }
+    }
+}
+
+impl ImportedTypes for syn::ArgCaptured {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        self.ty.imported_types(f);
+    }
+}
+
+impl ImportedTypes for ast::ImportType {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        f(&self.name, ImportedTypeKind::Definition);
+    }
+}
+
+impl ImportedTypes for ast::TypeAlias {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        f(&self.dest, ImportedTypeKind::Reference);
+    }
+}
+
+/// Remove any methods, statics, &c, that reference types that are *not*
+/// defined.
+pub trait RemoveUndefinedImports {
+    fn remove_undefined_imports<F>(&mut self, is_defined: &F)
+    where
+        F: Fn(&Ident) -> bool;
+}
+
+impl RemoveUndefinedImports for ast::Program {
+    fn remove_undefined_imports<F>(&mut self, is_defined: &F)
+    where
+        F: Fn(&Ident) -> bool,
+    {
+        self.imports.remove_undefined_imports(is_defined);
+        self.type_aliases.remove_undefined_imports(is_defined);
+    }
+}
+
+impl<T> RemoveUndefinedImports for Vec<T>
+where
+    T: ImportedTypeReferences,
+{
+    fn remove_undefined_imports<F>(&mut self, is_defined: &F)
+    where
+        F: Fn(&Ident) -> bool,
+    {
+        self.retain(|x| {
+            let mut all_defined = true;
+            x.imported_type_references(&mut |id| {
+                all_defined = all_defined && is_defined(id);
+            });
+            all_defined
+        });
+    }
+}

crates/backend/src/lib.rs

@@ -12,4 +12,5 @@ extern crate wasm_bindgen_shared as shared;
 
 pub mod ast;
 mod codegen;
+pub mod defined;
 pub mod util;

crates/test-project-builder/src/lib.rs

@@ -560,6 +560,7 @@ impl Project {
         let (root, target_dir) = self.build();
         let mut cmd = Command::new("cargo");
         cmd.arg("build")
+            .arg("-vv")
             .arg("--target")
             .arg("wasm32-unknown-unknown")
             .current_dir(&root)
@@ -677,7 +678,10 @@ impl Project {
         lazy_static! {
             static ref MUTEX: Mutex<()> = Mutex::new(());
         }
-        let _lock = MUTEX.lock().unwrap();
+        let _lock = {
+            let _x = wrap_step("waiting on headless test lock");
+            MUTEX.lock().unwrap()
+        };
 
         let mut cmd = self.npm();
         cmd.arg("run")
@@ -686,20 +690,29 @@ impl Project {
             .arg("--quiet")
             .arg("--watch-stdin")
             .current_dir(&root);
-        let _server = run_in_background(&mut cmd, "webpack-dev-server".into());
+        let mut server = run_in_background(&mut cmd, "webpack-dev-server".into());
 
         // wait for webpack-dev-server to come online and bind its port
-        loop {
-            if TcpStream::connect("127.0.0.1:8080").is_ok() {
-                break;
+        {
+            let _x = wrap_step("waiting for webpack-dev-server");
+
+            loop {
+                if TcpStream::connect("127.0.0.1:8080").is_ok() {
+                    break;
+                }
+                if server.exited() {
+                    panic!("webpack-dev-server exited during headless test initialization")
+                }
+                thread::sleep(Duration::from_millis(100));
             }
-            thread::sleep(Duration::from_millis(100));
         }
 
         let path = env::var_os("PATH").unwrap_or_default();
         let mut path = env::split_paths(&path).collect::<Vec<_>>();
         path.push(root.join("node_modules/geckodriver"));
 
+        let _x = wrap_step("running headless test");
+
         let mut cmd = Command::new("node");
         cmd.args(&self.node_args)
             .arg(root.join("run-headless.js"))
@@ -775,6 +788,12 @@ struct BackgroundChild {
     stderr: Option<thread::JoinHandle<io::Result<String>>>,
 }
 
+impl BackgroundChild {
+    pub fn exited(&mut self) -> bool {
+        self.child.try_wait().expect("should try_wait OK").is_some()
+    }
+}
+
 impl Drop for BackgroundChild {
     fn drop(&mut self) {
         drop(self.stdin.take());

crates/web-sys/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "web-sys"
+version = "0.1.0"
+authors = ["Nick Fitzgerald <fitzgen@gmail.com>"]
+readme = "./README.md"
+
+[build-dependencies]
+env_logger = "0.5.10"
+failure = "0.1"
+wasm-bindgen-webidl = { path = "../webidl", version = "=0.2.11" }
+
+[dependencies]
+wasm-bindgen = { path = "../..", version = "=0.2.11" }
+
+[dev-dependencies]
+wasm-bindgen-test-project-builder = { path = "../test-project-builder", version = '=0.2.11' }

crates/web-sys/README.md

@@ -0,0 +1,3 @@
+# `web-sys`
+
+Raw bindings to Web APIs for projects using `wasm-bindgen`.