From 2a6d2004e17f993a02f4d212292258182a2f362b Mon Sep 17 00:00:00 2001
From: Henry <chocolatkey@gmail.com>
Date: Thu, 24 Jan 2019 15:35:21 -0800
Subject: [PATCH 01/13] minor typo in js-sys lib.rs

---
 crates/js-sys/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/js-sys/src/lib.rs b/crates/js-sys/src/lib.rs
index cf70f351..556b827f 100644
--- a/crates/js-sys/src/lib.rs
+++ b/crates/js-sys/src/lib.rs
@@ -4841,7 +4841,7 @@ macro_rules! arrays {
             /// Additionally the returned object can be safely mutated but the
             /// input slice isn't guaranteed to be mutable.
             ///
-            /// Finally, the returned objet is disconnected from the input
+            /// Finally, the returned object is disconnected from the input
             /// slice's lifetime, so there's no guarantee that the data is read
             /// at the right time.
             pub unsafe fn view(rust: &[$ty]) -> $name {

From b3e97a7e45758735fbda111cdff8dab2594253d9 Mon Sep 17 00:00:00 2001
From: Ivo Georgiev <ivo@strem.io>
Date: Mon, 28 Jan 2019 20:55:11 +0100
Subject: [PATCH 02/13] browser-support: warn about the performance hit of
 using the polyfill~

---
 guide/src/reference/browser-support.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/guide/src/reference/browser-support.md b/guide/src/reference/browser-support.md
index 7362ea61..c9f4c5b7 100644
--- a/guide/src/reference/browser-support.md
+++ b/guide/src/reference/browser-support.md
@@ -44,6 +44,10 @@ also like to be aware of it!
      };
      ```
 
+     **Warning:** doing this implies the polyfill will always be used,
+     even if native APIs are available. This has a very significant
+     performance impact (the polyfill was measured to be 100x slower in Chromium)!
+
   2. If you're not using a bundler you can also include support manually by
      adding a `<script>` tag which defines the `TextEncoder` and `TextDecoder`
      globals. [This StackOverflow question][soq] has some example usage and MDN

From c35d6f4b0acdc6a88cdb6fbabe8dece1f4d2438c Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Fri, 25 Jan 2019 14:31:50 -0800
Subject: [PATCH 03/13] Fix conditional #[wasm_bindgen] in impls

Reported in #1191 the fix requires us to get a bit creative I think. The
general gist is that a block like this:

    #[wasm_bindgen]
    impl Foo {
        pub fn foo() {}
    }

was previously expanded all in one go. Now, however, it's expanded into:

    impl Foo {
        #[__wasm_bindgen_class_marker(Foo = "Foo")]
        pub fn foo() {}
    }

    // goop generated by orginal #[wasm_bindgen]

This method of expansion takes advantage of rustc's recursive expansion
feature. It also allows us to expand `impl` blocks and allow inner items
to not be fully expanded yet, such as still having `#[cfg]` attributes
(like in the original bug report).

We use theinternal `__wasm_bindgen_class_marker` to indicate that we're
parsing an `ImplItemMethod` unconditionally, and then generation
proceeds as usual. The only final catch is that when we're expanding in
an `impl` block we have to generate tokens for the `Program`
(wasm-bindgen injected goop like the custom section) inside the body
of the function itself instead of next to it. Otherwise we'd get syntax
errors inside of impl blocks!

Closes #1191
---
 crates/macro-support/src/lib.rs               |  68 ++++++++++
 crates/macro-support/src/parser.rs            | 117 +++++++++++-------
 crates/macro/src/lib.rs                       |  13 ++
 crates/macro/ui-tests/invalid-methods.rs      |   8 +-
 crates/macro/ui-tests/invalid-methods.stderr  |   8 +-
 crates/macro/ui-tests/unused-attributes.rs    |   2 +
 .../macro/ui-tests/unused-attributes.stderr   |  12 +-
 src/lib.rs                                    |   2 +
 tests/wasm/classes.js                         |   5 +
 tests/wasm/classes.rs                         |  17 +++
 10 files changed, 197 insertions(+), 55 deletions(-)

diff --git a/crates/macro-support/src/lib.rs b/crates/macro-support/src/lib.rs
index b931bc82..c9c70494 100644
--- a/crates/macro-support/src/lib.rs
+++ b/crates/macro-support/src/lib.rs
@@ -13,8 +13,11 @@ extern crate wasm_bindgen_shared as shared;
 
 use backend::{Diagnostic, TryToTokens};
 pub use parser::BindgenAttrs;
+use quote::ToTokens;
 use parser::MacroParse;
 use proc_macro2::TokenStream;
+use syn::parse::{Parse, ParseStream, Result as SynResult};
+use quote::TokenStreamExt;
 
 mod parser;
 
@@ -36,3 +39,68 @@ pub fn expand(attr: TokenStream, input: TokenStream) -> Result<TokenStream, Diag
 
     Ok(tokens)
 }
+
+/// Takes the parsed input from a `#[wasm_bindgen]` macro and returns the generated bindings
+pub fn expand_class_marker(attr: TokenStream, input: TokenStream) -> Result<TokenStream, Diagnostic> {
+    parser::reset_attrs_used();
+    let mut item = syn::parse2::<syn::ImplItemMethod>(input)?;
+    let opts: ClassMarker = syn::parse2(attr)?;
+
+    let mut program = backend::ast::Program::default();
+    item.macro_parse(&mut program, (&opts.class, &opts.js_class))?;
+    parser::assert_all_attrs_checked(); // same as above
+
+    // This is where things are slightly different, we are being expanded in the
+    // context of an impl so we can't inject arbitrary item-like tokens into the
+    // output stream. If we were to do that then it wouldn't parse!
+    //
+    // Instead what we want to do is to generate the tokens for `program` into
+    // the header of the function. This'll inject some no_mangle functions and
+    // statics and such, and they should all be valid in the context of the
+    // start of a function.
+    //
+    // We manually implement `ToTokens for ImplItemMethod` here, injecting our
+    // program's tokens before the actual method's inner body tokens.
+    let mut tokens = proc_macro2::TokenStream::new();
+    tokens.append_all(item.attrs.iter().filter(|attr| {
+        match attr.style {
+            syn::AttrStyle::Outer => true,
+            _ => false,
+        }
+    }));
+    item.vis.to_tokens(&mut tokens);
+    item.sig.to_tokens(&mut tokens);
+    let mut err = None;
+    item.block.brace_token.surround(&mut tokens, |tokens| {
+        if let Err(e) = program.try_to_tokens(tokens) {
+            err = Some(e);
+        }
+        tokens.append_all(item.attrs.iter().filter(|attr| {
+            match attr.style {
+                syn::AttrStyle::Inner(_) => true,
+                _ => false,
+            }
+        }));
+        tokens.append_all(&item.block.stmts);
+    });
+
+    if let Some(err) = err {
+        return Err(err)
+    }
+
+    Ok(tokens)
+}
+
+struct ClassMarker {
+    class: syn::Ident,
+    js_class: String,
+}
+
+impl Parse for ClassMarker {
+    fn parse(input: ParseStream) -> SynResult<Self> {
+        let class = input.parse::<syn::Ident>()?;
+        input.parse::<Token![=]>()?;
+        let js_class = input.parse::<syn::LitStr>()?.value();
+        Ok(ClassMarker { class, js_class })
+    }
+}
diff --git a/crates/macro-support/src/parser.rs b/crates/macro-support/src/parser.rs
index ef85cc5f..20e3524f 100644
--- a/crates/macro-support/src/parser.rs
+++ b/crates/macro-support/src/parser.rs
@@ -796,7 +796,7 @@ impl<'a> MacroParse<(Option<BindgenAttrs>, &'a mut TokenStream)> for syn::Item {
 }
 
 impl<'a> MacroParse<BindgenAttrs> for &'a mut syn::ItemImpl {
-    fn macro_parse(self, program: &mut ast::Program, opts: BindgenAttrs) -> Result<(), Diagnostic> {
+    fn macro_parse(self, _program: &mut ast::Program, opts: BindgenAttrs) -> Result<(), Diagnostic> {
         if self.defaultness.is_some() {
             bail_span!(
                 self.defaultness,
@@ -830,7 +830,7 @@ impl<'a> MacroParse<BindgenAttrs> for &'a mut syn::ItemImpl {
         };
         let mut errors = Vec::new();
         for item in self.items.iter_mut() {
-            if let Err(e) = (&name, item).macro_parse(program, &opts) {
+            if let Err(e) = prepare_for_impl_recursion(item, &name, &opts) {
                 errors.push(e);
             }
         }
@@ -840,77 +840,106 @@ impl<'a> MacroParse<BindgenAttrs> for &'a mut syn::ItemImpl {
     }
 }
 
-impl<'a, 'b> MacroParse<&'a BindgenAttrs> for (&'a Ident, &'b mut syn::ImplItem) {
+// Prepare for recursion into an `impl` block. Here we want to attach an
+// internal attribute, `__wasm_bindgen_class_marker`, with any metadata we need
+// to pass from the impl to the impl item. Recursive macro expansion will then
+// expand the `__wasm_bindgen_class_marker` attribute.
+//
+// Note that we currently do this because inner items may have things like cfgs
+// on them, so we want to expand the impl first, let the insides get cfg'd, and
+// then go for the rest.
+fn prepare_for_impl_recursion(
+    item: &mut syn::ImplItem,
+    class: &Ident,
+    impl_opts: &BindgenAttrs
+) -> Result<(), Diagnostic> {
+    let method = match item {
+        syn::ImplItem::Method(m) => m,
+        syn::ImplItem::Const(_) => {
+            bail_span!(
+                &*item,
+                "const definitions aren't supported with #[wasm_bindgen]"
+            );
+        }
+        syn::ImplItem::Type(_) => bail_span!(
+            &*item,
+            "type definitions in impls aren't supported with #[wasm_bindgen]"
+        ),
+        syn::ImplItem::Existential(_) => bail_span!(
+            &*item,
+            "existentials in impls aren't supported with #[wasm_bindgen]"
+        ),
+        syn::ImplItem::Macro(_) => {
+            // In theory we want to allow this, but we have no way of expanding
+            // the macro and then placing our magical attributes on the expanded
+            // functions. As a result, just disallow it for now to hopefully
+            // ward off buggy results from this macro.
+            bail_span!(&*item, "macros in impls aren't supported");
+        }
+        syn::ImplItem::Verbatim(_) => panic!("unparsed impl item?"),
+    };
+
+    let js_class = impl_opts
+        .js_class()
+        .map(|s| s.0.to_string())
+        .unwrap_or(class.to_string());
+
+    method.attrs.insert(0, syn::Attribute {
+        pound_token: Default::default(),
+        style: syn::AttrStyle::Outer,
+        bracket_token: Default::default(),
+        path: syn::Ident::new("__wasm_bindgen_class_marker", Span::call_site()).into(),
+        tts: quote::quote! { (#class = #js_class) }.into(),
+    });
+
+    Ok(())
+}
+
+impl<'a, 'b> MacroParse<(&'a Ident, &'a str)> for &'b mut syn::ImplItemMethod {
     fn macro_parse(
         self,
         program: &mut ast::Program,
-        impl_opts: &'a BindgenAttrs,
+        (class, js_class): (&'a Ident, &'a str),
     ) -> Result<(), Diagnostic> {
-        let (class, item) = self;
-        let method = match item {
-            syn::ImplItem::Method(ref mut m) => m,
-            syn::ImplItem::Const(_) => {
-                bail_span!(
-                    &*item,
-                    "const definitions aren't supported with #[wasm_bindgen]"
-                );
-            }
-            syn::ImplItem::Type(_) => bail_span!(
-                &*item,
-                "type definitions in impls aren't supported with #[wasm_bindgen]"
-            ),
-            syn::ImplItem::Existential(_) => bail_span!(
-                &*item,
-                "existentials in impls aren't supported with #[wasm_bindgen]"
-            ),
-            syn::ImplItem::Macro(_) => {
-                bail_span!(&*item, "macros in impls aren't supported");
-            }
-            syn::ImplItem::Verbatim(_) => panic!("unparsed impl item?"),
-        };
-        match method.vis {
+        match self.vis {
             syn::Visibility::Public(_) => {}
             _ => return Ok(()),
         }
-        if method.defaultness.is_some() {
+        if self.defaultness.is_some() {
             panic!("default methods are not supported");
         }
-        if method.sig.constness.is_some() {
+        if self.sig.constness.is_some() {
             bail_span!(
-                method.sig.constness,
+                self.sig.constness,
                 "can only #[wasm_bindgen] non-const functions",
             );
         }
-        if method.sig.unsafety.is_some() {
-            bail_span!(method.sig.unsafety, "can only bindgen safe functions",);
+        if self.sig.unsafety.is_some() {
+            bail_span!(self.sig.unsafety, "can only bindgen safe functions",);
         }
 
-        let opts = BindgenAttrs::find(&mut method.attrs)?;
-        let comments = extract_doc_comments(&method.attrs);
+        let opts = BindgenAttrs::find(&mut self.attrs)?;
+        let comments = extract_doc_comments(&self.attrs);
         let is_constructor = opts.constructor().is_some();
         let (function, method_self) = function_from_decl(
-            &method.sig.ident,
+            &self.sig.ident,
             &opts,
-            Box::new(method.sig.decl.clone()),
-            method.attrs.clone(),
-            method.vis.clone(),
+            Box::new(self.sig.decl.clone()),
+            self.attrs.clone(),
+            self.vis.clone(),
             true,
             Some(class),
         )?;
-        let js_class = impl_opts
-            .js_class()
-            .map(|s| s.0.to_string())
-            .unwrap_or(class.to_string());
 
         program.exports.push(ast::Export {
             rust_class: Some(class.clone()),
-            js_class: Some(js_class),
+            js_class: Some(js_class.to_string()),
             method_self,
             is_constructor,
             function,
             comments,
             start: false,
-            rust_name: method.sig.ident.clone(),
+            rust_name: self.sig.ident.clone(),
         });
         opts.check_used()?;
         Ok(())
diff --git a/crates/macro/src/lib.rs b/crates/macro/src/lib.rs
index f94d2b52..69149fdd 100755
--- a/crates/macro/src/lib.rs
+++ b/crates/macro/src/lib.rs
@@ -19,3 +19,16 @@ pub fn wasm_bindgen(attr: TokenStream, input: TokenStream) -> TokenStream {
         Err(diagnostic) => (quote! { #diagnostic }).into(),
     }
 }
+
+#[proc_macro_attribute]
+pub fn __wasm_bindgen_class_marker(attr: TokenStream, input: TokenStream) -> TokenStream {
+    match macro_support::expand_class_marker(attr.into(), input.into()) {
+        Ok(tokens) => {
+            if cfg!(feature = "xxx_debug_only_print_generated_code") {
+                println!("{}", tokens);
+            }
+            tokens.into()
+        }
+        Err(diagnostic) => (quote! { #diagnostic }).into(),
+    }
+}
diff --git a/crates/macro/ui-tests/invalid-methods.rs b/crates/macro/ui-tests/invalid-methods.rs
index 78e43bfa..915b16d2 100644
--- a/crates/macro/ui-tests/invalid-methods.rs
+++ b/crates/macro/ui-tests/invalid-methods.rs
@@ -36,8 +36,14 @@ impl A {
     x!();
 
     // pub default fn foo() {} // TODO: compiler's pretty printer totally broken
+}
 
-
+#[wasm_bindgen]
+impl A {
     pub const fn foo() {}
+}
+
+#[wasm_bindgen]
+impl A {
     pub unsafe fn foo() {}
 }
diff --git a/crates/macro/ui-tests/invalid-methods.stderr b/crates/macro/ui-tests/invalid-methods.stderr
index 9ac1b887..b01dc7c8 100644
--- a/crates/macro/ui-tests/invalid-methods.stderr
+++ b/crates/macro/ui-tests/invalid-methods.stderr
@@ -47,15 +47,15 @@ error: macros in impls aren't supported
    |     ^^^^^
 
 error: can only #[wasm_bindgen] non-const functions
-  --> $DIR/invalid-methods.rs:41:9
+  --> $DIR/invalid-methods.rs:43:9
    |
-41 |     pub const fn foo() {}
+43 |     pub const fn foo() {}
    |         ^^^^^
 
 error: can only bindgen safe functions
-  --> $DIR/invalid-methods.rs:42:9
+  --> $DIR/invalid-methods.rs:48:9
    |
-42 |     pub unsafe fn foo() {}
+48 |     pub unsafe fn foo() {}
    |         ^^^^^^
 
 error: aborting due to 10 previous errors
diff --git a/crates/macro/ui-tests/unused-attributes.rs b/crates/macro/ui-tests/unused-attributes.rs
index cafb137b..bc5423ef 100644
--- a/crates/macro/ui-tests/unused-attributes.rs
+++ b/crates/macro/ui-tests/unused-attributes.rs
@@ -4,6 +4,8 @@ extern crate wasm_bindgen;
 
 use wasm_bindgen::prelude::*;
 
+struct A;
+
 #[wasm_bindgen]
 impl A {
     #[wasm_bindgen(method)]
diff --git a/crates/macro/ui-tests/unused-attributes.stderr b/crates/macro/ui-tests/unused-attributes.stderr
index 7ec4ad08..33f2602c 100644
--- a/crates/macro/ui-tests/unused-attributes.stderr
+++ b/crates/macro/ui-tests/unused-attributes.stderr
@@ -1,13 +1,13 @@
 error: unused #[wasm_bindgen] attribute
- --> $DIR/unused-attributes.rs:9:20
-  |
-9 |     #[wasm_bindgen(method)]
-  |                    ^^^^^^
+  --> $DIR/unused-attributes.rs:11:20
+   |
+11 |     #[wasm_bindgen(method)]
+   |                    ^^^^^^
 
 error: unused #[wasm_bindgen] attribute
-  --> $DIR/unused-attributes.rs:10:20
+  --> $DIR/unused-attributes.rs:12:20
    |
-10 |     #[wasm_bindgen(method)]
+12 |     #[wasm_bindgen(method)]
    |                    ^^^^^^
 
 error: aborting due to 2 previous errors
diff --git a/src/lib.rs b/src/lib.rs
index 7b2ffb94..7a94632d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -37,6 +37,8 @@ macro_rules! if_std {
 /// ```
 pub mod prelude {
     pub use wasm_bindgen_macro::wasm_bindgen;
+    #[doc(hidden)]
+    pub use wasm_bindgen_macro::__wasm_bindgen_class_marker;
     pub use JsValue;
 
     if_std! {
diff --git a/tests/wasm/classes.js b/tests/wasm/classes.js
index 325ae72c..1c3ef4cc 100644
--- a/tests/wasm/classes.js
+++ b/tests/wasm/classes.js
@@ -143,3 +143,8 @@ exports.js_renamed_export = () => {
     x.foo();
     x.bar(x);
 };
+
+exports.js_conditional_bindings = () => {
+    const x = new wasm.ConditionalBindings();
+    x.free();
+};
diff --git a/tests/wasm/classes.rs b/tests/wasm/classes.rs
index ba64a105..e73a1b6e 100644
--- a/tests/wasm/classes.rs
+++ b/tests/wasm/classes.rs
@@ -22,6 +22,7 @@ extern "C" {
     fn js_js_rename();
     fn js_access_fields();
     fn js_renamed_export();
+    fn js_conditional_bindings();
 }
 
 #[wasm_bindgen_test]
@@ -402,3 +403,19 @@ impl RenamedExport {
 fn renamed_export() {
     js_renamed_export();
 }
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
+pub struct ConditionalBindings {
+}
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
+impl ConditionalBindings {
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen(constructor))]
+    pub fn new() -> ConditionalBindings {
+        ConditionalBindings {}
+    }
+}
+#[wasm_bindgen_test]
+fn conditional_bindings() {
+    js_conditional_bindings();
+}

From 92244550779ce1d99d3d6414ca77e97da0253d0d Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 28 Jan 2019 14:12:02 -0800
Subject: [PATCH 04/13] Support `Option` with custom enums in JS

Find a hole automatically to use a sentinel value for `None`, and then
just wire everything up!

Closes #1198
---
 crates/backend/src/ast.rs            |  1 +
 crates/backend/src/codegen.rs        | 13 +++++++++++
 crates/cli-support/src/descriptor.rs |  6 ++---
 crates/cli-support/src/js/js2rust.rs | 16 +++++++++++++
 crates/cli-support/src/js/rust2js.rs | 13 +++++++++++
 crates/macro-support/src/parser.rs   | 34 +++++++++++++++++++++++++++-
 tests/wasm/enums.js                  | 10 ++++++++
 tests/wasm/enums.rs                  | 31 ++++++++++++++++++++++++-
 8 files changed, 119 insertions(+), 5 deletions(-)

diff --git a/crates/backend/src/ast.rs b/crates/backend/src/ast.rs
index ce5baacf..37dfbc61 100644
--- a/crates/backend/src/ast.rs
+++ b/crates/backend/src/ast.rs
@@ -207,6 +207,7 @@ pub struct Enum {
     pub name: Ident,
     pub variants: Vec<Variant>,
     pub comments: Vec<String>,
+    pub hole: u32,
 }
 
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
diff --git a/crates/backend/src/codegen.rs b/crates/backend/src/codegen.rs
index 55259d06..c5f9c73a 100644
--- a/crates/backend/src/codegen.rs
+++ b/crates/backend/src/codegen.rs
@@ -1013,6 +1013,7 @@ impl<'a> ToTokens for DescribeImport<'a> {
 impl ToTokens for ast::Enum {
     fn to_tokens(&self, into: &mut TokenStream) {
         let enum_name = &self.name;
+        let hole = &self.hole;
         let cast_clauses = self.variants.iter().map(|variant| {
             let variant_name = &variant.name;
             quote! {
@@ -1034,6 +1035,7 @@ impl ToTokens for ast::Enum {
             impl ::wasm_bindgen::convert::FromWasmAbi for #enum_name {
                 type Abi = u32;
 
+                #[inline]
                 unsafe fn from_abi(
                     js: u32,
                     _extra: &mut ::wasm_bindgen::convert::Stack,
@@ -1044,10 +1046,21 @@ impl ToTokens for ast::Enum {
                 }
             }
 
+            impl ::wasm_bindgen::convert::OptionFromWasmAbi for #enum_name {
+                #[inline]
+                fn is_none(val: &u32) -> bool { *val == #hole }
+            }
+
+            impl ::wasm_bindgen::convert::OptionIntoWasmAbi for #enum_name {
+                #[inline]
+                fn none() -> Self::Abi { #hole }
+            }
+
             impl ::wasm_bindgen::describe::WasmDescribe for #enum_name {
                 fn describe() {
                     use wasm_bindgen::describe::*;
                     inform(ENUM);
+                    inform(#hole);
                 }
             }
         })
diff --git a/crates/cli-support/src/descriptor.rs b/crates/cli-support/src/descriptor.rs
index 1bcea29f..3479a74d 100644
--- a/crates/cli-support/src/descriptor.rs
+++ b/crates/cli-support/src/descriptor.rs
@@ -59,7 +59,7 @@ pub enum Descriptor {
     Vector(Box<Descriptor>),
     String,
     Anyref,
-    Enum,
+    Enum { hole: u32 },
     RustStruct(String),
     Char,
     Option(Box<Descriptor>),
@@ -128,7 +128,7 @@ impl Descriptor {
             OPTIONAL => Descriptor::Option(Box::new(Descriptor::_decode(data))),
             STRING => Descriptor::String,
             ANYREF => Descriptor::Anyref,
-            ENUM => Descriptor::Enum,
+            ENUM => Descriptor::Enum { hole: get(data) },
             RUST_STRUCT => {
                 let name = (0..get(data))
                     .map(|_| char::from_u32(get(data)).unwrap())
@@ -159,7 +159,7 @@ impl Descriptor {
             | Descriptor::U32
             | Descriptor::F32
             | Descriptor::F64
-            | Descriptor::Enum => true,
+            | Descriptor::Enum { .. } => true,
             _ => return false,
         }
     }
diff --git a/crates/cli-support/src/js/js2rust.rs b/crates/cli-support/src/js/js2rust.rs
index aae626ed..847b56ab 100644
--- a/crates/cli-support/src/js/js2rust.rs
+++ b/crates/cli-support/src/js/js2rust.rs
@@ -306,6 +306,14 @@ impl<'a, 'b> Js2Rust<'a, 'b> {
                         .push(format!("isLikeNone({0}) ? 0 : {0}.codePointAt(0)", name));
                     return Ok(self);
                 }
+                Descriptor::Enum { hole } => {
+                    self.cx.expose_is_like_none();
+                    self.js_arguments
+                        .push((name.clone(), "number | undefined".to_string()));
+                    self.rust_arguments
+                        .push(format!("isLikeNone({0}) ? {1} : {0}", name, hole));
+                    return Ok(self);
+                }
                 _ => bail!(
                     "unsupported optional argument type for calling Rust function from JS: {:?}",
                     arg
@@ -609,6 +617,14 @@ impl<'a, 'b> Js2Rust<'a, 'b> {
                     .to_string();
                     return Ok(self);
                 }
+                Descriptor::Enum { hole } => {
+                    self.ret_ty = "number | undefined".to_string();
+                    self.ret_expr = format!("
+                        const ret = RET;
+                        return ret === {} ? undefined : ret;
+                    ", hole);
+                    return Ok(self);
+                }
                 _ => bail!(
                     "unsupported optional return type for calling Rust function from JS: {:?}",
                     ty
diff --git a/crates/cli-support/src/js/rust2js.rs b/crates/cli-support/src/js/rust2js.rs
index b2081c6d..43cb8e2e 100644
--- a/crates/cli-support/src/js/rust2js.rs
+++ b/crates/cli-support/src/js/rust2js.rs
@@ -200,6 +200,11 @@ impl<'a, 'b> Rust2Js<'a, 'b> {
                         .push(format!("{0} === 0xFFFFFF ? undefined : {0} !== 0", abi));
                     return Ok(());
                 }
+                Descriptor::Enum { hole } => {
+                    self.js_arguments
+                        .push(format!("{0} === {1} ? undefined : {0}", abi, hole));
+                    return Ok(());
+                }
                 Descriptor::Char => {
                     let value = self.shim_argument();
                     self.js_arguments.push(format!(
@@ -441,6 +446,14 @@ impl<'a, 'b> Rust2Js<'a, 'b> {
                     .to_string();
                     return Ok(());
                 }
+                Descriptor::Enum { hole } => {
+                    self.cx.expose_is_like_none();
+                    self.ret_expr = format!("
+                        const val = JS;
+                        return isLikeNone(val) ? {} : val;
+                    ", hole);
+                    return Ok(());
+                }
                 _ => bail!(
                     "unsupported optional return type for calling JS function from Rust: {:?}",
                     ty
diff --git a/crates/macro-support/src/parser.rs b/crates/macro-support/src/parser.rs
index 20e3524f..c3ea5ad9 100644
--- a/crates/macro-support/src/parser.rs
+++ b/crates/macro-support/src/parser.rs
@@ -953,6 +953,12 @@ impl MacroParse<()> for syn::ItemEnum {
             _ => bail_span!(self, "only public enums are allowed with #[wasm_bindgen]"),
         }
 
+        if self.variants.len() == 0 {
+            bail_span!(self, "cannot export empty enums to JS");
+        }
+
+        let has_discriminant = self.variants[0].discriminant.is_some();
+
         let variants = self
             .variants
             .iter()
@@ -962,6 +968,14 @@ impl MacroParse<()> for syn::ItemEnum {
                     syn::Fields::Unit => (),
                     _ => bail_span!(v.fields, "only C-Style enums allowed with #[wasm_bindgen]"),
                 }
+
+                // Require that everything either has a discriminant or doesn't.
+                // We don't really want to get in the business of emulating how
+                // rustc assigns values to enums.
+                if v.discriminant.is_some() != has_discriminant {
+                    bail_span!(v, "must either annotate discriminant of all variants or none");
+                }
+
                 let value = match v.discriminant {
                     Some((
                         _,
@@ -992,12 +1006,30 @@ impl MacroParse<()> for syn::ItemEnum {
                     value,
                 })
             })
-            .collect::<Result<_, Diagnostic>>()?;
+            .collect::<Result<Vec<_>, Diagnostic>>()?;
+
+        let mut values = variants.iter().map(|v| v.value).collect::<Vec<_>>();
+        values.sort();
+        let hole = values.windows(2)
+            .filter_map(|window| {
+                if window[0] + 1 != window[1] {
+                    Some(window[0] + 1)
+                } else {
+                    None
+                }
+            })
+            .next()
+            .unwrap_or(*values.last().unwrap() + 1);
+        for value in values {
+            assert!(hole != value);
+        }
+
         let comments = extract_doc_comments(&self.attrs);
         program.enums.push(ast::Enum {
             name: self.ident,
             variants,
             comments,
+            hole,
         });
         Ok(())
     }
diff --git a/tests/wasm/enums.js b/tests/wasm/enums.js
index ae66eb4d..4a4debb2 100644
--- a/tests/wasm/enums.js
+++ b/tests/wasm/enums.js
@@ -18,3 +18,13 @@ exports.js_c_style_enum_with_custom_values = () => {
 
     assert.strictEqual(wasm.enum_with_custom_values_cycle(wasm.ColorWithCustomValues.Green), wasm.ColorWithCustomValues.Yellow);
 };
+
+exports.js_handle_optional_enums = x => wasm.handle_optional_enums(x);
+
+exports.js_expect_enum = (a, b) => {
+  assert.strictEqual(a, b);
+};
+
+exports.js_expect_enum_none = a => {
+  assert.strictEqual(a, undefined);
+};
diff --git a/tests/wasm/enums.rs b/tests/wasm/enums.rs
index c51d60b5..f6bacad9 100644
--- a/tests/wasm/enums.rs
+++ b/tests/wasm/enums.rs
@@ -6,9 +6,13 @@ use wasm_bindgen_test::*;
 extern "C" {
     fn js_c_style_enum();
     fn js_c_style_enum_with_custom_values();
+    fn js_handle_optional_enums(x: Option<Color>) -> Option<Color>;
+    fn js_expect_enum(x: Color, y: Option<Color>);
+    fn js_expect_enum_none(x: Option<Color>);
 }
 
 #[wasm_bindgen]
+#[derive(PartialEq, Debug)]
 pub enum Color {
     Green,
     Yellow,
@@ -22,7 +26,7 @@ pub mod inner {
     pub enum ColorWithCustomValues {
         Green = 21,
         Yellow = 34,
-        Red,
+        Red = 2,
     }
 }
 
@@ -53,3 +57,28 @@ fn c_style_enum() {
 fn c_style_enum_with_custom_values() {
     js_c_style_enum_with_custom_values();
 }
+
+#[wasm_bindgen]
+pub fn handle_optional_enums(x: Option<Color>) -> Option<Color> {
+    x
+}
+
+#[wasm_bindgen_test]
+fn test_optional_enums() {
+    use self::Color::*;
+
+    assert_eq!(js_handle_optional_enums(None), None);
+    assert_eq!(js_handle_optional_enums(Some(Green)), Some(Green));
+    assert_eq!(js_handle_optional_enums(Some(Yellow)), Some(Yellow));
+    assert_eq!(js_handle_optional_enums(Some(Red)), Some(Red));
+}
+
+#[wasm_bindgen_test]
+fn test_optional_enum_values() {
+    use self::Color::*;
+
+    js_expect_enum(Green, Some(Green));
+    js_expect_enum(Yellow, Some(Yellow));
+    js_expect_enum(Red, Some(Red));
+    js_expect_enum_none(None);
+}

From 153acdb4fda41e3d62cb7cb9de8c7f0e4c3c1740 Mon Sep 17 00:00:00 2001
From: Andrew Chin <achin@eminence32.net>
Date: Mon, 28 Jan 2019 23:54:40 -0500
Subject: [PATCH 05/13] Fix webaudio example

The rust set_* functions except numbers, not strings.
---
 examples/webaudio/index.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/webaudio/index.js b/examples/webaudio/index.js
index 6ff2e02f..116689cb 100644
--- a/examples/webaudio/index.js
+++ b/examples/webaudio/index.js
@@ -19,21 +19,21 @@ import('./pkg/webaudio')
     const primary_slider = document.getElementById("primary_input");
     primary_slider.addEventListener("input", event => {
       if (fm) {
-        fm.set_note(event.target.value);
+        fm.set_note(parseInt(event.target.value));
       }
     });
 
     const fm_freq = document.getElementById("fm_freq");
     fm_freq.addEventListener("input", event => {
       if (fm) {
-        fm.set_fm_frequency(event.target.value);
+        fm.set_fm_frequency(parseFloat(event.target.value));
       }
     });
 
     const fm_amount = document.getElementById("fm_amount");
     fm_amount.addEventListener("input", event => {
       if (fm) {
-        fm.set_fm_amount(event.target.value);
+        fm.set_fm_amount(parseFloat(event.target.value));
       }
     });
   })

From 5d188e4c0f1e1b7fa8df5a74897cefb00306fb70 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <support@dependabot.com>
Date: Wed, 30 Jan 2019 08:15:57 +0000
Subject: [PATCH 06/13] Update @wasm-tool/wasm-pack-plugin requirement from
 0.2.1 to 0.2.2

Updates the requirements on [@wasm-tool/wasm-pack-plugin](https://github.com/wasm-tool/wasm-pack-plugin) to permit the latest version.
- [Release notes](https://github.com/wasm-tool/wasm-pack-plugin/releases)
- [Commits](https://github.com/wasm-tool/wasm-pack-plugin/commits)

Signed-off-by: dependabot[bot] <support@dependabot.com>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 49198ff2..729651bc 100644
--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
     "serve": "webpack-dev-server -p"
   },
   "devDependencies": {
-    "@wasm-tool/wasm-pack-plugin": "0.2.1",
+    "@wasm-tool/wasm-pack-plugin": "0.2.2",
     "text-encoding": "^0.7.0",
     "html-webpack-plugin": "^3.2.0",
     "webpack": "^4.11.1",

From 08e7560f72cab5d007fcc3c621047531deddbaad Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <support@dependabot.com>
Date: Thu, 31 Jan 2019 08:12:51 +0000
Subject: [PATCH 07/13] Update @wasm-tool/wasm-pack-plugin requirement from
 0.2.2 to 0.2.3

Updates the requirements on [@wasm-tool/wasm-pack-plugin](https://github.com/wasm-tool/wasm-pack-plugin) to permit the latest version.
- [Release notes](https://github.com/wasm-tool/wasm-pack-plugin/releases)
- [Commits](https://github.com/wasm-tool/wasm-pack-plugin/commits)

Signed-off-by: dependabot[bot] <support@dependabot.com>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 729651bc..4c7ce9f9 100644
--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
     "serve": "webpack-dev-server -p"
   },
   "devDependencies": {
-    "@wasm-tool/wasm-pack-plugin": "0.2.2",
+    "@wasm-tool/wasm-pack-plugin": "0.2.3",
     "text-encoding": "^0.7.0",
     "html-webpack-plugin": "^3.2.0",
     "webpack": "^4.11.1",

From 0e11e4a3bd1e3f3345e339de55b3b3be21688c49 Mon Sep 17 00:00:00 2001
From: Nick Fitzgerald <fitzgen@gmail.com>
Date: Thu, 31 Jan 2019 13:26:21 -0800
Subject: [PATCH 08/13] Add the `UnwrapThrowExt<T>` trait

An extension trait for `Option<T>` and `Result<T, E>` for unwraping the `T`
value, or throwing a JS error if it is not available.

These methods should have a smaller code size footprint than the normal
`Option::unwrap` and `Option::expect` methods, but they are specific to
working with wasm and JS.

On non-wasm32 targets, defaults to the normal unwrap/expect calls.
---
 src/lib.rs            | 72 ++++++++++++++++++++++++++++++++++++++++++-
 tests/unwrap_throw.rs | 23 ++++++++++++++
 2 files changed, 94 insertions(+), 1 deletion(-)
 create mode 100644 tests/unwrap_throw.rs

diff --git a/src/lib.rs b/src/lib.rs
index 7a94632d..83354495 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -36,10 +36,11 @@ macro_rules! if_std {
 /// use wasm_bindgen::prelude::*;
 /// ```
 pub mod prelude {
-    pub use wasm_bindgen_macro::wasm_bindgen;
     #[doc(hidden)]
     pub use wasm_bindgen_macro::__wasm_bindgen_class_marker;
+    pub use wasm_bindgen_macro::wasm_bindgen;
     pub use JsValue;
+    pub use UnwrapThrowExt;
 
     if_std! {
         pub use closure::Closure;
@@ -640,6 +641,75 @@ pub fn throw_val(s: JsValue) -> ! {
     }
 }
 
+/// An extension trait for `Option<T>` and `Result<T, E>` for unwraping the `T`
+/// value, or throwing a JS error if it is not available.
+///
+/// These methods should have a smaller code size footprint than the normal
+/// `Option::unwrap` and `Option::expect` methods, but they are specific to
+/// working with wasm and JS.
+///
+/// On non-wasm32 targets, defaults to the normal unwrap/expect calls.
+///
+/// # Example
+///
+/// ```no_run
+/// // If the value is `Option::Some` or `Result::Ok`, then we just get the
+/// // contained `T` value.
+/// let x = Some(42);
+/// assert_eq!(x.unwrap_throw(), 42);
+///
+/// let y: Option<i32> = None;
+///
+/// // This call would throw an error to JS!
+/// //
+/// //     y.unwrap_throw()
+/// //
+/// // And this call would throw an error to JS with a custom error message!
+/// //
+/// //     y.expect_throw("woopsie daisy!")
+/// ```
+pub trait UnwrapThrowExt<T>: Sized {
+    /// Unwrap this `Option` or `Result`, but instead of panicking on failure,
+    /// throw an exception to JavaScript.
+    fn unwrap_throw(self) -> T {
+        self.expect_throw("`unwrap_throw` failed")
+    }
+
+    /// Unwrap this container's `T` value, or throw an error to JS with the
+    /// given message if the `T` value is unavailable (e.g. an `Option<T>` is
+    /// `None`).
+    fn expect_throw(self, message: &str) -> T;
+}
+
+impl<T> UnwrapThrowExt<T> for Option<T> {
+    fn expect_throw(self, message: &str) -> T {
+        if cfg!(all(target_arch = "wasm32", not(target_os = "emscripten"))) {
+            match self {
+                Some(val) => val,
+                None => throw_str(message),
+            }
+        } else {
+            self.expect(message)
+        }
+    }
+}
+
+impl<T, E> UnwrapThrowExt<T> for Result<T, E>
+where
+    E: core::fmt::Debug,
+{
+    fn expect_throw(self, message: &str) -> T {
+        if cfg!(all(target_arch = "wasm32", not(target_os = "emscripten"))) {
+            match self {
+                Ok(val) => val,
+                Err(_) => throw_str(message),
+            }
+        } else {
+            self.expect(message)
+        }
+    }
+}
+
 /// Returns a handle to this wasm instance's `WebAssembly.Module`
 ///
 /// Note that this is only available when the final wasm app is built with
diff --git a/tests/unwrap_throw.rs b/tests/unwrap_throw.rs
new file mode 100644
index 00000000..8a45004e
--- /dev/null
+++ b/tests/unwrap_throw.rs
@@ -0,0 +1,23 @@
+extern crate wasm_bindgen;
+use wasm_bindgen::prelude::*;
+
+#[test]
+fn unwrap_throw_ok() {
+    assert_eq!(Some(42).unwrap_throw(), 42);
+    let x: Result<i32, ()> = Ok(42);
+    assert_eq!(x.unwrap_throw(), 42);
+}
+
+#[test]
+#[should_panic]
+fn unwrap_throw_none() {
+    let x: Option<i32> = None;
+    x.unwrap_throw();
+}
+
+#[test]
+#[should_panic]
+fn unwrap_throw_err() {
+    let x: Result<i32, ()> = Err(());
+    x.unwrap_throw();
+}

From 11db255e473cf7cf30dc7781a400c20d1b9f0eb7 Mon Sep 17 00:00:00 2001
From: Carlos Diaz-Padron <carlosdiazpadron@gmail.com>
Date: Thu, 31 Jan 2019 18:00:49 -0800
Subject: [PATCH 09/13] Fix version number in travis instruction

---
 guide/src/wasm-bindgen-test/continuous-integration.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/guide/src/wasm-bindgen-test/continuous-integration.md b/guide/src/wasm-bindgen-test/continuous-integration.md
index f969d865..a4146954 100644
--- a/guide/src/wasm-bindgen-test/continuous-integration.md
+++ b/guide/src/wasm-bindgen-test/continuous-integration.md
@@ -24,7 +24,7 @@ install:
   - tar xf wasm-bindgen-0.2.21-x86_64-unknown-linux-musl.tar.gz
   - chmod +x wasm-bindgen-0.2.21-x86_64-unknown-linux-musl/wasm-bindgen
   # Moves the binaries to a directory that is in your PATH
-  - mv wasm-bindgen-0.2.19-x86_64-unknown-linux-musl/wasm-bindgen* ~/.cargo/bin 
+  - mv wasm-bindgen-0.2.21-x86_64-unknown-linux-musl/wasm-bindgen* ~/.cargo/bin 
   # Install node.js with nvm.
   - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh | bash
   - source ~/.nvm/nvm.sh

From 019a0863c497eafdf279be814e4ac6ad872b7737 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 1 Feb 2019 15:44:42 +0900
Subject: [PATCH 10/13] give class members 2 spaces indentation in .d.ts files

---
 crates/cli-support/src/js/mod.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/cli-support/src/js/mod.rs b/crates/cli-support/src/js/mod.rs
index 97a062f4..6a38d178 100644
--- a/crates/cli-support/src/js/mod.rs
+++ b/crates/cli-support/src/js/mod.rs
@@ -845,7 +845,7 @@ impl<'a> Context<'a> {
             ",
             name,
         ));
-        ts_dst.push_str("free(): void;\n");
+        ts_dst.push_str("  free(): void;\n");
         dst.push_str(&class.contents);
         ts_dst.push_str(&class.typescript);
         dst.push_str("}\n");
@@ -2399,6 +2399,8 @@ impl<'a, 'b> SubContext<'a, 'b> {
             .contents
             .push_str(&format_doc_comments(&export.comments, Some(js_doc)));
 
+        class.typescript.push_str("  "); // Indentation
+
         if export.is_constructor {
             if class.has_constructor {
                 bail!("found duplicate constructor `{}`", export.function.name);
@@ -2596,7 +2598,7 @@ impl<'a, 'b> SubContext<'a, 'b> {
                     .argument(&descriptor)?
                     .ret(&Descriptor::Unit)?;
                 ts_dst.push_str(&format!(
-                    "{}{}: {};\n",
+                    "  {}{}: {};\n",
                     if field.readonly { "readonly " } else { "" },
                     field.name,
                     &cx.js_arguments[0].1

From 23ccd3b5c1cb47b13260cb0ebadc4439d3f0c23e Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 1 Feb 2019 16:07:12 +0900
Subject: [PATCH 11/13] remove unnecessary space before function name in .d.ts
 file

---
 crates/cli-support/src/js/js2rust.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/cli-support/src/js/js2rust.rs b/crates/cli-support/src/js/js2rust.rs
index aae626ed..1e31e5a1 100644
--- a/crates/cli-support/src/js/js2rust.rs
+++ b/crates/cli-support/src/js/js2rust.rs
@@ -734,7 +734,11 @@ impl<'a, 'b> Js2Rust<'a, 'b> {
             .map(|s| format!("{}: {}", s.0, s.1))
             .collect::<Vec<_>>()
             .join(", ");
-        let mut ts = format!("{} {}({})", prefix, self.js_name, ts_args);
+        let mut ts = if prefix.is_empty() {
+            format!("{}({})", self.js_name, ts_args)
+        } else {
+            format!("{} {}({})", prefix, self.js_name, ts_args)
+        };
         if self.constructor.is_none() {
             ts.push_str(": ");
             ts.push_str(&self.ret_ty);

From a1995cafd42a5cced8a7825b37985db781eb5511 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 1 Feb 2019 16:07:31 +0900
Subject: [PATCH 12/13] remove unnecessary blank lines in .d.ts file

---
 crates/cli-support/src/js/js2rust.rs | 2 +-
 crates/cli-support/src/js/mod.rs     | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/cli-support/src/js/js2rust.rs b/crates/cli-support/src/js/js2rust.rs
index 1e31e5a1..14c540b7 100644
--- a/crates/cli-support/src/js/js2rust.rs
+++ b/crates/cli-support/src/js/js2rust.rs
@@ -743,7 +743,7 @@ impl<'a, 'b> Js2Rust<'a, 'b> {
             ts.push_str(": ");
             ts.push_str(&self.ret_ty);
         }
-        ts.push_str(";\n");
+        ts.push(';');
         (js, ts, self.js_doc_comments())
     }
 }
diff --git a/crates/cli-support/src/js/mod.rs b/crates/cli-support/src/js/mod.rs
index 6a38d178..7d45c323 100644
--- a/crates/cli-support/src/js/mod.rs
+++ b/crates/cli-support/src/js/mod.rs
@@ -845,7 +845,7 @@ impl<'a> Context<'a> {
             ",
             name,
         ));
-        ts_dst.push_str("  free(): void;\n");
+        ts_dst.push_str("  free(): void;");
         dst.push_str(&class.contents);
         ts_dst.push_str(&class.typescript);
         dst.push_str("}\n");
@@ -2598,7 +2598,7 @@ impl<'a, 'b> SubContext<'a, 'b> {
                     .argument(&descriptor)?
                     .ret(&Descriptor::Unit)?;
                 ts_dst.push_str(&format!(
-                    "  {}{}: {};\n",
+                    "\n  {}{}: {};",
                     if field.readonly { "readonly " } else { "" },
                     field.name,
                     &cx.js_arguments[0].1

From 6e2f10440e7bb25c269aa2bf95f065b129d66e64 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 1 Feb 2019 16:25:25 +0900
Subject: [PATCH 13/13] give 2 space indentations to each enum variant

---
 crates/cli-support/src/js/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/cli-support/src/js/mod.rs b/crates/cli-support/src/js/mod.rs
index 7d45c323..0ff36301 100644
--- a/crates/cli-support/src/js/mod.rs
+++ b/crates/cli-support/src/js/mod.rs
@@ -2573,12 +2573,12 @@ impl<'a, 'b> SubContext<'a, 'b> {
             .typescript
             .push_str(&format!("export enum {} {{", enum_.name));
 
-        variants.clear();
         for variant in enum_.variants.iter() {
-            variants.push_str(&format!("{},", variant.name));
+            self.cx
+                .typescript
+                .push_str(&format!("\n  {},", variant.name));
         }
-        self.cx.typescript.push_str(&variants);
-        self.cx.typescript.push_str("}\n");
+        self.cx.typescript.push_str("\n}\n");
     }
 
     fn generate_struct(&mut self, struct_: &decode::Struct) -> Result<(), Error> {