Add support for enums with negative discriminants (#4204)

Author: RunDevelopment

CHANGELOG.md

@@ -14,6 +14,9 @@
 * Added JSDoc type annotations to C-style enums.
   [#4192](https://github.com/rustwasm/wasm-bindgen/pull/4192)
 
+* Added support for C-style enums with negative discriminants.
+  [#4204](https://github.com/rustwasm/wasm-bindgen/pull/4204)
+
 ### Changed
 
 * String enums now generate private TypeScript types but only if used.

crates/backend/src/ast.rs

@@ -445,6 +445,9 @@ pub struct Enum {
     pub rust_name: Ident,
     /// The name of this enum in JS code
     pub js_name: String,
+    /// Whether the variant values and hole are signed, meaning that they
+    /// represent the bits of a `i32` value.
+    pub signed: bool,
     /// The variants provided by this enum
     pub variants: Vec<Variant>,
     /// The doc comments on this enum, if any

crates/backend/src/codegen.rs

@@ -1535,10 +1535,15 @@ impl ToTokens for ast::Enum {
         let name_len = name_str.len() as u32;
         let name_chars = name_str.chars().map(|c| c as u32);
         let hole = &self.hole;
+        let underlying = if self.signed {
+            quote! { i32 }
+        } else {
+            quote! { u32 }
+        };
         let cast_clauses = self.variants.iter().map(|variant| {
             let variant_name = &variant.name;
             quote! {
-                if js == #enum_name::#variant_name as u32 {
+                if js == #enum_name::#variant_name as #underlying {
                     #enum_name::#variant_name
                 }
             }
@@ -1548,20 +1553,20 @@ impl ToTokens for ast::Enum {
         (quote! {
             #[automatically_derived]
             impl #wasm_bindgen::convert::IntoWasmAbi for #enum_name {
-                type Abi = u32;
+                type Abi = #underlying;
 
                 #[inline]
-                fn into_abi(self) -> u32 {
-                    self as u32
+                fn into_abi(self) -> #underlying {
+                    self as #underlying
                 }
             }
 
             #[automatically_derived]
             impl #wasm_bindgen::convert::FromWasmAbi for #enum_name {
-                type Abi = u32;
+                type Abi = #underlying;
 
                 #[inline]
-                unsafe fn from_abi(js: u32) -> Self {
+                unsafe fn from_abi(js: #underlying) -> Self {
                     #(#cast_clauses else)* {
                         #wasm_bindgen::throw_str("invalid enum value passed")
                     }
@@ -1571,13 +1576,13 @@ impl ToTokens for ast::Enum {
             #[automatically_derived]
             impl #wasm_bindgen::convert::OptionFromWasmAbi for #enum_name {
                 #[inline]
-                fn is_none(val: &u32) -> bool { *val == #hole }
+                fn is_none(val: &Self::Abi) -> bool { *val == #hole as #underlying }
             }
 
             #[automatically_derived]
             impl #wasm_bindgen::convert::OptionIntoWasmAbi for #enum_name {
                 #[inline]
-                fn none() -> Self::Abi { #hole }
+                fn none() -> Self::Abi { #hole as #underlying }
             }
 
             #[automatically_derived]
@@ -1597,7 +1602,7 @@ impl ToTokens for ast::Enum {
                 #wasm_bindgen::JsValue
             {
                 fn from(value: #enum_name) -> Self {
-                    #wasm_bindgen::JsValue::from_f64((value as u32).into())
+                    #wasm_bindgen::JsValue::from_f64((value as #underlying).into())
                 }
             }
 
@@ -1608,7 +1613,7 @@ impl ToTokens for ast::Enum {
                 fn try_from_js_value(value: #wasm_bindgen::JsValue)
                     -> #wasm_bindgen::__rt::core::result::Result<Self, <#enum_name as #wasm_bindgen::convert::TryFromJsValue>::Error> {
                     use #wasm_bindgen::__rt::core::convert::TryFrom;
-                    let js = f64::try_from(&value)? as u32;
+                    let js = f64::try_from(&value)? as #underlying;
 
                     #wasm_bindgen::__rt::core::result::Result::Ok(
                         #(#try_from_cast_clauses else)* {

crates/backend/src/encode.rs

@@ -239,6 +239,7 @@ 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> {
     Enum {
         name: &e.js_name,
+        signed: e.signed,
         variants: e
             .variants
             .iter()

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

@@ -894,18 +894,20 @@ impl<'a> Context<'a> {
     }
 
     fn enum_(&mut self, enum_: decode::Enum<'_>) -> Result<(), Error> {
+        let signed = enum_.signed;
         let aux = AuxEnum {
             name: enum_.name.to_string(),
             comments: concatenate_comments(&enum_.comments),
             variants: enum_
                 .variants
                 .iter()
                 .map(|v| {
-                    (
-                        v.name.to_string(),
-                        v.value,
-                        concatenate_comments(&v.comments),
-                    )
+                    let value = if signed {
+                        v.value as i32 as i64
+                    } else {
+                        v.value as i64
+                    };
+                    (v.name.to_string(), value, concatenate_comments(&v.comments))
                 })
                 .collect(),
             generate_typescript: enum_.generate_typescript,

crates/cli-support/src/wit/nonstandard.rs

@@ -170,7 +170,7 @@ pub struct AuxEnum {
     pub comments: String,
     /// A list of variants with their name, value and comments
     /// and whether typescript bindings should be generated for each variant
-    pub variants: Vec<(String, u32, String)>,
+    pub variants: Vec<(String, i64, String)>,
     /// Whether typescript bindings should be generated for this enum.
     pub generate_typescript: bool,
 }

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

@@ -4,6 +4,7 @@ export function enum_echo(color: Color): Color;
 export function option_enum_echo(color?: Color): Color | undefined;
 export function get_name(color: Color): ColorName;
 export function option_string_enum_echo(color?: ColorName): ColorName | undefined;
+export function option_order(order?: Ordering): Ordering | undefined;
 /**
  * A color.
  */
@@ -27,6 +28,14 @@ export enum ImplicitDiscriminant {
   C = 42,
   D = 43,
 }
+/**
+ * A C-style enum with negative discriminants.
+ */
+export enum Ordering {
+  Less = -1,
+  Equal = 0,
+  Greater = 1,
+}
 /**
  * The name of a color.
  */

crates/cli/tests/reference/enums.js

@@ -62,6 +62,15 @@ export function option_string_enum_echo(color) {
     return __wbindgen_enum_ColorName[ret];
 }
 
+/**
+ * @param {Ordering | undefined} [order]
+ * @returns {Ordering | undefined}
+ */
+export function option_order(order) {
+    const ret = wasm.option_order(isLikeNone(order) ? 2 : order);
+    return ret === 2 ? undefined : ret;
+}
+
 /**
  * A color.
  * @enum {0 | 1 | 2}
@@ -89,6 +98,15 @@ export const ImplicitDiscriminant = Object.freeze({
     C: 42, "42": "C",
     D: 43, "43": "D",
 });
+/**
+ * A C-style enum with negative discriminants.
+ * @enum {-1 | 0 | 1}
+ */
+export const Ordering = Object.freeze({
+    Less: -1, "-1": "Less",
+    Equal: 0, "0": "Equal",
+    Greater: 1, "1": "Greater",
+});
 
 const __wbindgen_enum_ColorName = ["green", "yellow", "red"];
 

crates/cli/tests/reference/enums.rs

@@ -65,3 +65,16 @@ pub enum ImplicitDiscriminant {
     C = 42,
     D,
 }
+
+/// A C-style enum with negative discriminants.
+#[wasm_bindgen]
+pub enum Ordering {
+    Less = -1,
+    Equal = 0,
+    Greater = 1,
+}
+
+#[wasm_bindgen]
+pub fn option_order(order: Option<Ordering>) -> Option<Ordering> {
+    order
+}

crates/cli/tests/reference/enums.wat

@@ -4,12 +4,14 @@
   (func $option_enum_echo (;1;) (type 0) (param i32) (result i32))
   (func $get_name (;2;) (type 0) (param i32) (result i32))
   (func $option_string_enum_echo (;3;) (type 0) (param i32) (result i32))
+  (func $option_order (;4;) (type 0) (param i32) (result i32))
   (memory (;0;) 17)
   (export "memory" (memory 0))
   (export "enum_echo" (func $enum_echo))
   (export "option_enum_echo" (func $option_enum_echo))
   (export "get_name" (func $get_name))
   (export "option_string_enum_echo" (func $option_string_enum_echo))
+  (export "option_order" (func $option_order))
   (@custom "target_features" (after code) "\04+\0amultivalue+\0fmutable-globals+\0freference-types+\08sign-ext")
 )