Create the web-sys crate mechanically from WebIDL

.eslintrc

@@ -18,7 +18,8 @@
         ],
     "quotes": [
         "error",
-        "single"
+        "single",
+        { "allowTemplateLiterals": true }
     ],
     "semi": [
         "error",

.travis.yml

@@ -60,6 +60,16 @@ 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: cargo test --manifest-path crates/web-sys/Cargo.toml
+      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

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

crates/cli-support/src/js/mod.rs

@@ -284,6 +284,40 @@ impl<'a> Context<'a> {
             ))
         })?;
 
+        self.bind("__wbindgen_is_object", &|me| {
+            me.expose_get_object();
+            Ok(String::from(
+                "
+                function(i) {
+                    const val = getObject(i);
+                    return typeof(val) === 'object' && val !== null ? 1 : 0;
+                }
+                ",
+            ))
+        })?;
+
+        self.bind("__wbindgen_is_function", &|me| {
+            me.expose_get_object();
+            Ok(String::from(
+                "
+                function(i) {
+                    return typeof(getObject(i)) === 'function' ? 1 : 0;
+                }
+                ",
+            ))
+        })?;
+
+        self.bind("__wbindgen_is_string", &|me| {
+            me.expose_get_object();
+            Ok(String::from(
+                "
+                function(i) {
+                    return typeof(getObject(i)) === 'string' ? 1 : 0;
+                }
+                ",
+            ))
+        })?;
+
         self.bind("__wbindgen_string_get", &|me| {
             me.expose_pass_string_to_wasm()?;
             me.expose_get_object();
@@ -1501,7 +1535,7 @@ impl<'a> Context<'a> {
                 if (desc) return desc;
                 obj = Object.getPrototypeOf(obj);
               }
-              throw new Error('descriptor not found');
+              throw new Error(`descriptor for id='${id}' not found`);
             }
             ",
         );
@@ -1866,11 +1900,24 @@ impl<'a, 'b> SubContext<'a, 'b> {
                             }
                         };
 
+                        let fallback = if import.structural {
+                            "".to_string()
+                        } else {
+                            format!(
+                                " || function() {{
+                                    throw new Error(`wasm-bindgen: {} does not exist`);
+                                }}",
+                                target
+                            )
+                        };
+
                         self.cx.global(&format!(
                             "
-                            const {}_target = {};
+                            const {}_target = {} {} ;
                             ",
-                            import.shim, target
+                            import.shim,
+                            target,
+                            fallback
                         ));
                         format!(
                             "{}_target{}",