Adding LambdaAccessorSlot

rhino/src/main/java/org/mozilla/javascript/LambdaConstructor.java

@@ -6,6 +6,9 @@
 
 package org.mozilla.javascript;
 
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
 /**
  * This class implements a JavaScript function that may be used as a constructor by delegating to an
  * interface that can be easily implemented as a lambda. The LambdaFunction class may be used to add
@@ -120,6 +123,17 @@ public void definePrototypeProperty(Symbol key, Object value, int attributes) {
         proto.defineProperty(key, value, attributes);
     }
 
+    public void definePrototypeProperty(String name, java.util.function.Function<Scriptable, Object> getter, int attributes) {
+        ScriptableObject proto = getPrototypeScriptable();
+        proto.defineProperty(name, getter, null,  attributes );
+    }
+
+    public void definePrototypeProperty(String name, Function<Scriptable, Object> getter, BiConsumer<Scriptable, Object> setter, int attributes) {
+        ScriptableObject proto = getPrototypeScriptable();
+        proto.defineProperty(name, getter, setter,  attributes );
+    }
+
+
     /**
      * Define a function property directly on the constructor that is implemented under the covers
      * by a LambdaFunction.

rhino/src/main/java/org/mozilla/javascript/OwnerAwareLambdaSlot.java

@@ -0,0 +1,88 @@
+package org.mozilla.javascript;
+
+import java.util.IdentityHashMap;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+/**
+ * A specialized property accessor using lambda functions, similar to {@link LambdaSlot},
+ * but allows defining properties with getter and setter lambdas that require access to the owner object ('this').
+ * This enables the implementation of properties that can access instance fields of the owner.
+ *
+ * Unlike {@link LambdaSlot}, Lambda functions used to define getter and setter logic require the owner's
+ * `Scriptable` object as one of the parameters.
+ * This is particularly useful for implementing properties that behave like standard JavaScript properties,
+ * but are implemented with native functionality without the need for reflection.
+ */
+public class OwnerAwareLambdaSlot extends Slot {
+    private transient Function<Scriptable, Object> getter;
+    private transient BiConsumer<Scriptable, Object> setter;
+    OwnerAwareLambdaSlot(Object name, int index) {
+        super(name, index, 0);
+    }
+
+    OwnerAwareLambdaSlot(Slot oldSlot) {
+        super(oldSlot);
+    }
+
+    @Override
+    boolean isValueSlot() {
+        return false;
+    }
+
+
+    @Override
+    ScriptableObject getPropertyDescriptor(Context cx, Scriptable scope) {
+        ScriptableObject desc = (ScriptableObject) cx.newObject(scope);
+        if (getter != null) {
+            desc.defineProperty("get",
+                    new LambdaFunction(scope, "get " + super.name, 0, (cx1, scope1, thisObj, args) ->
+                            getter.apply(thisObj)), ScriptableObject.EMPTY);
+        }
+
+        if (setter != null) {
+            desc.defineProperty("set",
+                    new LambdaFunction(scope, "set " + super.name, 1, (cx1, scope1, thisObj, args) ->
+                    {
+                        setter.accept(thisObj, args[0]);
+                        return  Undefined.instance;
+                    }), ScriptableObject.EMPTY);
+        }
+        desc.setCommonDescriptorProperties(getAttributes(), false);
+        return desc;
+    }
+
+    @Override
+    public boolean setValue(Object value, Scriptable scope, Scriptable owner, boolean isStrict) {
+        if (setter != null) {
+            setter.accept(owner, value);
+            return true;
+        }
+
+        if (isStrict) {
+            // in strict mode
+            throw ScriptRuntime.typeErrorById("msg.modify.readonly", name);
+        } else {
+            super.setValue(value, scope, owner, false);
+        }
+
+        return true;
+    }
+
+    @Override
+    public Object getValue(Scriptable owner) {
+        if (getter != null) {
+            return getter.apply(owner);
+        }
+        Object v = super.getValue(owner);
+        return v == null ? Undefined.instance : v;
+    }
+
+    public void setGetter(Function<Scriptable, Object> getter) {
+        this.getter = getter;
+    }
+
+    public void setSetter(BiConsumer<Scriptable, Object> setter) {
+        this.setter = setter;
+    }
+}

rhino/src/main/java/org/mozilla/javascript/ScriptableObject.java

@@ -28,6 +28,7 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import org.mozilla.javascript.ScriptRuntime.StringIdOrIndex;
@@ -1690,6 +1691,35 @@ public void defineProperty(
         slot.setter = setter;
     }
 
+    /**
+     * Define a property on this object that is implemented using lambda functions accepting Scriptable `this` object
+     * as first parameter. Unlike with `defineProperty(String name, Supplier<Object> getter, Consumer<Object> setter, int attributes)`
+     * where getter and setter need to have access to target object instance, this allows for defining properties on
+     * LambdaConstructor prototype providing getter and setter logic with java instance methods.
+     * If a property with the same name already exists, then it will be replaced. This property will appear to the
+     * JavaScript user exactly like any other property -- unlike Function properties and those based
+     * on reflection, the property descriptor will only reflect the value as defined by this
+     * function.
+     *
+     * @param name the name of the property
+     * @param getter a function that given Scriptable `this` returns the value of the property. If null, throws typeError
+     * @param setter a function that Scriptable `this` and a value sets the value of the property, by calling appropriate
+     *               method on `this`. If null, then the value will be
+     *     set directly and may not be retrieved by the getter.
+     * @param attributes the attributes to set on the property
+     */
+    public void defineProperty(
+            String name, java.util.function.Function<Scriptable, Object> getter, BiConsumer<Scriptable, Object> setter, int attributes) {
+        if (getter == null && setter == null)
+            throw ScriptRuntime.typeError("at least one of {getter, setter} is required");
+
+        OwnerAwareLambdaSlot slot = slotMap.compute(name, 0, ScriptableObject::ensureOwnerAwareLambdaSlot);
+        slot.setAttributes(attributes);
+
+        slot.setGetter(getter);
+        slot.setSetter(setter);
+    }
+
     protected void checkPropertyDefinition(ScriptableObject desc) {
         Object getter = getProperty(desc, "get");
         if (getter != NOT_FOUND && getter != Undefined.instance && !(getter instanceof Callable)) {
@@ -2695,6 +2725,16 @@ private static LambdaSlot ensureLambdaSlot(Object name, int index, Slot existing
         }
     }
 
+    private static OwnerAwareLambdaSlot ensureOwnerAwareLambdaSlot(Object name, int index, Slot existing) {
+        if (existing == null) {
+            return new OwnerAwareLambdaSlot(name, index);
+        } else if (existing instanceof OwnerAwareLambdaSlot) {
+            return (OwnerAwareLambdaSlot) existing;
+        } else {
+            return new OwnerAwareLambdaSlot(existing);
+        }
+    }
+
     private void writeObject(ObjectOutputStream out) throws IOException {
         out.defaultWriteObject();
         final long stamp = slotMap.readLock();