NativeReflect: re-implement Reflect.get()

Author: duonglaiquang

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

@@ -8,6 +8,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import org.mozilla.javascript.ScriptRuntime.StringIdOrIndex;
 
 /**
@@ -213,23 +214,101 @@ private static Object deleteProperty(
         return false;
     }
 
+    /*
+     * https://tc39.es/ecma262/#sec-reflect.get
+     * 1. If target is not an Object, throw a TypeError exception.
+     * 2. Let key be ? ToPropertyKey(propertyKey).
+     * 3. If receiver is not present, then
+     *        a. Set receiver to target.
+     * 4. Return ? target.[[Get]](key, receiver).
+     */
     private static Object get(Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
-        ScriptableObject target = checkTarget(args);
-
-        if (args.length > 1) {
-            if (ScriptRuntime.isSymbol(args[1])) {
-                Object prop = ScriptableObject.getProperty(target, (Symbol) args[1]);
-                return prop == Scriptable.NOT_FOUND ? Undefined.SCRIPTABLE_UNDEFINED : prop;
+        final ScriptableObject target = checkTarget(args);
+        final Object propertyKey = args.length > 1 ? args[1] : Undefined.instance;
+        final Object receiver = args.length > 2 ? args[2] : target;
+
+        // If target is a proxy, delegate to the proxy handler
+        if (target instanceof NativeProxy) {
+            final NativeProxy proxy = (NativeProxy) target;
+            final Function trap = proxy.getTrap("get");
+            if (trap != null) {
+                final ScriptableObject proxyTarget = proxy.getTargetThrowIfRevoked();
+                final Object[] trapArgs = {proxyTarget, propertyKey, receiver};
+                final Object trapResult = proxy.callTrap(trap, trapArgs);
+
+                // checks for non-configurable properties
+                // https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver steps 9
+                final DescriptorInfo targetDesc = proxyTarget.getOwnPropertyDescriptor(cx, propertyKey);
+                if (targetDesc != null && targetDesc.isConfigurable(false)) {
+                    if (targetDesc.isDataDescriptor() && targetDesc.isWritable(false)) {
+                        if (!Objects.equals(trapResult, targetDesc.value)) {
+                            throw ScriptRuntime.typeError(
+                                    "proxy must report the same value for the non-writable,"
+                                            + " non-configurable property '\"" + propertyKey + "\"'");
+                        }
+                    }
+                    if (targetDesc.isAccessorDescriptor()
+                            && (targetDesc.getter == null
+                                    || targetDesc.getter == Scriptable.NOT_FOUND
+                                    || Undefined.isUndefined(targetDesc.getter))) {
+                        if (!Undefined.isUndefined(trapResult)) {
+                            throw ScriptRuntime.typeError(
+                                    "proxy must report the same value for the non-writable,"
+                                            + " non-configurable property '\"" + propertyKey + "\"'");
+                        }
+                    }
+                }
+                return trapResult;
             }
-            if (args[1] instanceof Number) {
-                Object prop = ScriptableObject.getProperty(target, ScriptRuntime.toIndex(args[1]));
-                return prop == Scriptable.NOT_FOUND ? Undefined.SCRIPTABLE_UNDEFINED : prop;
+        }
+
+        return internalGet(cx, target, propertyKey, receiver);
+    }
+
+    /*
+     * https://tc39.es/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-get-p-receiver
+     * 1. Let desc be ? O.[[GetOwnProperty]](P).
+     * 2. If desc is undefined, then
+     *        a. Let parent be ? O.[[GetPrototypeOf]]().
+     *        b. If parent is null, return undefined.
+     *        c. Return ? parent.[[Get]](P, Receiver).
+     * 3. If IsDataDescriptor(desc) is true, return desc.[[Value]].
+     * 4. Assert: IsAccessorDescriptor(desc) is true.
+     * 5. Let getter be desc.[[Get]].
+     * 6. If getter is undefined, return undefined.
+     * 7. Return ? Call(getter, Receiver).
+     */
+    private static Object internalGet(
+            Context cx, ScriptableObject target, Object propertyKey, Object receiver) {
+        final DescriptorInfo desc = target.getOwnPropertyDescriptor(cx, propertyKey);
+        if (desc == null) {
+            final Scriptable parent = target.getPrototype();
+            if (parent == null) {
+                return Undefined.SCRIPTABLE_UNDEFINED;
             }
+            return internalGet(cx, ScriptableObject.ensureScriptableObject(parent), propertyKey, receiver);
+        }
 
-            Object prop = ScriptableObject.getProperty(target, ScriptRuntime.toString(args[1]));
-            return prop == Scriptable.NOT_FOUND ? Undefined.SCRIPTABLE_UNDEFINED : prop;
+        if (desc.isDataDescriptor()) {
+            return desc.value == Scriptable.NOT_FOUND
+                    ? Undefined.SCRIPTABLE_UNDEFINED
+                    : desc.value;
         }
-        return Undefined.SCRIPTABLE_UNDEFINED;
+
+        final Object getter = desc.getter;
+        if (getter == null || getter == Scriptable.NOT_FOUND || Undefined.isUndefined(getter)) {
+            return Undefined.SCRIPTABLE_UNDEFINED;
+        }
+
+        final Scriptable receiverForCall;
+        if (receiver == null || Undefined.isUndefined(receiver)) {
+            receiverForCall = cx.isStrictMode()
+                    ? null
+                    : ScriptableObject.getTopLevelScope(target);
+        } else {
+            receiverForCall = ScriptableObject.ensureScriptable(receiver);
+        }
+        return ((Function) getter).call(cx, target, receiverForCall, ScriptRuntime.emptyArgs);
     }
 
     private static Scriptable getOwnPropertyDescriptor(

tests/src/test/java/org/mozilla/javascript/tests/es6/NativeReflectTest.java

@@ -477,4 +477,65 @@ public void constructSubclassBuiltin() {
                         + " + ' ' + (Object.getPrototypeOf(set) === CustomSet.prototype)";
         Utils.assertWithAllModes_ES6("1,2,3,4 true true true", js);
     }
+
+    @Test
+    public void getWithReceiver() {
+        String js =
+                // accessor: receiver is used as 'this' in getter
+                "var target = {};\n"
+                        + "Object.defineProperty(target, 'x', {\n"
+                        + "  get: function() { return this.value; }\n"
+                        + "});\n"
+                        + "var accessorResult = Reflect.get(target, 'x', { value: 42 });\n"
+                        // inherited accessor: receiver is still used as 'this'
+                        + "var child = Object.create(target);\n"
+                        + "var protoResult = Reflect.get(child, 'x', { value: 'hello' });\n"
+                        // data property: receiver is ignored
+                        + "var dataResult = Reflect.get({ x: 10 }, 'x', { x: 99 });\n"
+                        + "accessorResult + ' ' + protoResult + ' ' + dataResult";
+        Utils.assertWithAllModes_ES6("42 hello 10", js);
+    }
+
+    @Test
+    public void getWithProxyTarget() {
+        String js =
+                "var target = { x: 1 };\n"
+                        + "var proxy = new Proxy(target, {\n"
+                        + "  get: function(target, prop, receiver) {\n"
+                        + "    return 'trapped:' + prop;\n"
+                        + "  }\n"
+                        + "});\n"
+                        + "var trapResult = Reflect.get(proxy, 'x');\n"
+                        + "var frozenTarget = {};\n"
+                        + "Object.defineProperty(frozenTarget, 'x',"
+                        + " { value: 42, writable: false, configurable: false });\n"
+                        + "var nonConfigurableProxy = new Proxy(frozenTarget, {\n"
+                        + "  get: function(target, prop, receiver) { return 'wrong'; }\n"
+                        + "});\n"
+                        + "var nonConfigurableResult;\n"
+                        + "try { Reflect.get(nonConfigurableProxy, 'x'); nonConfigurableResult = 'no error'; }"
+                        + " catch (e) { nonConfigurableResult = 'threw'; }\n"
+                        + "trapResult + ' ' + nonConfigurableResult";
+        Utils.assertWithAllModes_ES6("trapped:x threw", js);
+    }
+
+    @Test
+    public void proxyTrapForwardsViaReflect() {
+        String js =
+                "var target = { x: 'hello' };\n"
+                        + "Object.defineProperty(target, 'context', {\n"
+                        + "  get: function() { return 'context-' + (this.id || 'default'); }\n"
+                        + "});\n"
+                        + "var accessLog = [];\n"
+                        + "var proxy = new Proxy(target, {\n"
+                        + "  get: function(target, key, receiver) {\n"
+                        + "    accessLog.push('get:' + key);\n"
+                        + "    return Reflect.get(target, key, receiver);\n"
+                        + "  }\n"
+                        + "});\n"
+                        + "var getResult = proxy.x;\n"
+                        + "var accessorResult = Reflect.get(proxy, 'context', { id: 'custom' });\n"
+                        + "getResult + ' ' + accessorResult + ' | ' + accessLog";
+        Utils.assertWithAllModes_ES6("hello context-custom | get:x,get:context", js);
+    }
 }