The error that arises is the following: E0401: Inner items do not inherit type or const parameters from the functions they are embedded in.. It hints at that an outer type parameter (in this case Self) is being used in an embedded function.

But how can that be when there isn't any inner function? Well, maybe there is. Lets take a look at this even simpler example:

#[wasm_bindgen]
pub struct A();

#[wasm_bindgen]
impl A
{
  #[wasm_bindgen]
  pub fn foo() -> Option<Self>
  {
    None
  }
}

Using cargo-extend we can see what the #[wasm_bindgen] macro does to the function foo with .

impl A {
    pub fn foo() -> Option<Self> {
        #[automatically_derived]
        const __wasm_bindgen_generated_A_f__const: () = {
            pub unsafe extern "C" fn __wasm_bindgen_generated_A_f() -> <Option<
                Self,
            > as wasm_bindgen::convert::ReturnWasmAbi>::Abi {
                let _ret = {
                    let _ret = A::f();
                    _ret
                };
                <Option<Self> as wasm_bindgen::convert::ReturnWasmAbi>::return_abi(_ret)
            }
        };
        None
    }
}

And there you have it. The problem is that the #[wasm_bindgen] macro creates an inner function with a return type that references Self. Which is disallowed according to E0401:

pub unsafe extern "C" fn __wasm_bindgen_generated_A_f() -> <Option<
                Self,
            >

An example that recreates the error without the #[wasm_bindgen] macro could look like this:

pub struct A();

impl A
{
  pub fn foo() -> Option<Self>
  {
    // `bar` is not allowed to reference `Self`.
    fn bar() -> Option<Self> {
      None
    }
    None
  }
}

Thank you for the detailed answer. It sounds like this is expected (at least if you are familiar with #[wasm_bindgen] internals) and there is no viable path to mitigating this issue in the near term. I suppose explicitly spelling out the type is the best Option then.

It sounds like this is expected (at least if you are familiar with #[wasm_bindgen] internals) and there is no viable path to mitigating this issue in the near term.

No, I think this should be fixable. #[wasm_bindgen] has access to the name of the struct, so it could automatically replace all instances of Self with the concrete type to fix this.

That is great to hear! It would certainly remove a sharp corner for newcomers like myself to cut themselves on... 😅

Should the label be changed from question to enhancement then?