Enum impl fn gives name conflict error

[cretz]

Based on the comment at #1496 (comment), this gives an error:

#[wasm_bindgen]
#[derive(Copy, Clone)]
pub enum ImageFormat {
    PNG,
    JPEG,
    GIF,
}

#[wasm_bindgen]
impl ImageFormat {
    #[wasm_bindgen]
    pub fn from_str(s: &str) -> Result<ImageFormat, JsValue> {
        match s {
            "PNG" => Ok(ImageFormat::PNG),
            "JPEG" => Ok(ImageFormat::JPEG),
            "GIF" => Ok(ImageFormat::GIF),
            _ => Err(JsValue::from(js_sys::Error::new(&format!("Unknown format: {}", s)))),
        }
    }
}

The error is:

error: cannot shadow already defined class `ImageFormat`

The wasm-bindgen version in my lock file is 0.2.48.

[GeorgeScrivener]

I'm running in to this as well using version 0.2.60 , is there a workaround for it?
I'm happy to help track it down but would need some pointers as I'm unfamiliar with the codebase. @alexcrichton where's the best place to start?

[alexcrichton]

The code to fix here is likely around crates/cli-support/src/js/* and this may just be a bug in generation or it may be something where we need to generate some bindings before others. I'm not entirely sure where the bug lies here myself, unfortunately.

[GeorgeScrivener]

The problem seems to be that the class gets generated twice here:

    pub fn generate(&mut self) -> Result<(), Error> {
        for (id, adapter) in crate::sorted_iter(&self.wit.adapters) {
            let instrs = match &adapter.kind {
                AdapterKind::Import { .. } => continue,
                AdapterKind::Local { instructions } => instructions,
            };
            self.generate_adapter(*id, adapter, instrs)?; // << First here as a Method
        }

        ...

        for e in self.aux.enums.iter() {
            self.generate_enum(e)?; // << Then again here
        }
        ...

Enum's are currently generated as JS objects like this:
export const EnumName = Object.freeze({ A:0,B:1,... });

What is the JS we expect to generate for methods on enums?

[alexcrichton]

I don't know what the expected JS for this is, it may be the case that JS doesn't support methods-on-enums.

[Pauan]

@alexcrichton Enums don't exist in JavaScript at all. They do exist in TypeScript, but they do not support methods at all, they are just simple C-style enums.

For example, this...

enum Foo {
    Bar,
    Qux,
    Corge,
}

...gets compiled by TypeScript into this:

(function (Foo) {
    Foo[Foo["Bar"] = 0] = "Bar";
    Foo[Foo["Qux"] = 1] = "Qux";
    Foo[Foo["Corge"] = 2] = "Corge";
})(Foo || (Foo = {}));

This is very similar to what wasm-bindgen currently generates.

TypeScript also supports "ADT-style" enums, which look like this:

type Foo
    = { type: "bar", value: number }
    | { type: "qux" }
    | { type: "corge", first: string, second: string };

These are translated into normal JS objects (e.g. { type: "corge", first: "yes", second: "no" }), and they also do not support methods at all, they are just raw data.

[alexcrichton]

I think this is perhaps an issue we can't fix then? We can likely provide a better error message but methods-on-enums may just not be supported.

[Pauan]

Yeah, I don't see any good ways to support methods on enums:

1. We could translate them into regular JS functions (not methods). That seems... surprising. And it would cause name conflicts.

2. We could translate enums into classes, but that would break conventions with TypeScript, which also seems bad. And that won't work with ADT-style enums (if we ever support those in the future).

We definitely should have a better error message though.

[Pauan]

As far as users are concerned, the solution for them is to export regular functions (not methods), like this:

#[wasm_bindgen]
#[derive(Copy, Clone)]
pub enum ImageFormat {
    PNG,
    JPEG,
    GIF,
}

#[wasm_bindgen]
pub fn from_str(s: &str) -> Result<ImageFormat, JsValue> {
    match s {
        "PNG" => Ok(ImageFormat::PNG),
        "JPEG" => Ok(ImageFormat::JPEG),
        "GIF" => Ok(ImageFormat::GIF),
        _ => Err(JsValue::from(js_sys::Error::new(&format!("Unknown format: {}", s)))),
    }
}

#[wasm_bindgen]
pub fn foo(x: ImageFormat) {
    // ...
}

Now everything works fine, both in the code generation and the TypeScript types.