Support raw identifiers for enums and enum variants

crates/backend/src/ast.rs

@@ -475,8 +475,10 @@ pub struct Enum {
 #[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
 #[derive(Clone)]
 pub struct Variant {
-    /// The name of this variant
-    pub name: Ident,
+    /// The name of this variant in Rust
+    pub rust_name: Ident,
+    /// The name of this variant in JS
+    pub js_name: String,
     /// The backing value of this variant
     pub value: u32,
     /// The doc comments on this variant, if any

crates/backend/src/codegen.rs

@@ -1549,7 +1549,7 @@ impl ToTokens for ast::Enum {
         };
         let maybe_no_coverage = coverage();
         let cast_clauses = self.variants.iter().map(|variant| {
-            let variant_name = &variant.name;
+            let variant_name = &variant.rust_name;
             quote! {
                 if js == #enum_name::#variant_name as #underlying {
                     #enum_name::#variant_name

crates/backend/src/encode.rs

@@ -150,7 +150,7 @@ fn shared_program<'a>(
             .iter()
             .map(|a| shared_struct(a, intern))
             .collect(),
-        enums: prog.enums.iter().map(|a| shared_enum(a, intern)).collect(),
+        enums: prog.enums.iter().map(|a| shared_enum(a)).collect(),
         imports: prog
             .imports
             .iter()
@@ -236,23 +236,19 @@ fn shared_function<'a>(func: &'a ast::Function, _intern: &'a Interner) -> Functi
     }
 }
 
-fn shared_enum<'a>(e: &'a ast::Enum, intern: &'a Interner) -> Enum<'a> {
+fn shared_enum(e: &ast::Enum) -> Enum {
     Enum {
         name: &e.js_name,
         signed: e.signed,
-        variants: e
-            .variants
-            .iter()
-            .map(|v| shared_variant(v, intern))
-            .collect(),
+        variants: e.variants.iter().map(shared_variant).collect(),
         comments: e.comments.iter().map(|s| &**s).collect(),
         generate_typescript: e.generate_typescript,
     }
 }
 
-fn shared_variant<'a>(v: &'a ast::Variant, intern: &'a Interner) -> EnumVariant<'a> {
+fn shared_variant(v: &ast::Variant) -> EnumVariant {
     EnumVariant {
-        name: intern.intern(&v.name),
+        name: v.js_name.as_str(),
         value: v.value,
         comments: v.comments.iter().map(|s| &**s).collect(),
     }

crates/cli/tests/reference/raw.d.ts

@@ -1,6 +1,9 @@
 /* tslint:disable */
 /* eslint-disable */
 export function test1(test: number): number;
+export enum Enum {
+  A = 0,
+}
 export class Test {
   private constructor();
   free(): void;

crates/cli/tests/reference/raw.js

@@ -32,6 +32,13 @@ export function test1(test) {
     return ret >>> 0;
 }
 
+/**
+ * @enum {0}
+ */
+export const Enum = Object.freeze({
+    A: 0, "0": "A",
+});
+
 const TestFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_test_free(ptr >>> 0, 1));

crates/cli/tests/reference/raw.rs

@@ -22,3 +22,8 @@ impl r#Test {
 extern "C" {
     fn r#test2() -> JsValue;
 }
+
+#[wasm_bindgen]
+pub enum r#Enum {
+    r#A,
+}

crates/macro-support/src/parser.rs

@@ -1484,7 +1484,7 @@ impl<'a> MacroParse<(&'a mut TokenStream, BindgenAttrs)> for syn::ItemEnum {
         let js_name = opts
             .js_name()
             .map(|s| s.0)
-            .map_or_else(|| self.ident.to_string(), |s| s.to_string());
+            .map_or_else(|| self.ident.unraw().to_string(), |s| s.to_string());
         let comments = extract_doc_comments(&self.attrs);
 
         opts.check_used();
@@ -1588,7 +1588,8 @@ impl<'a> MacroParse<(&'a mut TokenStream, BindgenAttrs)> for syn::ItemEnum {
 
                 let comments = extract_doc_comments(&v.attrs);
                 Ok(ast::Variant {
-                    name: v.ident.clone(),
+                    rust_name: v.ident.clone(),
+                    js_name: v.ident.unraw().to_string(),
                     // due to the above checks, we know that the value fits
                     // within 32 bits, so this cast doesn't lose any information
                     value: value as u32,