webidl: add support for partial interfaces and mixins

This is a major change to how webidl is processed. This adds
a two phase process, where the first phase records the names of
various types and indexes the mixins (and might do more in the
future). The actual program building happens in the second phase.

As part of this, this also makes it so that interface objects
are passed by reference, rather than by value. The spec isn't
exactly clear on this, but Mozilla's C++ reflection suggestions
seem to indicate that they should be passed by reference (see
https://developer.mozilla.org/en-US/docs/Mozilla/WebIDL_bindings).

crates/webidl/src/lib.rs

@@ -24,6 +24,7 @@ use std::collections::BTreeSet;
 use std::fs;
 use std::io::{self, Read};
 use std::iter::FromIterator;
+use std::mem;
 use std::path::Path;
 
 use backend::defined::{ImportedTypeDefinitions, RemoveUndefinedImports};
@@ -32,10 +33,7 @@ use failure::ResultExt;
 use heck::CamelCase;
 use quote::ToTokens;
 
-use util::{
+use util::{public, FirstPass, TypePosition};
-    create_basic_method, create_function, create_getter, create_setter, webidl_ty_to_syn_ty,
-    TypePosition,
-};
 
 /// Either `Ok(t)` or `Err(failure::Error)`.
 pub type Result<T> = ::std::result::Result<T, failure::Error>;
@@ -96,45 +94,137 @@ trait WebidlParse<Ctx> {
     fn webidl_parse(&self, program: &mut backend::ast::Program, context: Ctx) -> Result<()>;
 }
 
-impl WebidlParse<()> for Vec<webidl::ast::Definition> {
+fn first_pass<'a>(definitions: &'a [webidl::ast::Definition]) -> FirstPass<'a> {
+    use webidl::ast::*;
+
+    let mut first_pass = FirstPass::default();
+    for def in definitions {
+        if let Definition::Interface(Interface::NonPartial(NonPartialInterface { name, .. })) = def
+        {
+            if first_pass.interfaces.insert(name.clone()) {
+                warn!("Encountered multiple declarations of {}", name);
+            }
+        }
+        if let Definition::Dictionary(Dictionary::NonPartial(NonPartialDictionary {
+            name, ..
+        })) = def
+        {
+            if first_pass.dictionaries.insert(name.clone()) {
+                warn!("Encountered multiple declarations of {}", name);
+            }
+        }
+        if let Definition::Enum(Enum { name, .. }) = def {
+            if first_pass.enums.insert(name.clone()) {
+                warn!("Encountered multiple declarations of {}", name);
+            }
+        }
+        if let Definition::Mixin(mixin) = def {
+            match mixin {
+                Mixin::NonPartial(mixin) => {
+                    let entry = first_pass
+                        .mixins
+                        .entry(mixin.name.clone())
+                        .or_insert(Default::default());
+                    if mem::replace(&mut entry.non_partial, Some(mixin)).is_some() {
+                        warn!(
+                            "Encounterd multiple declarations of {}, using last encountered",
+                            mixin.name
+                        );
+                    }
+                }
+                Mixin::Partial(mixin) => {
+                    let entry = first_pass
+                        .mixins
+                        .entry(mixin.name.clone())
+                        .or_insert(Default::default());
+                    entry.partials.push(mixin);
+                }
+            }
+        }
+    }
+    first_pass
+}
+
+impl WebidlParse<()> for [webidl::ast::Definition] {
     fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
+        let first_pass = first_pass(self);
         for def in self {
-            def.webidl_parse(program, ())?;
+            def.webidl_parse(program, &first_pass)?;
         }
         Ok(())
     }
 }
 
-impl WebidlParse<()> for webidl::ast::Definition {
+impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> 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: &'a FirstPass<'b>,
+    ) -> Result<()> {
+        match self {
+            webidl::ast::Definition::Enum(enumeration) => enumeration.webidl_parse(program, ())?,
+            webidl::ast::Definition::Includes(includes) => {
+                includes.webidl_parse(program, first_pass)?
             }
-            webidl::ast::Definition::Typedef(ref typedef) => typedef.webidl_parse(program, ()),
+            webidl::ast::Definition::Interface(interface) => {
-            webidl::ast::Definition::Enum(ref enumeration) => enumeration.webidl_parse(program, ()),
+                interface.webidl_parse(program, first_pass)?
+            }
+            webidl::ast::Definition::Typedef(typedef) => typedef.webidl_parse(program, first_pass)?,
             // 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::Interface {
+impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::Includes {
-    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: &'a FirstPass<'b>,
+    ) -> 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, (&self.includer, first_pass))?;
+                    }
+                }
+                for partial in &mixin.partials {
+                    for member in &partial.members {
+                        member.webidl_parse(program, (&self.includer, first_pass))?;
+                    }
+                }
+            }
+            None => warn!("Tried to include missing mixin {}", self.includee),
+        }
+        Ok(())
+    }
+}
+
+impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::Interface {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        first_pass: &'a FirstPass<'b>,
+    ) -> 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(())
             }
@@ -142,14 +232,18 @@ impl WebidlParse<()> for webidl::ast::Interface {
     }
 }
 
-impl WebidlParse<()> for webidl::ast::Typedef {
+impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> 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: &'a FirstPass,
+    ) -> 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 +255,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,
         });
@@ -172,8 +264,12 @@ impl WebidlParse<()> for webidl::ast::Typedef {
     }
 }
 
-impl WebidlParse<()> for webidl::ast::NonPartialInterface {
+impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> 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: &'a FirstPass<'b>,
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
@@ -183,34 +279,59 @@ 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),
                 attrs: Vec::new(),
             }),
         });
 
         for extended_attribute in &self.extended_attributes {
-            extended_attribute.webidl_parse(program, self)?;
+            extended_attribute.webidl_parse(program, (self, first_pass))?;
         }
 
         for member in &self.members {
-            member.webidl_parse(program, &self.name)?;
+            member.webidl_parse(program, (&self.name, first_pass))?;
         }
 
         Ok(())
     }
 }
 
-impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::ExtendedAttribute {
+impl<'a, 'b> WebidlParse<&'a FirstPass<'b>> for webidl::ast::PartialInterface {
     fn webidl_parse(
         &self,
         program: &mut backend::ast::Program,
-        interface: &'a webidl::ast::NonPartialInterface,
+        first_pass: &'a FirstPass<'b>,
+    ) -> 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, (&self.name, first_pass))?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<'a, 'b, 'c> WebidlParse<(&'a webidl::ast::NonPartialInterface, &'b FirstPass<'c>)>
+    for webidl::ast::ExtendedAttribute
+{
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        (interface, first_pass): (&'a webidl::ast::NonPartialInterface, &'b FirstPass<'c>),
     ) -> 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,37 +355,32 @@ 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 {
             webidl::ast::ExtendedAttribute::ArgumentList(
                 webidl::ast::ArgumentListExtendedAttribute { arguments, name },
-            )
+            ) if name == "Constructor" =>
-                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 {
@@ -272,10 +388,9 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
                     rhs_arguments,
                     rhs_name,
                 },
-            )
+            ) if lhs_name == "NamedConstructor" =>
-                if lhs_name == "NamedConstructor" =>
             {
-                add_constructor(rhs_arguments, rhs_name);
+                add_constructor(rhs_arguments, rhs_name)
             }
             webidl::ast::ExtendedAttribute::ArgumentList(_)
             | webidl::ast::ExtendedAttribute::Identifier(_)
@@ -290,13 +405,15 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
     }
 }
 
-impl<'a> WebidlParse<&'a str> for webidl::ast::InterfaceMember {
+impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> 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)
+        context: (&'a str, &'b FirstPass<'c>),
-            }
+    ) -> Result<()> {
-            webidl::ast::InterfaceMember::Operation(ref op) => op.webidl_parse(program, self_name),
+        match self {
+            webidl::ast::InterfaceMember::Attribute(attr) => attr.webidl_parse(program, context),
+            webidl::ast::InterfaceMember::Operation(op) => op.webidl_parse(program, context),
             // TODO
             webidl::ast::InterfaceMember::Const(_)
             | webidl::ast::InterfaceMember::Iterable(_)
@@ -309,11 +426,32 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::InterfaceMember {
     }
 }
 
-impl<'a> WebidlParse<&'a str> for webidl::ast::Attribute {
+impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> 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,
+        context: (&'a str, &'b FirstPass<'c>),
+    ) -> Result<()> {
         match self {
-            webidl::ast::Attribute::Regular(attr) => attr.webidl_parse(program, self_name),
+            webidl::ast::MixinMember::Attribute(attr) => attr.webidl_parse(program, context),
-            webidl::ast::Attribute::Static(attr) => attr.webidl_parse(program, self_name),
+            webidl::ast::MixinMember::Operation(op) => op.webidl_parse(program, context),
+            // TODO
+            webidl::ast::MixinMember::Const(_) => {
+                warn!("Unsupported WebIDL interface member: {:?}", self);
+                Ok(())
+            }
+        }
+    }
+}
+impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> for webidl::ast::Attribute {
+    fn webidl_parse(
+        &self,
+        program: &mut backend::ast::Program,
+        context: (&'a str, &'b FirstPass<'c>),
+    ) -> Result<()> {
+        match self {
+            webidl::ast::Attribute::Regular(attr) => attr.webidl_parse(program, context),
+            webidl::ast::Attribute::Static(attr) => attr.webidl_parse(program, context),
             // TODO
             webidl::ast::Attribute::Stringifier(_) => {
                 warn!("Unsupported WebIDL attribute: {:?}", self);
@@ -323,11 +461,15 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::Attribute {
     }
 }
 
-impl<'a> WebidlParse<&'a str> for webidl::ast::Operation {
+impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> 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,
+        context: (&'a str, &'b FirstPass<'c>),
+    ) -> Result<()> {
         match self {
-            webidl::ast::Operation::Regular(op) => op.webidl_parse(program, self_name),
+            webidl::ast::Operation::Regular(op) => op.webidl_parse(program, context),
-            webidl::ast::Operation::Static(op) => op.webidl_parse(program, self_name),
+            webidl::ast::Operation::Static(op) => op.webidl_parse(program, context),
             // TODO
             webidl::ast::Operation::Special(_) | webidl::ast::Operation::Stringifier(_) => {
                 warn!("Unsupported WebIDL operation: {:?}", self);
@@ -337,8 +479,12 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::Operation {
     }
 }
 
-impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
+impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> 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,
+        (self_name, first_pass): (&'a str, &'b FirstPass<'c>),
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
@@ -346,25 +492,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));
         }
 
@@ -372,8 +522,12 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::RegularAttribute {
     }
 }
 
-impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
+impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> 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,
+        (self_name, first_pass): (&'a str, &'b FirstPass<'c>),
+    ) -> Result<()> {
         if util::is_chrome_only(&self.extended_attributes) {
             return Ok(());
         }
@@ -381,25 +535,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));
         }
 
@@ -407,44 +565,56 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::StaticAttribute {
     }
 }
 
-impl<'a> WebidlParse<&'a str> for webidl::ast::RegularOperation {
+impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> 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,
+        (self_name, first_pass): (&'a str, &'b FirstPass<'c>),
+    ) -> 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(())
     }
 }
 
-impl<'a> WebidlParse<&'a str> for webidl::ast::StaticOperation {
+impl<'a, 'b, 'c> WebidlParse<(&'a str, &'b FirstPass<'c>)> 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,
+        (self_name, first_pass): (&'a str, &'b FirstPass<'c>),
+    ) -> 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(())
@@ -458,9 +628,7 @@ impl<'a> WebidlParse<()> for webidl::ast::Enum {
             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

crates/webidl/src/util.rs

@@ -1,8 +1,9 @@
+use std::collections::{BTreeMap, BTreeSet};
 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;
@@ -17,79 +18,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;
-        }
-    })
-}
-
 fn simple_fn_arg(ident: Ident, ty: syn::Type) -> syn::ArgCaptured {
     syn::ArgCaptured {
         pat: syn::Pat::Ident(syn::PatIdent {
@@ -103,49 +31,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(),
@@ -173,192 +58,344 @@ 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(
+#[derive(Default)]
-    arguments: &[webidl::ast::Argument],
+pub struct FirstPass<'a> {
-    name: Option<&String>,
+    pub interfaces: BTreeSet<String>,
-    return_type: &webidl::ast::ReturnType,
+    pub dictionaries: BTreeSet<String>,
-    self_name: &str,
+    pub enums: BTreeSet<String>,
-    is_static: bool,
+    pub mixins: BTreeMap<String, MixinData<'a>>,
-    catch: bool,
+}
-) -> Option<backend::ast::ImportFunction> {
+
-    let name = match name {
+#[derive(Default)]
-        None => {
+pub struct MixinData<'a> {
-            warn!("Operations without a name are unsupported");
+    pub non_partial: Option<&'a webidl::ast::NonPartialMixin>,
+    pub partials: Vec<&'a webidl::ast::PartialMixin>,
+}
+
+impl<'a> FirstPass<'a> {
+    pub fn webidl_ty_to_syn_ty(
+        &self,
+        ty: &webidl::ast::Type,
+        pos: TypePosition,
+    ) -> Option<syn::Type> {
+        // nullable types are not yet supported (see issue #14)
+        if ty.nullable {
             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/simple.rs

@@ -44,14 +44,14 @@ fn method() {
                     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(Foo::new(3.14159).unwrap()));
+                    // assert!(!pi.my_cmp(&pi));
-                    let tmp = pi.my_cmp(Foo::new(3.14159).unwrap());
+                    let tmp = pi.my_cmp(&pi);
                     assert!(tmp);
-                    let tmp =!pi.my_cmp(Foo::new(2.71828).unwrap());
+                    let tmp =!pi.my_cmp(&e);
                     assert!(tmp);
-                    let tmp = !e.my_cmp(Foo::new(3.14159).unwrap());
+                    let tmp = !e.my_cmp(&pi);
                     assert!(tmp);
-                    let tmp = e.my_cmp(Foo::new(2.71828).unwrap());
+                    let tmp = e.my_cmp(&e);
                     assert!(tmp);
                 }
             "#,
@@ -370,3 +370,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();
+}