Make getter/setter names consistent with js_name

crates/backend/src/ast.rs

@@ -248,9 +248,9 @@ pub enum OperationKind {
     /// A standard method, nothing special
     Regular,
     /// A method for getting the value of the provided Ident or String
-    Getter(Option<String>),
+    Getter,
     /// A method for setting the value of the provided Ident or String
-    Setter(Option<String>),
+    Setter,
     /// A dynamically intercepted getter
     IndexingGetter,
     /// A dynamically intercepted setter
@@ -361,8 +361,6 @@ pub struct Function {
     pub name: String,
     /// The span of the function's name in Rust code
     pub name_span: Span,
-    /// Whether the function has a js_name attribute
-    pub renamed_via_js_name: bool,
     /// The arguments to the function
     pub arguments: Vec<syn::PatType>,
     /// The return type of the function, if provided
@@ -544,27 +542,3 @@ impl ImportKind {
         }
     }
 }
-
-impl Function {
-    /// If the rust object has a `fn xxx(&self) -> MyType` method, get the name for a getter in
-    /// javascript (in this case `xxx`, so you can write `val = obj.xxx`)
-    pub fn infer_getter_property(&self) -> &str {
-        &self.name
-    }
-
-    /// If the rust object has a `fn set_xxx(&mut self, MyType)` style method, get the name
-    /// for a setter in javascript (in this case `xxx`, so you can write `obj.xxx = val`)
-    pub fn infer_setter_property(&self) -> Result<String, Diagnostic> {
-        let name = self.name.to_string();
-
-        // Otherwise we infer names based on the Rust function name.
-        if !name.starts_with("set_") {
-            bail_span!(
-                syn::token::Pub(self.name_span),
-                "setters must start with `set_`, found: {}",
-                name,
-            );
-        }
-        Ok(name[4..].to_string())
-    }
-}

crates/backend/src/encode.rs

@@ -203,7 +203,7 @@ fn shared_export<'a>(
     intern: &'a Interner,
 ) -> Result<Export<'a>, Diagnostic> {
     let consumed = matches!(export.method_self, Some(ast::MethodSelf::ByValue));
-    let method_kind = from_ast_method_kind(&export.function, intern, &export.method_kind)?;
+    let method_kind = from_ast_method_kind(&export.method_kind)?;
     Ok(Export {
         class: export.js_class.as_deref(),
         comments: export.comments.iter().map(|s| &**s).collect(),
@@ -321,7 +321,7 @@ fn shared_import_function<'a>(
 ) -> Result<ImportFunction<'a>, Diagnostic> {
     let method = match &i.kind {
         ast::ImportFunctionKind::Method { class, kind, .. } => {
-            let kind = from_ast_method_kind(&i.function, intern, kind)?;
+            let kind = from_ast_method_kind(kind)?;
             Some(MethodData { class, kind })
         }
         ast::ImportFunctionKind::Normal => None,
@@ -584,28 +584,15 @@ macro_rules! encode_api {
 }
 wasm_bindgen_shared::shared_api!(encode_api);
 
-fn from_ast_method_kind<'a>(
-    function: &'a ast::Function,
-    intern: &'a Interner,
-    method_kind: &'a ast::MethodKind,
-) -> Result<MethodKind<'a>, Diagnostic> {
+fn from_ast_method_kind(method_kind: &ast::MethodKind) -> Result<MethodKind, Diagnostic> {
     Ok(match method_kind {
         ast::MethodKind::Constructor => MethodKind::Constructor,
         ast::MethodKind::Operation(ast::Operation { is_static, kind }) => {
             let is_static = *is_static;
             let kind = match kind {
-                ast::OperationKind::Getter(g) => {
-                    let g = g.as_ref().map(|g| intern.intern_str(g));
-                    OperationKind::Getter(g.unwrap_or_else(|| function.infer_getter_property()))
-                }
                 ast::OperationKind::Regular => OperationKind::Regular,
-                ast::OperationKind::Setter(s) => {
-                    let s = s.as_ref().map(|s| intern.intern_str(s));
-                    OperationKind::Setter(match s {
-                        Some(s) => s,
-                        None => intern.intern_str(&function.infer_setter_property()?),
-                    })
-                }
+                ast::OperationKind::Getter => OperationKind::Getter,
+                ast::OperationKind::Setter => OperationKind::Setter,
                 ast::OperationKind::IndexingGetter => OperationKind::IndexingGetter,
                 ast::OperationKind::IndexingSetter => OperationKind::IndexingSetter,
                 ast::OperationKind::IndexingDeleter => OperationKind::IndexingDeleter,

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

@@ -500,8 +500,18 @@ impl<'a> Context<'a> {
                         }
 
                         let (name, kind) = match op.kind {
-                            decode::OperationKind::Getter(f) => (f, AuxExportedMethodKind::Getter),
-                            decode::OperationKind::Setter(f) => (f, AuxExportedMethodKind::Setter),
+                            decode::OperationKind::Getter => {
+                                (export.function.name, AuxExportedMethodKind::Getter)
+                            }
+                            decode::OperationKind::Setter => {
+                                let Some(name) = export.function.name.strip_prefix("set_") else {
+                                    bail!(
+                                        "The setter function `{}` must start with `set_`",
+                                        export.function.name
+                                    );
+                                };
+                                (name, AuxExportedMethodKind::Setter)
+                            }
                             _ => (export.function.name, AuxExportedMethodKind::Method),
                         };
 
@@ -680,62 +690,55 @@ impl<'a> Context<'a> {
         mut class: JsImport,
         function: &decode::Function<'_>,
         structural: bool,
-        op: &decode::Operation<'_>,
+        op: &decode::Operation,
     ) -> Result<(AuxImport, bool), Error> {
+        let name = function.name.to_string();
+
         match op.kind {
             decode::OperationKind::Regular => {
                 if op.is_static {
-                    Ok((
-                        AuxImport::ValueWithThis(class, function.name.to_string()),
-                        false,
-                    ))
+                    Ok((AuxImport::ValueWithThis(class, name), false))
                 } else if structural {
-                    Ok((
-                        AuxImport::StructuralMethod(function.name.to_string()),
-                        false,
-                    ))
+                    Ok((AuxImport::StructuralMethod(name), false))
                 } else {
                     class.fields.push("prototype".to_string());
-                    class.fields.push(function.name.to_string());
+                    class.fields.push(name);
                     Ok((AuxImport::Value(AuxValue::Bare(class)), true))
                 }
             }
 
-            decode::OperationKind::Getter(field) => {
+            decode::OperationKind::Getter => {
                 if structural {
                     if op.is_static {
-                        Ok((
-                            AuxImport::StructuralClassGetter(class, field.to_string()),
-                            false,
-                        ))
+                        Ok((AuxImport::StructuralClassGetter(class, name), false))
                     } else {
-                        Ok((AuxImport::StructuralGetter(field.to_string()), false))
+                        Ok((AuxImport::StructuralGetter(name), false))
                     }
                 } else {
                     let val = if op.is_static {
-                        AuxValue::ClassGetter(class, field.to_string())
+                        AuxValue::ClassGetter(class, name)
                     } else {
-                        AuxValue::Getter(class, field.to_string())
+                        AuxValue::Getter(class, name)
                     };
                     Ok((AuxImport::Value(val), true))
                 }
             }
 
-            decode::OperationKind::Setter(field) => {
+            decode::OperationKind::Setter => {
+                let Some(name) = name.strip_prefix("set_").map(|s| s.to_string()) else {
+                    bail!("The setter function `{}` must start with `set_`", name);
+                };
                 if structural {
                     if op.is_static {
-                        Ok((
-                            AuxImport::StructuralClassSetter(class, field.to_string()),
-                            false,
-                        ))
+                        Ok((AuxImport::StructuralClassSetter(class, name), false))
                     } else {
-                        Ok((AuxImport::StructuralSetter(field.to_string()), false))
+                        Ok((AuxImport::StructuralSetter(name), false))
                     }
                 } else {
                     let val = if op.is_static {
-                        AuxValue::ClassSetter(class, field.to_string())
+                        AuxValue::ClassSetter(class, name)
                     } else {
-                        AuxValue::Setter(class, field.to_string())
+                        AuxValue::Setter(class, name)
                     };
                     Ok((AuxImport::Value(val), true))
                 }

crates/cli/tests/reference/getter-setter.js

@@ -180,14 +180,14 @@ export class Foo {
      * @returns {boolean | undefined}
      */
     static get x() {
-        const ret = wasm.foo_x_static();
+        const ret = wasm.foo_x();
         return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
      * @param {boolean | undefined} [value]
      */
     static set x(value) {
-        wasm.foo_set_x_static(isLikeNone(value) ? 0xFFFFFF : value ? 1 : 0);
+        wasm.foo_set_x(isLikeNone(value) ? 0xFFFFFF : value ? 1 : 0);
     }
 }
 

crates/cli/tests/reference/getter-setter.wat

@@ -20,9 +20,9 @@
   (func $foo_lone_getter (;9;) (type 3) (param i32) (result f64))
   (func $__wbg_set_foo_x (;10;) (type 4) (param i32 i32))
   (func $foo_weird (;11;) (type 2) (param i32) (result i32))
-  (func $foo_x_static (;12;) (type 0) (result i32))
+  (func $foo_x (;12;) (type 0) (result i32))
   (func $__wbg_foo_free (;13;) (type 4) (param i32 i32))
-  (func $foo_set_x_static (;14;) (type 1) (param i32))
+  (func $foo_set_x (;14;) (type 1) (param i32))
   (memory (;0;) 17)
   (export "memory" (memory 0))
   (export "__wbg_foo_free" (func $__wbg_foo_free))
@@ -36,8 +36,8 @@
   (export "foo_set_lone_setter" (func $foo_set_lone_setter))
   (export "foo_weird" (func $foo_weird))
   (export "foo_set_weird" (func $foo_set_weird))
-  (export "foo_x_static" (func $foo_x_static))
-  (export "foo_set_x_static" (func $foo_set_x_static))
+  (export "foo_x" (func $foo_x))
+  (export "foo_set_x" (func $foo_set_x))
   (export "__wbindgen_malloc" (func $__wbindgen_malloc))
   (export "__wbindgen_realloc" (func $__wbindgen_realloc))
   (@custom "target_features" (after code) "\04+\0amultivalue+\0fmutable-globals+\0freference-types+\08sign-ext")

crates/cli/tests/reference/import-getter-setter.d.ts

@@ -0,0 +1,3 @@
+/* tslint:disable */
+/* eslint-disable */
+export function exported(): void;

crates/cli/tests/reference/import-getter-setter.js

@@ -0,0 +1,102 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+export function exported() {
+    wasm.exported();
+}
+
+export function __wbg_a_266c81b129cbc216(arg0) {
+    const ret = getObject(arg0).a;
+    return ret;
+};
+
+export function __wbg_bar2_38c86771c0e03476() {
+    const ret = Bar.bar2();
+    return ret;
+};
+
+export function __wbg_bar_690459206923b526() {
+    const ret = Bar.bar();
+    return ret;
+};
+
+export function __wbg_new_98ff9abc2a3e2736() {
+    const ret = new SomeClass();
+    return addHeapObject(ret);
+};
+
+export function __wbg_prop2_79dcbfe47962d7a7(arg0) {
+    const ret = getObject(arg0).prop2;
+    return ret;
+};
+
+export function __wbg_seta_eda0c18669c4ad53(arg0, arg1) {
+    getObject(arg0).a = arg1 >>> 0;
+};
+
+export function __wbg_setbar2_d99cb80edd0e1959(arg0) {
+    Bar.set_bar2(arg0 >>> 0);
+};
+
+export function __wbg_setbar_029452b4d4645d79(arg0) {
+    Bar.set_bar(arg0 >>> 0);
+};
+
+export function __wbg_setprop2_51e596d4d035bc4d(arg0, arg1) {
+    getObject(arg0).prop2 = arg1 >>> 0;
+};
+
+export function __wbg_setsignal_bd536e517c35da41(arg0, arg1) {
+    getObject(arg0).signal = arg1 >>> 0;
+};
+
+export function __wbg_setsomeprop_965004b0138eb32c(arg0, arg1) {
+    getObject(arg0).some_prop = arg1 >>> 0;
+};
+
+export function __wbg_signal_89fe6c5b19fec3df(arg0) {
+    const ret = getObject(arg0).signal;
+    return ret;
+};
+
+export function __wbg_someprop_fd4fc05f44bf5de2(arg0) {
+    const ret = getObject(arg0).some_prop;
+    return ret;
+};
+
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+