Merge pull request #460 from ohanar/webidl_partial_mixins

webidl: add support for partial interfaces and mixins

crates/backend/src/ast.rs

@@ -10,6 +10,7 @@ pub struct Program {
     pub enums: Vec<Enum>,
     pub structs: Vec<Struct>,
     pub type_aliases: Vec<TypeAlias>,
+    pub consts: Vec<Const>,
 }
 
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
@@ -42,7 +43,6 @@ pub enum ImportKind {
     Static(ImportStatic),
     Type(ImportType),
     Enum(ImportEnum),
-    Const(Const),
 }
 
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
@@ -179,7 +179,7 @@ pub struct TypeAlias {
 pub struct Const {
     pub vis: syn::Visibility,
     pub name: Ident,
-    pub interface_name: Ident,
+    pub class: Option<Ident>,
     pub ty: syn::Type,
     pub value: ConstValue,
 }
@@ -312,7 +312,6 @@ impl ImportKind {
             ImportKind::Static(_) => false,
             ImportKind::Type(_) => false,
             ImportKind::Enum(_) => false,
-            ImportKind::Const(_) => false,
         }
     }
 
@@ -322,7 +321,6 @@ impl ImportKind {
             ImportKind::Static(ref f) => shared::ImportKind::Static(f.shared()),
             ImportKind::Type(ref f) => shared::ImportKind::Type(f.shared()),
             ImportKind::Enum(ref f) => shared::ImportKind::Enum(f.shared()),
-            ImportKind::Const(ref f) => shared::ImportKind::Const(f.shared()),
         }
     }
 }
@@ -425,9 +423,3 @@ impl StructField {
         }
     }
 }
-
-impl Const {
-    fn shared(&self) -> shared::Const {
-        shared::Const {}
-    }
-}

crates/backend/src/codegen.rs

@@ -62,6 +62,9 @@ impl ToTokens for ast::Program {
         for a in self.type_aliases.iter() {
             a.to_tokens(tokens);
         }
+        for c in self.consts.iter() {
+            c.to_tokens(tokens);
+        }
 
         // Generate a static which will eventually be what lives in a custom section
         // of the wasm executable. For now it's just a plain old static, but we'll
@@ -502,7 +505,6 @@ impl ToTokens for ast::ImportKind {
             ast::ImportKind::Static(ref s) => s.to_tokens(tokens),
             ast::ImportKind::Type(ref t) => t.to_tokens(tokens),
             ast::ImportKind::Enum(ref e) => e.to_tokens(tokens),
-            ast::ImportKind::Const(ref c) => c.to_tokens(tokens),
         }
     }
 }
@@ -845,7 +847,6 @@ impl<'a> ToTokens for DescribeImport<'a> {
             ast::ImportKind::Static(_) => return,
             ast::ImportKind::Type(_) => return,
             ast::ImportKind::Enum(_) => return,
-            ast::ImportKind::Const(_) => return,
         };
         let describe_name = format!("__wbindgen_describe_{}", f.shim);
         let describe_name = Ident::new(&describe_name, Span::call_site());
@@ -969,7 +970,6 @@ impl ToTokens for ast::Const {
 
         let vis = &self.vis;
         let name = &self.name;
-        let interface_name = &self.interface_name;
         let ty = &self.ty;
 
         let value: TokenStream = match self.value {
@@ -986,17 +986,24 @@ impl ToTokens for ast::Const {
             FloatLiteral(f) => {
                 let f = Literal::f64_unsuffixed(f);
                 quote!(#f)
-            },
+            }
             IntegerLiteral(i) => {
                 let i = Literal::i64_unsuffixed(i);
                 quote!(#i)
-            },
+            }
             Null => unimplemented!(),
         };
-        (quote! {
+
-            impl #interface_name {
+        let declaration = quote!(#vis const #name: #ty = #value;);
-                #vis const #name: #ty = #value;
+
-            }
+        if let Some(class) = &self.class {
-        }).to_tokens(tokens);
+            (quote! {
+                impl #class {
+                    #declaration
+                }
+            }).to_tokens(tokens);
+        } else {
+            declaration.to_tokens(tokens);
+        }
     }
 }

crates/backend/src/defined.rs

@@ -70,6 +70,7 @@ impl ImportedTypes for ast::Program {
     {
         self.imports.imported_types(f);
         self.type_aliases.imported_types(f);
+        self.consts.imported_types(f);
     }
 }
 
@@ -106,7 +107,6 @@ impl ImportedTypes for ast::ImportKind {
             ast::ImportKind::Function(fun) => fun.imported_types(f),
             ast::ImportKind::Type(ty) => ty.imported_types(f),
             ast::ImportKind::Enum(enm) => enm.imported_types(f),
-            ast::ImportKind::Const(c) => c.imported_types(f),
         }
     }
 }
@@ -254,6 +254,7 @@ impl RemoveUndefinedImports for ast::Program {
     {
         self.imports.remove_undefined_imports(is_defined);
         self.type_aliases.remove_undefined_imports(is_defined);
+        self.consts.remove_undefined_imports(is_defined);
     }
 }
 

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

@@ -1758,7 +1758,6 @@ impl<'a, 'b> SubContext<'a, 'b> {
             }
             shared::ImportKind::Type(_) => {}
             shared::ImportKind::Enum(_) => {}
-            shared::ImportKind::Const(_) => {}
         }
         Ok(())
     }
@@ -1918,9 +1917,7 @@ impl<'a, 'b> SubContext<'a, 'b> {
                             "
                             const {}_target = {} {} ;
                             ",
-                            import.shim,
+                            import.shim, target, fallback
-                            target,
-                            fallback
                         ));
                         format!(
                             "{}_target{}",
@@ -2020,9 +2017,7 @@ fn format_doc_comments(comments: &Vec<String>, js_doc_comments: Option<String>)
         .map(|c| format!("*{}\n", c.trim_matches('"')))
         .collect();
     let doc = if let Some(docs) = js_doc_comments {
-        docs.lines()
+        docs.lines().map(|l| format!("* {} \n", l)).collect()
-            .map(|l| format!("* {} \n", l))
-            .collect()
     } else {
         String::new()
     };

crates/shared/src/lib.rs

@@ -34,7 +34,6 @@ pub enum ImportKind {
     Static(ImportStatic),
     Type(ImportType),
     Enum(ImportEnum),
-    Const(Const)
 }
 
 #[derive(Deserialize, Serialize)]
@@ -125,9 +124,6 @@ pub struct StructField {
     pub comments: Vec<String>,
 }
 
-#[derive(Deserialize, Serialize)]
-pub struct Const {}
-
 pub fn new_function(struct_name: &str) -> String {
     let mut name = format!("__wbg_");
     name.extend(struct_name.chars().flat_map(|s| s.to_lowercase()));

crates/webidl/src/first_pass.rs

@@ -0,0 +1,150 @@
+use std::{
+    collections::{BTreeMap, BTreeSet}, mem,
+};
+
+use webidl;
+
+use super::Result;
+
+#[derive(Default)]
+pub(crate) struct FirstPassRecord<'a> {
+    pub(crate) interfaces: BTreeSet<String>,
+    pub(crate) dictionaries: BTreeSet<String>,
+    pub(crate) enums: BTreeSet<String>,
+    pub(crate) mixins: BTreeMap<String, MixinData<'a>>,
+}
+
+#[derive(Default)]
+pub(crate) struct MixinData<'a> {
+    pub(crate) non_partial: Option<&'a webidl::ast::NonPartialMixin>,
+    pub(crate) partials: Vec<&'a webidl::ast::PartialMixin>,
+}
+
+pub(crate) trait FirstPass {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()>;
+}
+
+impl FirstPass for [webidl::ast::Definition] {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        for def in self {
+            def.first_pass(record)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl FirstPass for webidl::ast::Definition {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        use webidl::ast::Definition::*;
+
+        match self {
+            Dictionary(dictionary) => dictionary.first_pass(record),
+            Enum(enum_) => enum_.first_pass(record),
+            Interface(interface) => interface.first_pass(record),
+            Mixin(mixin) => mixin.first_pass(record),
+            _ => {
+                // Other definitions aren't currently used in the first pass
+                Ok(())
+            }
+        }
+    }
+}
+
+impl FirstPass for webidl::ast::Dictionary {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        use webidl::ast::Dictionary::*;
+
+        match self {
+            NonPartial(dictionary) => dictionary.first_pass(record),
+            _ => {
+                // Other dictionaries aren't currently used in the first pass
+                Ok(())
+            }
+        }
+    }
+}
+
+impl FirstPass for webidl::ast::NonPartialDictionary {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        if record.dictionaries.insert(self.name.clone()) {
+            warn!("Encountered multiple declarations of {}", self.name);
+        }
+
+        Ok(())
+    }
+}
+
+impl FirstPass for webidl::ast::Enum {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        if record.enums.insert(self.name.clone()) {
+            warn!("Encountered multiple declarations of {}", self.name);
+        }
+
+        Ok(())
+    }
+}
+
+impl FirstPass for webidl::ast::Interface {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        use webidl::ast::Interface::*;
+
+        match self {
+            NonPartial(interface) => interface.first_pass(record),
+            _ => {
+                // Other interfaces aren't currently used in the first pass
+                Ok(())
+            }
+        }
+    }
+}
+
+impl FirstPass for webidl::ast::NonPartialInterface {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        if record.interfaces.insert(self.name.clone()) {
+            warn!("Encountered multiple declarations of {}", self.name);
+        }
+
+        Ok(())
+    }
+}
+
+impl FirstPass for webidl::ast::Mixin {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        use webidl::ast::Mixin::*;
+
+        match self {
+            NonPartial(mixin) => mixin.first_pass(record),
+            Partial(mixin) => mixin.first_pass(record),
+        }
+    }
+}
+
+impl FirstPass for webidl::ast::NonPartialMixin {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        let entry = record
+            .mixins
+            .entry(self.name.clone())
+            .or_insert(Default::default());
+        if mem::replace(&mut entry.non_partial, Some(self)).is_some() {
+            warn!(
+                "Encounterd multiple declarations of {}, using last encountered",
+                self.name
+            );
+        }
+
+        Ok(())
+    }
+}
+
+impl FirstPass for webidl::ast::PartialMixin {
+    fn first_pass<'a>(&'a self, record: &mut FirstPassRecord<'a>) -> Result<()> {
+        let entry = record
+            .mixins
+            .entry(self.name.clone())
+            .or_insert(Default::default());
+        entry.partials.push(self);
+
+        Ok(())
+    }
+}

crates/webidl/src/lib.rs

@@ -18,6 +18,7 @@ extern crate syn;
 extern crate wasm_bindgen_backend as backend;
 extern crate webidl;
 
+mod first_pass;
 mod util;
 
 use std::collections::BTreeSet;
@@ -32,10 +33,8 @@ use failure::ResultExt;
 use heck::{CamelCase, ShoutySnakeCase};
 use quote::ToTokens;
 
-use util::{
+use first_pass::{FirstPass, FirstPassRecord};
-    create_basic_method, create_function, create_getter, create_setter, webidl_const_ty_to_syn_ty,
+use util::{public, webidl_const_ty_to_syn_ty, webidl_const_v_to_backend_const_v, TypePosition};
-    webidl_const_v_to_backend_const_v, webidl_ty_to_syn_ty, TypePosition,
-};
 
 /// Either `Ok(t)` or `Err(failure::Error)`.
 pub type Result<T> = ::std::result::Result<T, failure::Error>;
@@ -54,8 +53,10 @@ fn parse_file(webidl_path: &Path) -> Result<backend::ast::Program> {
 fn parse(webidl_source: &str) -> Result<backend::ast::Program> {
     let definitions = webidl::parse_string(webidl_source).context("parsing WebIDL source text")?;
 
-    let mut program = backend::ast::Program::default();
+    let mut first_pass_record = Default::default();
-    definitions.webidl_parse(&mut program, ())?;
+    definitions.first_pass(&mut first_pass_record)?;
+    let mut program = Default::default();
+    definitions.webidl_parse(&mut program, &first_pass_record, ())?;
 
     Ok(program)
 }
@@ -93,48 +94,105 @@ fn compile_ast(mut ast: backend::ast::Program) -> String {
 }
 
 trait WebidlParse<Ctx> {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, context: Ctx) -> Result<()>;
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        context: Ctx,
+    ) -> Result<()>;
 }
 
-impl WebidlParse<()> for Vec<webidl::ast::Definition> {
+impl WebidlParse<()> for [webidl::ast::Definition] {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        (): (),
+    ) -> Result<()> {
         for def in self {
-            def.webidl_parse(program, ())?;
+            def.webidl_parse(program, first_pass, ())?;
         }
         Ok(())
     }
 }
 
 impl WebidlParse<()> for webidl::ast::Definition {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
+    fn webidl_parse(
-        match *self {
+        &self,
-            webidl::ast::Definition::Interface(ref interface) => {
+        program: &mut backend::ast::Program,
-                interface.webidl_parse(program, ())
+        first_pass: &FirstPassRecord<'_>,
+        (): (),
+    ) -> Result<()> {
+        match self {
+            webidl::ast::Definition::Enum(enumeration) => {
+                enumeration.webidl_parse(program, first_pass, ())?
+            }
+            webidl::ast::Definition::Includes(includes) => {
+                includes.webidl_parse(program, first_pass, ())?
+            }
+            webidl::ast::Definition::Interface(interface) => {
+                interface.webidl_parse(program, first_pass, ())?
+            }
+            webidl::ast::Definition::Typedef(typedef) => {
+                typedef.webidl_parse(program, first_pass, ())?
             }
-            webidl::ast::Definition::Typedef(ref typedef) => typedef.webidl_parse(program, ()),
-            webidl::ast::Definition::Enum(ref enumeration) => enumeration.webidl_parse(program, ()),
             // TODO
             webidl::ast::Definition::Callback(..)
             | webidl::ast::Definition::Dictionary(..)
             | webidl::ast::Definition::Implements(..)
-            | webidl::ast::Definition::Includes(..)
-            | webidl::ast::Definition::Mixin(..)
             | webidl::ast::Definition::Namespace(..) => {
-                warn!("Unsupported WebIDL definition: {:?}", self);
+                warn!("Unsupported WebIDL definition: {:?}", self)
-                Ok(())
+            }
+            webidl::ast::Definition::Mixin(_) => {
+                // handled in the first pass
             }
         }
+        Ok(())
+    }
+}
+
+impl WebidlParse<()> for webidl::ast::Includes {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        (): (),
+    ) -> Result<()> {
+        match first_pass.mixins.get(&self.includee) {
+            Some(mixin) => {
+                if let Some(non_partial) = mixin.non_partial {
+                    for member in &non_partial.members {
+                        member.webidl_parse(program, first_pass, &self.includer)?;
+                    }
+                }
+                for partial in &mixin.partials {
+                    for member in &partial.members {
+                        member.webidl_parse(program, first_pass, &self.includer)?;
+                    }
+                }
+            }
+            None => warn!("Tried to include missing mixin {}", self.includee),
+        }
+        Ok(())
     }
 }
 
 impl WebidlParse<()> for webidl::ast::Interface {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
+    fn webidl_parse(
-        match *self {
+        &self,
-            webidl::ast::Interface::NonPartial(ref interface) => {
+        program: &mut backend::ast::Program,
-                interface.webidl_parse(program, ())
+        first_pass: &FirstPassRecord<'_>,
+        (): (),
+    ) -> Result<()> {
+        match self {
+            webidl::ast::Interface::NonPartial(interface) => {
+                interface.webidl_parse(program, first_pass, ())
+            }
+            webidl::ast::Interface::Partial(interface) => {
+                interface.webidl_parse(program, first_pass, ())
             }
             // TODO
-            webidl::ast::Interface::Callback(..) | webidl::ast::Interface::Partial(..) => {
+            webidl::ast::Interface::Callback(..) => {
                 warn!("Unsupported WebIDL interface: {:?}", self);
                 Ok(())
             }
@@ -143,13 +201,18 @@ impl WebidlParse<()> for webidl::ast::Interface {
 }
 
 impl WebidlParse<()> for webidl::ast::Typedef {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        (): (),
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
 
-        let dest = rust_ident(&self.name);
+        let dest = rust_ident(self.name.to_camel_case().as_str());
-        let src = match webidl_ty_to_syn_ty(&self.type_, TypePosition::Return) {
+        let src = match first_pass.webidl_ty_to_syn_ty(&self.type_, TypePosition::Return) {
             Some(src) => src,
             None => {
                 warn!(
@@ -161,9 +224,7 @@ impl WebidlParse<()> for webidl::ast::Typedef {
         };
 
         program.type_aliases.push(backend::ast::TypeAlias {
-            vis: syn::Visibility::Public(syn::VisPublic {
+            vis: public(),
-                pub_token: Default::default(),
-            }),
             dest,
             src,
         });
@@ -173,7 +234,12 @@ impl WebidlParse<()> for webidl::ast::Typedef {
 }
 
 impl WebidlParse<()> for webidl::ast::NonPartialInterface {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        (): (),
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
@@ -183,20 +249,44 @@ impl WebidlParse<()> for webidl::ast::NonPartialInterface {
             version: None,
             js_namespace: None,
             kind: backend::ast::ImportKind::Type(backend::ast::ImportType {
-                vis: syn::Visibility::Public(syn::VisPublic {
+                vis: public(),
-                    pub_token: Default::default(),
+                name: rust_ident(self.name.to_camel_case().as_str()),
-                }),
-                name: rust_ident(&self.name),
                 attrs: Vec::new(),
             }),
         });
 
         for extended_attribute in &self.extended_attributes {
-            extended_attribute.webidl_parse(program, self)?;
+            extended_attribute.webidl_parse(program, first_pass, self)?;
         }
 
         for member in &self.members {
-            member.webidl_parse(program, &self.name)?;
+            member.webidl_parse(program, first_pass, &self.name)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl WebidlParse<()> for webidl::ast::PartialInterface {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        (): (),
+    ) -> Result<()> {
+        if util::is_chrome_only(&self.extended_attributes) {
+            return Ok(());
+        }
+
+        if !first_pass.interfaces.contains(&self.name) {
+            warn!(
+                "Partial interface {} missing non-partial interface",
+                self.name
+            );
+        }
+
+        for member in &self.members {
+            member.webidl_parse(program, first_pass, &self.name)?;
         }
 
         Ok(())
@@ -207,10 +297,11 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
     fn webidl_parse(
         &self,
         program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
         interface: &'a webidl::ast::NonPartialInterface,
     ) -> Result<()> {
         let mut add_constructor = |arguments: &[webidl::ast::Argument], class: &str| {
-            let self_ty = ident_ty(rust_ident(&interface.name));
+            let self_ty = ident_ty(rust_ident(interface.name.to_camel_case().as_str()));
 
             let kind = backend::ast::ImportFunctionKind::Method {
                 class: class.to_string(),
@@ -234,23 +325,19 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
             // > exception**.
             let throws = true;
 
-            create_function(
+            first_pass
-                "new",
+                .create_function(
-                arguments
+                    "new",
-                    .iter()
+                    arguments
-                    .map(|arg| (&*arg.name, &*arg.type_, arg.variadic)),
+                        .iter()
-                Some(self_ty),
+                        .map(|arg| (&*arg.name, &*arg.type_, arg.variadic)),
-                kind,
+                    Some(self_ty),
-                structural,
+                    kind,
-                throws,
+                    structural,
-            ).map(|function| {
+                    throws,
-                program.imports.push(backend::ast::Import {
+                )
-                    module: None,
+                .map(wrap_import_function)
-                    version: None,
+                .map(|import| program.imports.push(import));
-                    js_namespace: None,
-                    kind: backend::ast::ImportKind::Function(function),
-                })
-            })
         };
 
         match self {
@@ -259,12 +346,12 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
             )
                 if name == "Constructor" =>
             {
-                add_constructor(arguments, &interface.name);
+                add_constructor(arguments, &interface.name)
             }
             webidl::ast::ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name))
                 if name == "Constructor" =>
             {
-                add_constructor(&[], &interface.name);
+                add_constructor(&[], &interface.name)
             }
             webidl::ast::ExtendedAttribute::NamedArgumentList(
                 webidl::ast::NamedArgumentListExtendedAttribute {
@@ -275,7 +362,7 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
             )
                 if lhs_name == "NamedConstructor" =>
             {
-                add_constructor(rhs_arguments, rhs_name);
+                add_constructor(rhs_arguments, rhs_name)
             }
             webidl::ast::ExtendedAttribute::ArgumentList(_)
             | webidl::ast::ExtendedAttribute::Identifier(_)
@@ -291,13 +378,22 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
 }
 
 impl<'a> WebidlParse<&'a str> for webidl::ast::InterfaceMember {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
+    fn webidl_parse(
-        match *self {
+        &self,
-            webidl::ast::InterfaceMember::Attribute(ref attr) => {
+        program: &mut backend::ast::Program,
-                attr.webidl_parse(program, self_name)
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
+        match self {
+            webidl::ast::InterfaceMember::Attribute(attr) => {
+                attr.webidl_parse(program, first_pass, self_name)
+            }
+            webidl::ast::InterfaceMember::Operation(op) => {
+                op.webidl_parse(program, first_pass, self_name)
+            }
+            webidl::ast::InterfaceMember::Const(cnst) => {
+                cnst.webidl_parse(program, first_pass, self_name)
             }
-            webidl::ast::InterfaceMember::Operation(ref op) => op.webidl_parse(program, self_name),
-            webidl::ast::InterfaceMember::Const(ref c) => c.webidl_parse(program, self_name),
             // TODO
             webidl::ast::InterfaceMember::Iterable(_)
             | webidl::ast::InterfaceMember::Maplike(_)
@@ -309,11 +405,42 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::InterfaceMember {
     }
 }
 
-impl<'a> WebidlParse<&'a str> for webidl::ast::Attribute {
+impl<'a> WebidlParse<&'a str> for webidl::ast::MixinMember {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
         match self {
-            webidl::ast::Attribute::Regular(attr) => attr.webidl_parse(program, self_name),
+            webidl::ast::MixinMember::Attribute(attr) => {
-            webidl::ast::Attribute::Static(attr) => attr.webidl_parse(program, self_name),
+                attr.webidl_parse(program, first_pass, self_name)
+            }
+            webidl::ast::MixinMember::Operation(op) => {
+                op.webidl_parse(program, first_pass, self_name)
+            }
+            // TODO
+            webidl::ast::MixinMember::Const(_) => {
+                warn!("Unsupported WebIDL interface member: {:?}", self);
+                Ok(())
+            }
+        }
+    }
+}
+impl<'a> WebidlParse<&'a str> for webidl::ast::Attribute {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
+        match self {
+            webidl::ast::Attribute::Regular(attr) => {
+                attr.webidl_parse(program, first_pass, self_name)
+            }
+            webidl::ast::Attribute::Static(attr) => {
+                attr.webidl_parse(program, first_pass, self_name)
+            }
             // TODO
             webidl::ast::Attribute::Stringifier(_) => {
                 warn!("Unsupported WebIDL attribute: {:?}", self);
@@ -324,10 +451,15 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::Attribute {
 }
 
 impl<'a> WebidlParse<&'a str> for webidl::ast::Operation {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
         match self {
-            webidl::ast::Operation::Regular(op) => op.webidl_parse(program, self_name),
+            webidl::ast::Operation::Regular(op) => op.webidl_parse(program, first_pass, self_name),
-            webidl::ast::Operation::Static(op) => op.webidl_parse(program, self_name),
+            webidl::ast::Operation::Static(op) => op.webidl_parse(program, first_pass, self_name),
             // TODO
             webidl::ast::Operation::Special(_) | webidl::ast::Operation::Stringifier(_) => {
                 warn!("Unsupported WebIDL operation: {:?}", self);
@@ -338,7 +470,12 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::Operation {
 }
 
 impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
@@ -346,25 +483,29 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
         let is_structural = util::is_structural(&self.extended_attributes);
         let throws = util::throws(&self.extended_attributes);
 
-        create_getter(
+        first_pass
-            &self.name,
+            .create_getter(
-            &self.type_,
-            self_name,
-            false,
-            is_structural,
-            throws,
-        ).map(wrap_import_function)
-            .map(|import| program.imports.push(import));
-
-        if !self.read_only {
-            create_setter(
                 &self.name,
                 &self.type_,
                 self_name,
                 false,
                 is_structural,
                 throws,
-            ).map(wrap_import_function)
+            )
+            .map(wrap_import_function)
+            .map(|import| program.imports.push(import));
+
+        if !self.read_only {
+            first_pass
+                .create_setter(
+                    &self.name,
+                    &self.type_,
+                    self_name,
+                    false,
+                    is_structural,
+                    throws,
+                )
+                .map(wrap_import_function)
                 .map(|import| program.imports.push(import));
         }
 
@@ -373,7 +514,12 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
 }
 
 impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
@@ -381,25 +527,29 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
         let is_structural = util::is_structural(&self.extended_attributes);
         let throws = util::throws(&self.extended_attributes);
 
-        create_getter(
+        first_pass
-            &self.name,
+            .create_getter(
-            &self.type_,
-            self_name,
-            true,
-            is_structural,
-            throws,
-        ).map(wrap_import_function)
-            .map(|import| program.imports.push(import));
-
-        if !self.read_only {
-            create_setter(
                 &self.name,
                 &self.type_,
                 self_name,
                 true,
                 is_structural,
                 throws,
-            ).map(wrap_import_function)
+            )
+            .map(wrap_import_function)
+            .map(|import| program.imports.push(import));
+
+        if !self.read_only {
+            first_pass
+                .create_setter(
+                    &self.name,
+                    &self.type_,
+                    self_name,
+                    true,
+                    is_structural,
+                    throws,
+                )
+                .map(wrap_import_function)
                 .map(|import| program.imports.push(import));
         }
 
@@ -408,21 +558,28 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
 }
 
 impl<'a> WebidlParse<&'a str> for webidl::ast::RegularOperation {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
 
         let throws = util::throws(&self.extended_attributes);
 
-        create_basic_method(
+        first_pass
-            &self.arguments,
+            .create_basic_method(
-            self.name.as_ref(),
+                &self.arguments,
-            &self.return_type,
+                self.name.as_ref(),
-            self_name,
+                &self.return_type,
-            false,
+                self_name,
-            throws,
+                false,
-        ).map(wrap_import_function)
+                throws,
+            )
+            .map(wrap_import_function)
             .map(|import| program.imports.push(import));
 
         Ok(())
@@ -430,21 +587,28 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::RegularOperation {
 }
 
 impl<'a> WebidlParse<&'a str> for webidl::ast::StaticOperation {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, self_name: &'a str) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &FirstPassRecord<'_>,
+        self_name: &'a str,
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
 
         let throws = util::throws(&self.extended_attributes);
 
-        create_basic_method(
+        first_pass
-            &self.arguments,
+            .create_basic_method(
-            self.name.as_ref(),
+                &self.arguments,
-            &self.return_type,
+                self.name.as_ref(),
-            self_name,
+                &self.return_type,
-            true,
+                self_name,
-            throws,
+                true,
-        ).map(wrap_import_function)
+                throws,
+            )
+            .map(wrap_import_function)
             .map(|import| program.imports.push(import));
 
         Ok(())
@@ -452,15 +616,18 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::StaticOperation {
 }
 
 impl<'a> WebidlParse<()> for webidl::ast::Enum {
-    fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        _: &FirstPassRecord<'_>,
+        (): (),
+    ) -> Result<()> {
         program.imports.push(backend::ast::Import {
             module: None,
             version: None,
             js_namespace: None,
             kind: backend::ast::ImportKind::Enum(backend::ast::ImportEnum {
-                vis: syn::Visibility::Public(syn::VisPublic {
+                vis: public(),
-                    pub_token: Default::default(),
-                }),
                 name: rust_ident(self.name.to_camel_case().as_str()),
                 variants: self
                     .variants
@@ -479,23 +646,19 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::Const {
     fn webidl_parse(
         &self,
         program: &mut backend::ast::Program,
-        interface_name: &'a str,
+        _: &FirstPassRecord<'_>,
+        self_name: &'a str,
     ) -> Result<()> {
-        let syn_ty = webidl_const_ty_to_syn_ty(&self.type_);
+        let ty = webidl_const_ty_to_syn_ty(&self.type_);
-        program.imports.push(backend::ast::Import {
+
-            module: None,
+        program.consts.push(backend::ast::Const {
-            version: None,
+            vis: public(),
-            js_namespace: None,
+            name: rust_ident(self.name.to_shouty_snake_case().as_str()),
-            kind: backend::ast::ImportKind::Const(backend::ast::Const {
+            class: Some(rust_ident(self_name.to_camel_case().as_str())),
-                vis: syn::Visibility::Public(syn::VisPublic {
+            ty,
-                    pub_token: Default::default(),
+            value: webidl_const_v_to_backend_const_v(&self.value),
-                }),
-                name: rust_ident(self.name.to_shouty_snake_case().as_str()),
-                interface_name: rust_ident(interface_name),
-                ty: syn_ty,
-                value: webidl_const_v_to_backend_const_v(&self.value),
-            }),
         });
+
         Ok(())
     }
 }

crates/webidl/src/util.rs

@@ -2,12 +2,14 @@ use std::iter::{self, FromIterator};
 
 use backend;
 use backend::util::{ident_ty, leading_colon_path_ty, raw_ident, rust_ident, simple_path_ty};
-use heck::SnakeCase;
+use heck::{CamelCase, SnakeCase};
 use proc_macro2::Ident;
 use syn;
 use webidl;
 use webidl::ast::ExtendedAttribute;
 
+use first_pass::FirstPassRecord;
+
 fn shared_ref(ty: syn::Type) -> syn::Type {
     syn::TypeReference {
         and_token: Default::default(),
@@ -17,79 +19,6 @@ fn shared_ref(ty: syn::Type) -> syn::Type {
     }.into()
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum TypePosition {
-    Argument,
-    Return,
-}
-
-pub fn webidl_ty_to_syn_ty(ty: &webidl::ast::Type, pos: TypePosition) -> Option<syn::Type> {
-    // nullable types are not yet supported (see issue #14)
-    if ty.nullable {
-        return None;
-    }
-    Some(match ty.kind {
-        // `any` becomes `::wasm_bindgen::JsValue`.
-        webidl::ast::TypeKind::Any => {
-            simple_path_ty(vec![rust_ident("wasm_bindgen"), rust_ident("JsValue")])
-        }
-
-        // A reference to a type by name becomes the same thing in the
-        // bindings.
-        webidl::ast::TypeKind::Identifier(ref id) => ident_ty(rust_ident(id)),
-
-        // Scalars.
-        webidl::ast::TypeKind::Boolean => ident_ty(raw_ident("bool")),
-        webidl::ast::TypeKind::Byte => ident_ty(raw_ident("i8")),
-        webidl::ast::TypeKind::Octet => ident_ty(raw_ident("u8")),
-        webidl::ast::TypeKind::RestrictedDouble | webidl::ast::TypeKind::UnrestrictedDouble => {
-            ident_ty(raw_ident("f64"))
-        }
-        webidl::ast::TypeKind::RestrictedFloat | webidl::ast::TypeKind::UnrestrictedFloat => {
-            ident_ty(raw_ident("f32"))
-        }
-        webidl::ast::TypeKind::SignedLong => ident_ty(raw_ident("i32")),
-        webidl::ast::TypeKind::SignedLongLong => ident_ty(raw_ident("i64")),
-        webidl::ast::TypeKind::SignedShort => ident_ty(raw_ident("i16")),
-        webidl::ast::TypeKind::UnsignedLong => ident_ty(raw_ident("u32")),
-        webidl::ast::TypeKind::UnsignedLongLong => ident_ty(raw_ident("u64")),
-        webidl::ast::TypeKind::UnsignedShort => ident_ty(raw_ident("u16")),
-
-        // `DOMString -> `&str` for arguments
-        webidl::ast::TypeKind::DOMString if pos == TypePosition::Argument => {
-            shared_ref(ident_ty(raw_ident("str")))
-        }
-        // `DOMString` is not supported yet in other positions.
-        webidl::ast::TypeKind::DOMString => return None,
-
-        // Support for these types is not yet implemented, so skip
-        // generating any bindings for this function.
-        webidl::ast::TypeKind::ArrayBuffer
-        | webidl::ast::TypeKind::ByteString
-        | webidl::ast::TypeKind::DataView
-        | webidl::ast::TypeKind::Error
-        | webidl::ast::TypeKind::Float32Array
-        | webidl::ast::TypeKind::Float64Array
-        | webidl::ast::TypeKind::FrozenArray(_)
-        | webidl::ast::TypeKind::Int16Array
-        | webidl::ast::TypeKind::Int32Array
-        | webidl::ast::TypeKind::Int8Array
-        | webidl::ast::TypeKind::Object
-        | webidl::ast::TypeKind::Promise(_)
-        | webidl::ast::TypeKind::Record(..)
-        | webidl::ast::TypeKind::Sequence(_)
-        | webidl::ast::TypeKind::Symbol
-        | webidl::ast::TypeKind::USVString
-        | webidl::ast::TypeKind::Uint16Array
-        | webidl::ast::TypeKind::Uint32Array
-        | webidl::ast::TypeKind::Uint8Array
-        | webidl::ast::TypeKind::Uint8ClampedArray
-        | webidl::ast::TypeKind::Union(_) => {
-            return None;
-        }
-    })
-}
-
 pub fn webidl_const_ty_to_syn_ty(ty: &webidl::ast::ConstType) -> syn::Type {
     use webidl::ast::ConstType::*;
 
@@ -132,49 +61,6 @@ fn simple_fn_arg(ident: Ident, ty: syn::Type) -> syn::ArgCaptured {
     }
 }
 
-fn webidl_arguments_to_syn_arg_captured<'a, I>(
-    arguments: I,
-    kind: &backend::ast::ImportFunctionKind,
-) -> Option<Vec<syn::ArgCaptured>>
-where
-    I: Iterator<Item = (&'a str, &'a webidl::ast::Type, bool)>,
-{
-    let estimate = arguments.size_hint();
-    let len = estimate.1.unwrap_or(estimate.0);
-    let mut res = if let backend::ast::ImportFunctionKind::Method {
-        ty,
-        kind:
-            backend::ast::MethodKind::Operation(backend::ast::Operation {
-                is_static: false, ..
-            }),
-        ..
-    } = kind
-    {
-        let mut res = Vec::with_capacity(len + 1);
-        res.push(simple_fn_arg(raw_ident("self_"), shared_ref(ty.clone())));
-        res
-    } else {
-        Vec::with_capacity(len)
-    };
-
-    for (name, ty, variadic) in arguments {
-        if variadic {
-            warn!("Variadic arguments are not supported yet",);
-            return None;
-        }
-
-        match webidl_ty_to_syn_ty(ty, TypePosition::Argument) {
-            None => {
-                warn!("Argument's type is not yet supported: {:?}", ty);
-                return None;
-            }
-            Some(ty) => res.push(simple_fn_arg(rust_ident(&name.to_snake_case()), ty)),
-        }
-    }
-
-    Some(res)
-}
-
 fn unit_ty() -> syn::Type {
     syn::Type::Tuple(syn::TypeTuple {
         paren_token: Default::default(),
@@ -202,192 +88,330 @@ fn result_ty(t: syn::Type) -> syn::Type {
     ty.into()
 }
 
-pub fn create_function<'a, I>(
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    name: &str,
+pub enum TypePosition {
-    arguments: I,
+    Argument,
-    mut ret: Option<syn::Type>,
+    Return,
-    kind: backend::ast::ImportFunctionKind,
-    structural: bool,
-    catch: bool,
-) -> Option<backend::ast::ImportFunction>
-where
-    I: Iterator<Item = (&'a str, &'a webidl::ast::Type, bool)>,
-{
-    let rust_name = rust_ident(&name.to_snake_case());
-    let name = raw_ident(name);
-
-    let arguments = webidl_arguments_to_syn_arg_captured(arguments, &kind)?;
-
-    let js_ret = ret.clone();
-
-    if catch {
-        ret = Some(ret.map_or_else(|| result_ty(unit_ty()), |ret| result_ty(ret)))
-    }
-
-    let shim = {
-        let ns = match kind {
-            backend::ast::ImportFunctionKind::Normal => "",
-            backend::ast::ImportFunctionKind::Method { ref class, .. } => class,
-        };
-
-        raw_ident(&format!("__widl_f_{}_{}", rust_name, ns))
-    };
-
-    Some(backend::ast::ImportFunction {
-        function: backend::ast::Function {
-            name,
-            arguments,
-            ret,
-            rust_attrs: vec![],
-            rust_vis: syn::Visibility::Public(syn::VisPublic {
-                pub_token: Default::default(),
-            }),
-        },
-        rust_name,
-        js_ret,
-        catch,
-        structural,
-        kind,
-        shim,
-    })
 }
 
-pub fn create_basic_method(
+impl<'a> FirstPassRecord<'a> {
-    arguments: &[webidl::ast::Argument],
+    pub fn webidl_ty_to_syn_ty(
-    name: Option<&String>,
+        &self,
-    return_type: &webidl::ast::ReturnType,
+        ty: &webidl::ast::Type,
-    self_name: &str,
+        pos: TypePosition,
-    is_static: bool,
+    ) -> Option<syn::Type> {
-    catch: bool,
+        // nullable types are not yet supported (see issue #14)
-) -> Option<backend::ast::ImportFunction> {
+        if ty.nullable {
-    let name = match name {
-        None => {
-            warn!("Operations without a name are unsupported");
             return None;
         }
-        Some(ref name) => name,
+        Some(match ty.kind {
-    };
+            // `any` becomes `::wasm_bindgen::JsValue`.
+            webidl::ast::TypeKind::Any => {
+                simple_path_ty(vec![rust_ident("wasm_bindgen"), rust_ident("JsValue")])
+            }
 
-    let kind = backend::ast::ImportFunctionKind::Method {
+            // A reference to a type by name becomes the same thing in the
-        class: self_name.to_string(),
+            // bindings.
-        ty: ident_ty(rust_ident(self_name)),
+            webidl::ast::TypeKind::Identifier(ref id) => {
-        kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
+                let ty = ident_ty(rust_ident(id.to_camel_case().as_str()));
-            is_static,
+                if self.interfaces.contains(id) {
-            kind: backend::ast::OperationKind::Regular,
+                    if pos == TypePosition::Argument {
-        }),
+                        shared_ref(ty)
-    };
+                    } else {
+                        ty
+                    }
+                } else if self.dictionaries.contains(id) {
+                    ty
+                } else if self.enums.contains(id) {
+                    ty
+                } else {
+                    warn!("unrecognized type {}", id);
+                    ty
+                }
+            }
 
-    let ret = match return_type {
+            // Scalars.
-        webidl::ast::ReturnType::Void => None,
+            webidl::ast::TypeKind::Boolean => ident_ty(raw_ident("bool")),
-        webidl::ast::ReturnType::NonVoid(ty) => match webidl_ty_to_syn_ty(ty, TypePosition::Return)
+            webidl::ast::TypeKind::Byte => ident_ty(raw_ident("i8")),
+            webidl::ast::TypeKind::Octet => ident_ty(raw_ident("u8")),
+            webidl::ast::TypeKind::RestrictedDouble | webidl::ast::TypeKind::UnrestrictedDouble => {
+                ident_ty(raw_ident("f64"))
+            }
+            webidl::ast::TypeKind::RestrictedFloat | webidl::ast::TypeKind::UnrestrictedFloat => {
+                ident_ty(raw_ident("f32"))
+            }
+            webidl::ast::TypeKind::SignedLong => ident_ty(raw_ident("i32")),
+            webidl::ast::TypeKind::SignedLongLong => ident_ty(raw_ident("i64")),
+            webidl::ast::TypeKind::SignedShort => ident_ty(raw_ident("i16")),
+            webidl::ast::TypeKind::UnsignedLong => ident_ty(raw_ident("u32")),
+            webidl::ast::TypeKind::UnsignedLongLong => ident_ty(raw_ident("u64")),
+            webidl::ast::TypeKind::UnsignedShort => ident_ty(raw_ident("u16")),
+
+            // `DOMString -> `&str` for arguments
+            webidl::ast::TypeKind::DOMString if pos == TypePosition::Argument => {
+                shared_ref(ident_ty(raw_ident("str")))
+            }
+            // `DOMString` is not supported yet in other positions.
+            webidl::ast::TypeKind::DOMString => return None,
+
+            // Support for these types is not yet implemented, so skip
+            // generating any bindings for this function.
+            webidl::ast::TypeKind::ArrayBuffer
+            | webidl::ast::TypeKind::ByteString
+            | webidl::ast::TypeKind::DataView
+            | webidl::ast::TypeKind::Error
+            | webidl::ast::TypeKind::Float32Array
+            | webidl::ast::TypeKind::Float64Array
+            | webidl::ast::TypeKind::FrozenArray(_)
+            | webidl::ast::TypeKind::Int16Array
+            | webidl::ast::TypeKind::Int32Array
+            | webidl::ast::TypeKind::Int8Array
+            | webidl::ast::TypeKind::Object
+            | webidl::ast::TypeKind::Promise(_)
+            | webidl::ast::TypeKind::Record(..)
+            | webidl::ast::TypeKind::Sequence(_)
+            | webidl::ast::TypeKind::Symbol
+            | webidl::ast::TypeKind::USVString
+            | webidl::ast::TypeKind::Uint16Array
+            | webidl::ast::TypeKind::Uint32Array
+            | webidl::ast::TypeKind::Uint8Array
+            | webidl::ast::TypeKind::Uint8ClampedArray
+            | webidl::ast::TypeKind::Union(_) => {
+                return None;
+            }
+        })
+    }
+
+    fn webidl_arguments_to_syn_arg_captured<'b, I>(
+        &self,
+        arguments: I,
+        kind: &backend::ast::ImportFunctionKind,
+    ) -> Option<Vec<syn::ArgCaptured>>
+    where
+        I: Iterator<Item = (&'b str, &'b webidl::ast::Type, bool)>,
+    {
+        let estimate = arguments.size_hint();
+        let len = estimate.1.unwrap_or(estimate.0);
+        let mut res = if let backend::ast::ImportFunctionKind::Method {
+            ty,
+            kind:
+                backend::ast::MethodKind::Operation(backend::ast::Operation {
+                    is_static: false, ..
+                }),
+            ..
+        } = kind
         {
+            let mut res = Vec::with_capacity(len + 1);
+            res.push(simple_fn_arg(raw_ident("self_"), shared_ref(ty.clone())));
+            res
+        } else {
+            Vec::with_capacity(len)
+        };
+
+        for (name, ty, variadic) in arguments {
+            if variadic {
+                warn!("Variadic arguments are not supported yet",);
+                return None;
+            }
+
+            match self.webidl_ty_to_syn_ty(ty, TypePosition::Argument) {
+                None => {
+                    warn!("Argument's type is not yet supported: {:?}", ty);
+                    return None;
+                }
+                Some(ty) => res.push(simple_fn_arg(rust_ident(&name.to_snake_case()), ty)),
+            }
+        }
+
+        Some(res)
+    }
+
+    pub fn create_function<'b, I>(
+        &self,
+        name: &str,
+        arguments: I,
+        mut ret: Option<syn::Type>,
+        kind: backend::ast::ImportFunctionKind,
+        structural: bool,
+        catch: bool,
+    ) -> Option<backend::ast::ImportFunction>
+    where
+        I: Iterator<Item = (&'b str, &'b webidl::ast::Type, bool)>,
+    {
+        let rust_name = rust_ident(&name.to_snake_case());
+        let name = raw_ident(name);
+
+        let arguments = self.webidl_arguments_to_syn_arg_captured(arguments, &kind)?;
+
+        let js_ret = ret.clone();
+
+        if catch {
+            ret = Some(ret.map_or_else(|| result_ty(unit_ty()), |ret| result_ty(ret)))
+        }
+
+        let shim = {
+            let ns = match kind {
+                backend::ast::ImportFunctionKind::Normal => "",
+                backend::ast::ImportFunctionKind::Method { ref class, .. } => class,
+            };
+
+            raw_ident(&format!("__widl_f_{}_{}", rust_name, ns))
+        };
+
+        Some(backend::ast::ImportFunction {
+            function: backend::ast::Function {
+                name,
+                arguments,
+                ret,
+                rust_attrs: vec![],
+                rust_vis: public(),
+            },
+            rust_name,
+            js_ret,
+            catch,
+            structural,
+            kind,
+            shim,
+        })
+    }
+
+    pub fn create_basic_method(
+        &self,
+        arguments: &[webidl::ast::Argument],
+        name: Option<&String>,
+        return_type: &webidl::ast::ReturnType,
+        self_name: &str,
+        is_static: bool,
+        catch: bool,
+    ) -> Option<backend::ast::ImportFunction> {
+        let name = match name {
             None => {
-                warn!("Operation's return type is not yet supported: {:?}", ty);
+                warn!("Operations without a name are unsupported");
+                return None;
+            }
+            Some(ref name) => name,
+        };
+
+        let kind = backend::ast::ImportFunctionKind::Method {
+            class: self_name.to_string(),
+            ty: ident_ty(rust_ident(self_name.to_camel_case().as_str())),
+            kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
+                is_static,
+                kind: backend::ast::OperationKind::Regular,
+            }),
+        };
+
+        let ret = match return_type {
+            webidl::ast::ReturnType::Void => None,
+            webidl::ast::ReturnType::NonVoid(ty) => {
+                match self.webidl_ty_to_syn_ty(ty, TypePosition::Return) {
+                    None => {
+                        warn!("Operation's return type is not yet supported: {:?}", ty);
+                        return None;
+                    }
+                    Some(ty) => Some(ty),
+                }
+            }
+        };
+
+        self.create_function(
+            &name,
+            arguments
+                .iter()
+                .map(|arg| (&*arg.name, &*arg.type_, arg.variadic)),
+            ret,
+            kind,
+            false,
+            catch,
+        )
+    }
+
+    pub fn create_getter(
+        &self,
+        name: &str,
+        ty: &webidl::ast::Type,
+        self_name: &str,
+        is_static: bool,
+        is_structural: bool,
+        catch: bool,
+    ) -> Option<backend::ast::ImportFunction> {
+        let ret = match self.webidl_ty_to_syn_ty(ty, TypePosition::Return) {
+            None => {
+                warn!("Attribute's type does not yet support reading: {:?}", ty);
                 return None;
             }
             Some(ty) => Some(ty),
-        },
+        };
-    };
 
-    create_function(
+        let kind = backend::ast::ImportFunctionKind::Method {
-        &name,
+            class: self_name.to_string(),
-        arguments
+            ty: ident_ty(rust_ident(self_name.to_camel_case().as_str())),
-            .iter()
+            kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
-            .map(|arg| (&*arg.name, &*arg.type_, arg.variadic)),
+                is_static,
-        ret,
+                kind: backend::ast::OperationKind::Getter(Some(raw_ident(name))),
-        kind,
+            }),
-        false,
+        };
-        catch,
-    )
-}
 
-pub fn create_getter(
+        self.create_function(name, iter::empty(), ret, kind, is_structural, catch)
-    name: &str,
+    }
-    ty: &webidl::ast::Type,
-    self_name: &str,
-    is_static: bool,
-    is_structural: bool,
-    catch: bool,
-) -> Option<backend::ast::ImportFunction> {
-    let ret = match webidl_ty_to_syn_ty(ty, TypePosition::Return) {
-        None => {
-            warn!("Attribute's type does not yet support reading: {:?}", ty);
-            return None;
-        }
-        Some(ty) => Some(ty),
-    };
 
-    let kind = backend::ast::ImportFunctionKind::Method {
+    pub fn create_setter(
-        class: self_name.to_string(),
+        &self,
-        ty: ident_ty(rust_ident(self_name)),
+        name: &str,
-        kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
+        ty: &webidl::ast::Type,
-            is_static,
+        self_name: &str,
-            kind: backend::ast::OperationKind::Getter(Some(raw_ident(name))),
+        is_static: bool,
-        }),
+        is_structural: bool,
-    };
+        catch: bool,
+    ) -> Option<backend::ast::ImportFunction> {
+        let kind = backend::ast::ImportFunctionKind::Method {
+            class: self_name.to_string(),
+            ty: ident_ty(rust_ident(self_name.to_camel_case().as_str())),
+            kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
+                is_static,
+                kind: backend::ast::OperationKind::Setter(Some(raw_ident(name))),
+            }),
+        };
 
-    create_function(name, iter::empty(), ret, kind, is_structural, catch)
+        self.create_function(
-}
+            &format!("set_{}", name),
-
+            iter::once((name, ty, false)),
-pub fn create_setter(
+            None,
-    name: &str,
+            kind,
-    ty: &webidl::ast::Type,
+            is_structural,
-    self_name: &str,
+            catch,
-    is_static: bool,
+        )
-    is_structural: bool,
+    }
-    catch: bool,
-) -> Option<backend::ast::ImportFunction> {
-    let kind = backend::ast::ImportFunctionKind::Method {
-        class: self_name.to_string(),
-        ty: ident_ty(rust_ident(self_name)),
-        kind: backend::ast::MethodKind::Operation(backend::ast::Operation {
-            is_static,
-            kind: backend::ast::OperationKind::Setter(Some(raw_ident(name))),
-        }),
-    };
-
-    create_function(
-        &format!("set_{}", name),
-        iter::once((name, ty, false)),
-        None,
-        kind,
-        is_structural,
-        catch,
-    )
 }
 
 /// ChromeOnly is for things that are only exposed to priveleged code in Firefox.
 pub fn is_chrome_only(ext_attrs: &[Box<ExtendedAttribute>]) -> bool {
-    ext_attrs.iter().any(|external_attribute| {
+    ext_attrs.iter().any(|attr| match &**attr {
-        return match &**external_attribute {
+        ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name)) => {
-            ExtendedAttribute::ArgumentList(al) => al.name == "ChromeOnly",
+            name == "ChromeOnly"
-            ExtendedAttribute::Identifier(i) => i.lhs == "ChromeOnly",
+        }
-            ExtendedAttribute::IdentifierList(il) => il.lhs == "ChromeOnly",
+        _ => false,
-            ExtendedAttribute::NamedArgumentList(nal) => nal.lhs_name == "ChromeOnly",
-            ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name)) => {
-                name == "ChromeOnly"
-            }
-            ExtendedAttribute::NoArguments(_na) => false,
-        };
     })
 }
 
 pub fn is_structural(attrs: &[Box<ExtendedAttribute>]) -> bool {
-    attrs.iter().any(|attr| {
+    attrs.iter().any(|attr| match &**attr {
-        if let ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(ref name)) = **attr {
+        ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name)) => {
             name == "Unforgeable"
-        } else {
-            false
         }
+        _ => false,
     })
 }
 
 pub fn throws(attrs: &[Box<ExtendedAttribute>]) -> bool {
-    attrs.iter().any(|attr| {
+    attrs.iter().any(|attr| match &**attr {
-        if let ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(ref name)) = **attr {
+        ExtendedAttribute::NoArguments(webidl::ast::Other::Identifier(name)) => name == "Throws",
-            name == "Throws"
+        _ => false,
-        } else {
+    })
-            false
+}
-        }
+
+pub fn public() -> syn::Visibility {
+    syn::Visibility::Public(syn::VisPublic {
+        pub_token: Default::default(),
     })
 }

crates/webidl/tests/all/consts.rs

@@ -170,19 +170,19 @@ fn floats() {
 
                 #[wasm_bindgen]
                 pub fn test() {
-                    assert_eq!(foo::floats::F, 0.0);
+                    assert_eq!(foo::Floats::F, 0.0_f32);
-                    assert!(foo::floats::NEG_INF.is_infinite());
+                    assert!(foo::Floats::NEG_INF.is_infinite());
-                    assert!(foo::floats::NEG_INF.is_sign_negative());
+                    assert!(foo::Floats::NEG_INF.is_sign_negative());
-                    assert!(foo::floats::INF.is_infinite());
+                    assert!(foo::Floats::INF.is_infinite());
-                    assert!(foo::floats::INF.is_sign_positive());
+                    assert!(foo::Floats::INF.is_sign_positive());
-                    assert!(foo::floats::NAN.is_nan());
+                    assert!(foo::Floats::NAN.is_nan());
 
-                    assert_eq!(foo::doubles::D, 0.0);
+                    assert_eq!(foo::Doubles::D, 0.0_f64);
-                    assert!(foo::doubles::NEG_INF.is_infinite());
+                    assert!(foo::Doubles::NEG_INF.is_infinite());
-                    assert!(foo::doubles::NEG_INF.is_sign_negative());
+                    assert!(foo::Doubles::NEG_INF.is_sign_negative());
-                    assert!(foo::doubles::INF.is_infinite());
+                    assert!(foo::Doubles::INF.is_infinite());
-                    assert!(foo::doubles::INF.is_sign_positive());
+                    assert!(foo::Doubles::INF.is_sign_positive());
-                    assert!(foo::doubles::NAN.is_nan());
+                    assert!(foo::Doubles::NAN.is_nan());
                 }
             "#,
         )

crates/webidl/tests/all/simple.rs

@@ -43,16 +43,10 @@ fn method() {
                 pub fn test() {
                     let pi = Foo::new(3.14159).unwrap();
                     let e = Foo::new(2.71828).unwrap();
-                    // TODO: figure out why the following doesn't fail
+                    assert!(pi.my_cmp(&pi));
-                    // assert!(!pi.my_cmp(Foo::new(3.14159).unwrap()));
+                    assert!(!pi.my_cmp(&e));
-                    let tmp = pi.my_cmp(Foo::new(3.14159).unwrap());
+                    assert!(!e.my_cmp(&pi));
-                    assert!(tmp);
+                    assert!(e.my_cmp(&e));
-                    let tmp =!pi.my_cmp(Foo::new(2.71828).unwrap());
-                    assert!(tmp);
-                    let tmp = !e.my_cmp(Foo::new(3.14159).unwrap());
-                    assert!(tmp);
-                    let tmp = e.my_cmp(Foo::new(2.71828).unwrap());
-                    assert!(tmp);
                 }
             "#,
         )
@@ -370,3 +364,130 @@ fn unforgeable_is_structural() {
         )
         .test();
 }
+
+#[test]
+fn partial_interface() {
+    project()
+        .file(
+            "foo.webidl",
+            r#"
+                [Constructor]
+                interface Foo {
+                    readonly attribute short un;
+                    short deux();
+                };
+
+                partial interface Foo {
+                    readonly attribute short trois;
+                    short quatre();
+                };
+            "#,
+        )
+        .file(
+            "foo.js",
+            r#"
+                export class Foo {
+                    get un() {
+                        return 1;
+                    }
+                    deux() {
+                        return 2;
+                    }
+                    get trois() {
+                        return 3;
+                    }
+                    quatre() {
+                        return 4;
+                    }
+                }
+            "#,
+        )
+        .file(
+            "src/lib.rs",
+            r#"
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+
+                pub mod foo;
+
+                #[wasm_bindgen]
+                pub fn test() {
+                    let f = foo::Foo::new().unwrap();
+                    assert_eq!(f.un(), 1);
+                    assert_eq!(f.deux(), 2);
+                    assert_eq!(f.trois(), 3);
+                    assert_eq!(f.quatre(), 4);
+                }
+            "#,
+        )
+        .test();
+}
+
+#[test]
+fn mixin() {
+    project()
+        .file(
+            "foo.webidl",
+            r#"
+                [Constructor(short bar)]
+                interface Foo {
+                    static attribute short defaultBar;
+                };
+
+                interface mixin Bar {
+                    readonly attribute short bar;
+                };
+
+                partial interface mixin Bar {
+                    void addToBar(short other);
+                };
+
+                Foo includes Bar;
+            "#,
+        )
+        .file(
+            "foo.js",
+            r#"
+                export class Foo {
+                    constructor(bar) {
+                        this._bar = bar | Foo.defaultBar;
+                    }
+                    static get defaultBar() {
+                        return Foo._defaultBar;
+                    }
+                    static set defaultBar(defaultBar) {
+                        Foo._defaultBar = defaultBar;
+                    }
+                    get bar() {
+                        return this._bar;
+                    }
+                    addToBar(other) {
+                        this._bar += other;
+                    }
+                }
+            "#,
+        )
+        .file(
+            "src/lib.rs",
+            r#"
+                #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+                extern crate wasm_bindgen;
+                use wasm_bindgen::prelude::*;
+
+                pub mod foo;
+
+                use foo::Foo;
+
+                #[wasm_bindgen]
+                pub fn test() {
+                    let f = Foo::new(1).unwrap();
+                    assert_eq!(f.bar(), 1);
+                    Foo::set_default_bar(7);
+                    f.add_to_bar(Foo::default_bar());
+                    assert_eq!(f.bar(), 8);
+                }
+            "#,
+        )
+        .test();
+}