webidl: initial enum support

Slowki · Slowki · commit 28adf5820e71 · 2018-07-09T21:46:51.000-04:00
Add enum support to the WebIDL interface generator.
diff --git a/crates/backend/src/ast.rs b/crates/backend/src/ast.rs
@@ -41,6 +41,7 @@ pub enum ImportKind {
     Function(ImportFunction),
     Static(ImportStatic),
     Type(ImportType),
+    Enum(ImportEnum),
 }
 
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
@@ -99,6 +100,18 @@ pub struct ImportType {
     pub attrs: Vec<syn::Attribute>,
 }
 
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+pub struct ImportEnum {
+    /// The Rust enum's visibility
+    pub vis: syn::Visibility,
+    /// The Rust enum's identifiers
+    pub name: Ident,
+    /// The Rust identifiers for the variants
+    pub variants: Vec<Ident>,
+    /// The JS string values of the variants
+    pub variant_values: Vec<String>,
+}
+
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
 pub struct Function {
     pub name: Ident,
@@ -279,6 +292,7 @@ impl ImportKind {
             ImportKind::Function(_) => true,
             ImportKind::Static(_) => false,
             ImportKind::Type(_) => false,
+            ImportKind::Enum(_) => false,
         }
     }
 
@@ -287,6 +301,7 @@ impl ImportKind {
             ImportKind::Function(ref f) => shared::ImportKind::Function(f.shared()),
             ImportKind::Static(ref f) => shared::ImportKind::Static(f.shared()),
             ImportKind::Type(ref f) => shared::ImportKind::Type(f.shared()),
+            ImportKind::Enum(ref f) => shared::ImportKind::Enum(f.shared()),
         }
     }
 }
@@ -364,6 +379,12 @@ impl ImportType {
     }
 }
 
+impl ImportEnum {
+    fn shared(&self) -> shared::ImportEnum {
+        shared::ImportEnum {}
+    }
+}
+
 impl Struct {
     fn shared(&self) -> shared::Struct {
         shared::Struct {
diff --git a/crates/backend/src/codegen.rs b/crates/backend/src/codegen.rs
@@ -4,7 +4,7 @@ use std::env;
 use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 
 use ast;
-use proc_macro2::{Ident, Span, TokenStream};
+use proc_macro2::{Ident, Literal, Span, TokenStream};
 use quote::ToTokens;
 use serde_json;
 use shared;
@@ -500,6 +500,7 @@ impl ToTokens for ast::ImportKind {
             ast::ImportKind::Function(ref f) => f.to_tokens(tokens),
             ast::ImportKind::Static(ref s) => s.to_tokens(tokens),
             ast::ImportKind::Type(ref t) => t.to_tokens(tokens),
+            ast::ImportKind::Enum(ref e) => e.to_tokens(tokens),
         }
     }
 }
@@ -586,6 +587,98 @@ impl ToTokens for ast::ImportType {
     }
 }
 
+impl ToTokens for ast::ImportEnum {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let vis = &self.vis;
+        let name = &self.name;
+        let name_string = &self.name.to_string();
+        let variants = &self.variants;
+        let variant_strings = &self.variant_values;
+
+        let mut current_idx: usize = 0;
+        let variant_indexes: Vec<Literal> = variants
+            .iter()
+            .map(|_| {
+                let this_index = current_idx;
+                current_idx += 1;
+                Literal::usize_unsuffixed(this_index)
+            })
+            .collect();
+
+        // Borrow variant_indexes because we need to use it multiple times inside the quote! macro
+        let variant_indexes_ref = &variant_indexes;
+
+        // A vector of EnumName::VariantName tokens for this enum
+        let variant_paths: Vec<TokenStream> = self
+            .variants
+            .iter()
+            .map(|v| quote!(#name::#v).into_token_stream())
+            .collect();
+
+        // Borrow variant_paths because we need to use it multiple times inside the quote! macro
+        let variant_paths_ref = &variant_paths;
+
+        (quote! {
+            #[allow(bad_style)]
+            #[derive(Copy, Clone, Debug)]
+            #vis enum #name {
+                #(#variants = #variant_indexes_ref,)*
+            }
+
+            impl ::wasm_bindgen::describe::WasmDescribe for #name {
+                fn describe() {
+                    ::wasm_bindgen::JsValue::describe()
+                }
+            }
+
+            impl ::wasm_bindgen::convert::IntoWasmAbi for #name {
+                type Abi = <::wasm_bindgen::JsValue as
+                    ::wasm_bindgen::convert::IntoWasmAbi>::Abi;
+
+                fn into_abi(self, extra: &mut ::wasm_bindgen::convert::Stack) -> Self::Abi {
+                    match self {
+                        #(#variant_paths_ref => ::wasm_bindgen::JsValue::from_str(#variant_strings).into_abi(extra),)*
+                    }
+                }
+            }
+
+            impl ::wasm_bindgen::convert::FromWasmAbi for #name {
+                type Abi = <::wasm_bindgen::JsValue as
+                    ::wasm_bindgen::convert::FromWasmAbi>::Abi;
+
+                unsafe fn from_abi(
+                    js: Self::Abi,
+                    extra: &mut ::wasm_bindgen::convert::Stack,
+                ) -> Self {
+                    #name::from(::wasm_bindgen::JsValue::from_abi(js, extra))
+                }
+            }
+
+            impl From<::wasm_bindgen::JsValue> for #name {
+                fn from(obj: ::wasm_bindgen::JsValue) -> #name {
+                    let obj_str = match obj.as_string() {
+                        Some(string_value) => string_value,
+                        None => panic!("Can't convert a non-string into {}", #name_string),
+                    };
+
+                    match obj_str.as_str() {
+                        #(#variant_strings => #variant_paths_ref,)*
+                        unknown_value => panic!("Can't convert \"{}\" into {}", unknown_value, #name_string),
+                    }
+                }
+            }
+
+            impl From<#name> for ::wasm_bindgen::JsValue {
+                fn from(obj: #name) -> ::wasm_bindgen::JsValue {
+                    match obj {
+                        #(#variant_paths_ref => ::wasm_bindgen::JsValue::from_str(#variant_strings)),*
+                    }
+                }
+            }
+        }).to_tokens(tokens);
+    }
+}
+
 impl ToTokens for ast::ImportFunction {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let mut class_ty = None;
@@ -755,6 +848,7 @@ impl<'a> ToTokens for DescribeImport<'a> {
             ast::ImportKind::Function(ref f) => f,
             ast::ImportKind::Static(_) => return,
             ast::ImportKind::Type(_) => return,
+            ast::ImportKind::Enum(_) => return,
         };
         let describe_name = format!("__wbindgen_describe_{}", f.shim);
         let describe_name = Ident::new(&describe_name, Span::call_site());
diff --git a/crates/backend/src/defined.rs b/crates/backend/src/defined.rs
@@ -105,6 +105,7 @@ impl ImportedTypes for ast::ImportKind {
             ast::ImportKind::Static(s) => s.imported_types(f),
             ast::ImportKind::Function(fun) => fun.imported_types(f),
             ast::ImportKind::Type(ty) => ty.imported_types(f),
+            ast::ImportKind::Enum(enm) => enm.imported_types(f),
         }
     }
 }
@@ -210,6 +211,15 @@ impl ImportedTypes for ast::ImportType {
     }
 }
 
+impl ImportedTypes for ast::ImportEnum {
+    fn imported_types<F>(&self, f: &mut F)
+    where
+        F: FnMut(&Ident, ImportedTypeKind),
+    {
+        f(&self.name, ImportedTypeKind::Definition);
+    }
+}
+
 impl ImportedTypes for ast::TypeAlias {
     fn imported_types<F>(&self, f: &mut F)
     where
diff --git a/crates/cli-support/src/js/js2rust.rs b/crates/cli-support/src/js/js2rust.rs
@@ -71,13 +71,15 @@ impl<'a, 'b> Js2Rust<'a, 'b> {
             self.prelude(
                 "if (this.ptr === 0) {
                     throw new Error('Attempt to use a moved value');
-                }"
+                }",
             );
             if consumed {
-                self.prelude("\
-                    const ptr = this.ptr;\n\
-                    this.ptr = 0;\n\
-                ");
+                self.prelude(
+                    "\
+                     const ptr = this.ptr;\n\
+                     this.ptr = 0;\n\
+                     ",
+                );
                 self.rust_arguments.insert(0, "ptr".to_string());
             } else {
                 self.rust_arguments.insert(0, "this.ptr".to_string());
diff --git a/crates/cli-support/src/js/mod.rs b/crates/cli-support/src/js/mod.rs
@@ -1756,6 +1756,7 @@ impl<'a, 'b> SubContext<'a, 'b> {
                 })?;
             }
             shared::ImportKind::Type(_) => {}
+            shared::ImportKind::Enum(_) => {}
         }
         Ok(())
     }
diff --git a/crates/cli-support/src/js/rust2js.rs b/crates/cli-support/src/js/rust2js.rs
@@ -306,16 +306,19 @@ impl<'a, 'b> Rust2Js<'a, 'b> {
             // Insert an assertion to the type of the returned value as
             // otherwise this will cause memory unsafety on the Rust side of
             // things.
-            self.ret_expr = format!("\
+            self.ret_expr = format!(
+                "\
                 const val = JS;
                 if (!(val instanceof {0})) {{
                     throw new Error('expected value of type {0}');
                 }}
                 const ret = val.ptr;
                 val.ptr = 0;
                 return ret;\
-            ", class);
-            return Ok(())
+            ",
+                class
+            );
+            return Ok(());
         }
 
         self.ret_expr = match *ty {
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
@@ -33,6 +33,7 @@ pub enum ImportKind {
     Function(ImportFunction),
     Static(ImportStatic),
     Type(ImportType),
+    Enum(ImportEnum),
 }
 
 #[derive(Deserialize, Serialize)]
@@ -78,6 +79,9 @@ pub struct ImportStatic {
 #[derive(Deserialize, Serialize)]
 pub struct ImportType {}
 
+#[derive(Deserialize, Serialize)]
+pub struct ImportEnum {}
+
 #[derive(Deserialize, Serialize)]
 pub struct Export {
     pub class: Option<String>,
diff --git a/crates/webidl/src/lib.rs b/crates/webidl/src/lib.rs
@@ -29,6 +29,7 @@ use std::path::Path;
 use backend::defined::{ImportedTypeDefinitions, RemoveUndefinedImports};
 use backend::util::{ident_ty, rust_ident, wrap_import_function};
 use failure::ResultExt;
+use heck::CamelCase;
 use quote::ToTokens;
 
 use util::{
@@ -111,10 +112,10 @@ impl WebidlParse<()> for webidl::ast::Definition {
                 interface.webidl_parse(program, ())
             }
             webidl::ast::Definition::Typedef(ref typedef) => typedef.webidl_parse(program, ()),
+            webidl::ast::Definition::Enum(ref enumeration) => enumeration.webidl_parse(program, ()),
             // TODO
             webidl::ast::Definition::Callback(..)
             | webidl::ast::Definition::Dictionary(..)
-            | webidl::ast::Definition::Enum(..)
             | webidl::ast::Definition::Implements(..)
             | webidl::ast::Definition::Includes(..)
             | webidl::ast::Definition::Mixin(..)
@@ -236,7 +237,8 @@ impl<'a> WebidlParse<&'a webidl::ast::NonPartialInterface> for webidl::ast::Exte
         match self {
             webidl::ast::ExtendedAttribute::ArgumentList(
                 webidl::ast::ArgumentListExtendedAttribute { arguments, name },
-            ) if name == "Constructor" =>
+            )
+                if name == "Constructor" =>
             {
                 add_constructor(arguments, &interface.name);
             }
@@ -251,7 +253,8 @@ 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);
             }
@@ -396,3 +399,27 @@ impl<'a> WebidlParse<&'a str> for webidl::ast::StaticOperation {
         Ok(())
     }
 }
+
+impl<'a> WebidlParse<()> for webidl::ast::Enum {
+    fn webidl_parse(&self, program: &mut backend::ast::Program, _: ()) -> Result<()> {
+        program.imports.push(backend::ast::Import {
+            module: None,
+            version: None,
+            js_namespace: None,
+            kind: backend::ast::ImportKind::Enum(backend::ast::ImportEnum {
+                vis: syn::Visibility::Public(syn::VisPublic {
+                    pub_token: Default::default(),
+                }),
+                name: rust_ident(self.name.to_camel_case().as_str()),
+                variants: self
+                    .variants
+                    .iter()
+                    .map(|v| rust_ident(v.to_camel_case().as_str()))
+                    .collect(),
+                variant_values: self.variants.clone(),
+            }),
+        });
+
+        Ok(())
+    }
+}
diff --git a/tests/all/webidl/enums.rs b/tests/all/webidl/enums.rs
diff --git a/tests/all/webidl/mod.rs b/tests/all/webidl/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ pub enum ImportKind {`
`41`	`41`	`Function(ImportFunction),`
`42`	`42`	`Static(ImportStatic),`
`43`	`43`	`Type(ImportType),`
	`44`	`+ Enum(ImportEnum),`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]`
`@@ -99,6 +100,18 @@ pub struct ImportType {`
`99`	`100`	`pub attrs: Vec<syn::Attribute>,`
`100`	`101`	`}`
`101`	`102`
	`103`	`+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]`
	`104`	`+pub struct ImportEnum {`
	`105`	`+ /// The Rust enum's visibility`
	`106`	`+ pub vis: syn::Visibility,`
	`107`	`+ /// The Rust enum's identifiers`
	`108`	`+ pub name: Ident,`
	`109`	`+ /// The Rust identifiers for the variants`
	`110`	`+ pub variants: Vec<Ident>,`
	`111`	`+ /// The JS string values of the variants`
	`112`	`+ pub variant_values: Vec<String>,`
	`113`	`+}`
	`114`	`+`
`102`	`115`	`#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]`
`103`	`116`	`pub struct Function {`
`104`	`117`	`pub name: Ident,`
`@@ -279,6 +292,7 @@ impl ImportKind {`
`279`	`292`	`ImportKind::Function(_) => true,`
`280`	`293`	`ImportKind::Static(_) => false,`
`281`	`294`	`ImportKind::Type(_) => false,`
	`295`	`+ ImportKind::Enum(_) => false,`
`282`	`296`	`}`
`283`	`297`	`}`
`284`	`298`
`@@ -287,6 +301,7 @@ impl ImportKind {`
`287`	`301`	`ImportKind::Function(ref f) => shared::ImportKind::Function(f.shared()),`
`288`	`302`	`ImportKind::Static(ref f) => shared::ImportKind::Static(f.shared()),`
`289`	`303`	`ImportKind::Type(ref f) => shared::ImportKind::Type(f.shared()),`
	`304`	`+ ImportKind::Enum(ref f) => shared::ImportKind::Enum(f.shared()),`
`290`	`305`	`}`
`291`	`306`	`}`
`292`	`307`	`}`
`@@ -364,6 +379,12 @@ impl ImportType {`
`364`	`379`	`}`
`365`	`380`	`}`
`366`	`381`
	`382`	`+impl ImportEnum {`
	`383`	`+ fn shared(&self) -> shared::ImportEnum {`
	`384`	`+ shared::ImportEnum {}`
	`385`	`+ }`
	`386`	`+}`
	`387`	`+`
`367`	`388`	`impl Struct {`
`368`	`389`	`fn shared(&self) -> shared::Struct {`
`369`	`390`	`shared::Struct {`
Original file line number	Diff line number	Diff line change
`@@ -105,6 +105,7 @@ impl ImportedTypes for ast::ImportKind {`
`105`	`105`	`ast::ImportKind::Static(s) => s.imported_types(f),`
`106`	`106`	`ast::ImportKind::Function(fun) => fun.imported_types(f),`
`107`	`107`	`ast::ImportKind::Type(ty) => ty.imported_types(f),`
	`108`	`+ ast::ImportKind::Enum(enm) => enm.imported_types(f),`
`108`	`109`	`}`
`109`	`110`	`}`
`110`	`111`	`}`
`@@ -210,6 +211,15 @@ impl ImportedTypes for ast::ImportType {`
`210`	`211`	`}`
`211`	`212`	`}`
`212`	`213`
	`214`	`+impl ImportedTypes for ast::ImportEnum {`
	`215`	`+ fn imported_types<F>(&self, f: &mut F)`
	`216`	`+ where`
	`217`	`+ F: FnMut(&Ident, ImportedTypeKind),`
	`218`	`+ {`
	`219`	`+ f(&self.name, ImportedTypeKind::Definition);`
	`220`	`+ }`
	`221`	`+}`
	`222`	`+`
`213`	`223`	`impl ImportedTypes for ast::TypeAlias {`
`214`	`224`	`fn imported_types<F>(&self, f: &mut F)`
`215`	`225`	`where`
Original file line number	Diff line number	Diff line change
`@@ -1756,6 +1756,7 @@ impl<'a, 'b> SubContext<'a, 'b> {`
`1756`	`1756`	`})?;`
`1757`	`1757`	`}`
`1758`	`1758`	`shared::ImportKind::Type(_) => {}`
	`1759`	`+ shared::ImportKind::Enum(_) => {}`
`1759`	`1760`	`}`
`1760`	`1761`	`Ok(())`
`1761`	`1762`	`}`