Title: [197544] trunk/Source/_javascript_Core
Revision
197544
Author
[email protected]
Date
2016-03-03 19:43:06 -0800 (Thu, 03 Mar 2016)

Log Message

[ES6] Implement Proxy.[[SetPrototypeOf]]
https://bugs.webkit.org/show_bug.cgi?id=154931

Reviewed by Ryosuke Niwa.

This patch is a straight forward implementation of Proxy.[[SetPrototypeOf]]
with respect to section 9.5.2 of the ECMAScript spec.
https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-setprototypeof-v

* runtime/JSObject.cpp:
(JSC::JSObject::putInlineSlow):
* runtime/ProxyObject.cpp:
(JSC::ProxyObject::put):
(JSC::ProxyObject::getGenericPropertyNames):
(JSC::ProxyObject::performSetPrototype):
(JSC::ProxyObject::setPrototype):
(JSC::ProxyObject::visitChildren):
* runtime/ProxyObject.h:
* tests/es6.yaml:
* tests/stress/proxy-set-prototype-of.js: Added.
(assert):
(throw.new.Error.let.handler.get setPrototypeOf):
(throw.new.Error.set let):
(throw.new.Error.set catch):
(throw.new.Error):
(assert.let.handler.setPrototypeOf):
(assert.set let):
(assert.set catch):
(let.handler.setPrototypeOf):
(set let):
(set catch):

Modified Paths

Added Paths

Diff

Modified: trunk/Source/_javascript_Core/ChangeLog (197543 => 197544)


--- trunk/Source/_javascript_Core/ChangeLog	2016-03-04 03:19:11 UTC (rev 197543)
+++ trunk/Source/_javascript_Core/ChangeLog	2016-03-04 03:43:06 UTC (rev 197544)
@@ -1,3 +1,37 @@
+2016-03-03  Saam Barati  <[email protected]>
+
+        [ES6] Implement Proxy.[[SetPrototypeOf]]
+        https://bugs.webkit.org/show_bug.cgi?id=154931
+
+        Reviewed by Ryosuke Niwa.
+
+        This patch is a straight forward implementation of Proxy.[[SetPrototypeOf]]
+        with respect to section 9.5.2 of the ECMAScript spec.
+        https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-setprototypeof-v
+
+        * runtime/JSObject.cpp:
+        (JSC::JSObject::putInlineSlow):
+        * runtime/ProxyObject.cpp:
+        (JSC::ProxyObject::put):
+        (JSC::ProxyObject::getGenericPropertyNames):
+        (JSC::ProxyObject::performSetPrototype):
+        (JSC::ProxyObject::setPrototype):
+        (JSC::ProxyObject::visitChildren):
+        * runtime/ProxyObject.h:
+        * tests/es6.yaml:
+        * tests/stress/proxy-set-prototype-of.js: Added.
+        (assert):
+        (throw.new.Error.let.handler.get setPrototypeOf):
+        (throw.new.Error.set let):
+        (throw.new.Error.set catch):
+        (throw.new.Error):
+        (assert.let.handler.setPrototypeOf):
+        (assert.set let):
+        (assert.set catch):
+        (let.handler.setPrototypeOf):
+        (set let):
+        (set catch):
+
 2016-03-03  Keith Miller  <[email protected]>
 
         JSArrayBuffers should be collected less aggressively

Modified: trunk/Source/_javascript_Core/runtime/JSObject.cpp (197543 => 197544)


--- trunk/Source/_javascript_Core/runtime/JSObject.cpp	2016-03-04 03:19:11 UTC (rev 197543)
+++ trunk/Source/_javascript_Core/runtime/JSObject.cpp	2016-03-04 03:43:06 UTC (rev 197544)
@@ -429,7 +429,7 @@
                 }
             }
         }
-        if (obj->type() == ProxyObjectType) {
+        if (obj->type() == ProxyObjectType && propertyName != vm.propertyNames->underscoreProto) {
             ProxyObject* proxy = jsCast<ProxyObject*>(obj);
             proxy->ProxyObject::put(proxy, exec, propertyName, value, slot);
             return;

Modified: trunk/Source/_javascript_Core/runtime/ProxyObject.cpp (197543 => 197544)


--- trunk/Source/_javascript_Core/runtime/ProxyObject.cpp	2016-03-04 03:19:11 UTC (rev 197543)
+++ trunk/Source/_javascript_Core/runtime/ProxyObject.cpp	2016-03-04 03:43:06 UTC (rev 197544)
@@ -405,6 +405,11 @@
 void ProxyObject::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
 {
     VM& vm = exec->vm();
+    if (propertyName == vm.propertyNames->underscoreProto) {
+        Base::put(cell, exec, propertyName, value, slot);
+        return;
+    }
+
     ProxyObject* thisObject = jsCast<ProxyObject*>(cell);
     auto performDefaultPut = [&] () {
         JSObject* target = jsCast<JSObject*>(thisObject->target());
@@ -955,6 +960,66 @@
     RELEASE_ASSERT_NOT_REACHED();
 }
 
+bool ProxyObject::performSetPrototype(ExecState* exec, JSValue prototype, bool shouldThrowIfCantSet)
+{
+    ASSERT(prototype.isObject() || prototype.isNull());
+
+    VM& vm = exec->vm();
+
+    JSValue handlerValue = this->handler();
+    if (handlerValue.isNull()) {
+        throwVMTypeError(exec, ASCIILiteral("Proxy 'handler' is null. It should be an Object."));
+        return false;
+    }
+
+    JSObject* handler = jsCast<JSObject*>(handlerValue);
+    CallData callData;
+    CallType callType;
+    JSValue setPrototypeOfMethod = handler->getMethod(exec, callData, callType, makeIdentifier(vm, "setPrototypeOf"), ASCIILiteral("'setPrototypeOf' property of a Proxy's handler should be callable."));
+    if (vm.exception())
+        return false;
+
+    JSObject* target = this->target();
+    if (setPrototypeOfMethod.isUndefined())
+        return target->setPrototype(vm, exec, prototype, shouldThrowIfCantSet);
+
+    MarkedArgumentBuffer arguments;
+    arguments.append(target);
+    arguments.append(prototype);
+    JSValue trapResult = call(exec, setPrototypeOfMethod, callType, callData, handler, arguments);
+    if (vm.exception())
+        return false;
+
+    bool trapResultAsBool = trapResult.toBoolean(exec);
+    if (vm.exception())
+        return false;
+    
+    if (!trapResultAsBool) {
+        if (shouldThrowIfCantSet)
+            throwVMTypeError(exec, ASCIILiteral("Proxy 'setPrototypeOf' returned false indicating it could not set the prototype value. The operation was expected to succeed."));
+        return false;
+    }
+
+    bool targetIsExtensible = target->isExtensible(exec);
+    if (vm.exception())
+        return false;
+    if (targetIsExtensible)
+        return true;
+
+    JSValue targetPrototype = target->prototype();
+    if (!sameValue(exec, prototype, targetPrototype)) {
+        throwVMTypeError(exec, ASCIILiteral("Proxy 'setPrototypeOf' trap returned true when its target is non-extensible and the new prototype value is not the same as the current prototype value. It should have returned false."));
+        return false;
+    }
+
+    return true;
+}
+
+bool ProxyObject::setPrototype(JSObject* object, ExecState* exec, JSValue prototype, bool shouldThrowIfCantSet)
+{
+    return jsCast<ProxyObject*>(object)->performSetPrototype(exec, prototype, shouldThrowIfCantSet);
+}
+
 void ProxyObject::visitChildren(JSCell* cell, SlotVisitor& visitor)
 {
     ProxyObject* thisObject = jsCast<ProxyObject*>(cell);

Modified: trunk/Source/_javascript_Core/runtime/ProxyObject.h (197543 => 197544)


--- trunk/Source/_javascript_Core/runtime/ProxyObject.h	2016-03-04 03:19:11 UTC (rev 197543)
+++ trunk/Source/_javascript_Core/runtime/ProxyObject.h	2016-03-04 03:43:06 UTC (rev 197544)
@@ -83,6 +83,7 @@
     static NO_RETURN_DUE_TO_CRASH void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
     static NO_RETURN_DUE_TO_CRASH void getStructurePropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
     static NO_RETURN_DUE_TO_CRASH void getGenericPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+    static bool setPrototype(JSObject*, ExecState*, JSValue prototype, bool shouldThrowIfCantSet);
     static void visitChildren(JSCell*, SlotVisitor&);
 
     bool getOwnPropertySlotCommon(ExecState*, PropertyName, PropertySlot&);
@@ -96,6 +97,7 @@
     bool performIsExtensible(ExecState*);
     bool performDefineOwnProperty(ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow);
     void performGetOwnPropertyNames(ExecState*, PropertyNameArray&, EnumerationMode);
+    bool performSetPrototype(ExecState*, JSValue prototype, bool shouldThrowIfCantSet);
 
     WriteBarrier<JSObject> m_target;
     WriteBarrier<Unknown> m_handler;

Modified: trunk/Source/_javascript_Core/tests/es6.yaml (197543 => 197544)


--- trunk/Source/_javascript_Core/tests/es6.yaml	2016-03-04 03:19:11 UTC (rev 197543)
+++ trunk/Source/_javascript_Core/tests/es6.yaml	2016-03-04 03:43:06 UTC (rev 197544)
@@ -719,9 +719,9 @@
 - path: es6/Array_is_subclassable_Array.prototype.concat.js
   cmd: runES6 :normal
 - path: es6/Array_is_subclassable_Array.prototype.filter.js
-  cmd: runES6 :fail
+  cmd: runES6 :normal
 - path: es6/Array_is_subclassable_Array.prototype.map.js
-  cmd: runES6 :fail
+  cmd: runES6 :normal
 - path: es6/Array_is_subclassable_Array.prototype.slice.js
   cmd: runES6 :normal
 - path: es6/Array_is_subclassable_Array.prototype.splice.js
@@ -1069,7 +1069,7 @@
 - path: es6/Proxy_set_handler_instances_of_proxies.js
   cmd: runES6 :normal
 - path: es6/Proxy_setPrototypeOf_handler.js
-  cmd: runES6 :fail
+  cmd: runES6 :normal
 - path: es6/Reflect_Reflect.construct.js
   cmd: runES6 :fail
 - path: es6/Reflect_Reflect.construct_creates_instance_from_newTarget_argument.js
@@ -1197,9 +1197,9 @@
 - path: es6/well-known_symbols_Symbol.species_Array.prototype.concat.js
   cmd: runES6 :normal
 - path: es6/well-known_symbols_Symbol.species_Array.prototype.filter.js
-  cmd: runES6 :fail
+  cmd: runES6 :normal
 - path: es6/well-known_symbols_Symbol.species_Array.prototype.map.js
-  cmd: runES6 :fail
+  cmd: runES6 :normal
 - path: es6/well-known_symbols_Symbol.species_Array.prototype.slice.js
   cmd: runES6 :normal
 - path: es6/well-known_symbols_Symbol.species_Array.prototype.splice.js

Added: trunk/Source/_javascript_Core/tests/stress/proxy-set-prototype-of.js (0 => 197544)


--- trunk/Source/_javascript_Core/tests/stress/proxy-set-prototype-of.js	                        (rev 0)
+++ trunk/Source/_javascript_Core/tests/stress/proxy-set-prototype-of.js	2016-03-04 03:43:06 UTC (rev 197544)
@@ -0,0 +1,416 @@
+function assert(b) {
+    if (!b)
+        throw new Error("Bad assertion!");
+}
+
+{
+    let target = {};
+    let error = null;
+    let handler = {
+        get setPrototypeOf() {
+            error = new Error;
+            throw error;
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let setters = [
+            () => Reflect.setPrototypeOf(proxy, {}),
+            () => Object.setPrototypeOf(proxy, {}),
+            () => proxy.__proto__ = {},
+        ];
+        for (let set of setters) {
+            let threw = false;
+            try {
+                set();
+            } catch(e) {
+                assert(e === error);
+                threw = true;
+            }
+            assert(threw);
+        }
+    }
+}
+
+{
+    let target = {};
+    let error = null;
+    let handler = {
+        setPrototypeOf: function() {
+            error = new Error;
+            throw error;
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let setters = [
+            () => Reflect.setPrototypeOf(proxy, {}),
+            () => Object.setPrototypeOf(proxy, {}),
+            () => proxy.__proto__ = {},
+        ];
+        for (let set of setters) {
+            let threw = false;
+            try {
+                set();
+            } catch(e) {
+                assert(e === error);
+                threw = true;
+            }
+            assert(threw);
+        }
+    }
+}
+
+{
+    let target = {};
+    let error = null;
+    let handler = {
+        setPrototypeOf: 25
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let setters = [
+            () => Reflect.setPrototypeOf(proxy, {}),
+            () => Object.setPrototypeOf(proxy, {}),
+            () => proxy.__proto__ = {},
+        ];
+        for (let set of setters) {
+            let threw = false;
+            try {
+                set();
+            } catch(e) {
+                assert(e.toString() === "TypeError: 'setPrototypeOf' property of a Proxy's handler should be callable.");
+                threw = true;
+            }
+            assert(threw);
+        }
+    }
+}
+
+{
+    let target = {};
+    target.__proto__ = null;
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            return true;
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let setters = [
+            () => Reflect.setPrototypeOf(proxy, {}),
+            () => Object.setPrototypeOf(proxy, {}),
+            () => proxy.__proto__ = {},
+        ];
+        for (let set of setters) {
+            let result = set();
+            assert(result);
+            assert(Reflect.getPrototypeOf(target) === null);
+            // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+            //assert(Reflect.getPrototypeOf(proxy) === null);
+            //assert(proxy.__proto__ === null);
+        }
+    }
+}
+
+{
+    let target = {};
+    target.__proto__ = null;
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            assert(theTarget === target);
+            return Reflect.setPrototypeOf(theTarget, value);
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let obj = {};
+        let setters = [
+            () => Reflect.setPrototypeOf(proxy, obj),
+            () => Object.setPrototypeOf(proxy, obj),
+            () => proxy.__proto__ = obj,
+        ];
+        for (let set of setters) {
+            let result = set();
+            assert(result);
+            assert(Reflect.getPrototypeOf(target) === obj);
+            // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+            //assert(Reflect.getPrototypeOf(proxy) === obj);
+            //assert(proxy.__proto__ === obj);
+        }
+    }
+}
+
+{
+    let target = {};
+    target.__proto__ = null;
+    Reflect.preventExtensions(target);
+    let called = false;
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            called = true;
+            assert(theTarget === target);
+            assert(value !== null);
+            Reflect.setPrototypeOf(theTarget, value);
+            return true;
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let obj = {};
+        let setters = [
+            () => Reflect.setPrototypeOf(proxy, obj),
+            () => Object.setPrototypeOf(proxy, obj),
+            () => proxy.__proto__ = obj,
+        ];
+        for (let set of setters) {
+            let threw = false;
+            try {
+                set();
+            } catch(e) {
+                threw = true;
+                assert(called);
+                called = false;
+                assert(e.toString() === "TypeError: Proxy 'setPrototypeOf' trap returned true when its target is non-extensible and the new prototype value is not the same as the current prototype value. It should have returned false.");
+            }
+
+            assert(threw);
+            assert(Reflect.getPrototypeOf(target) === null);
+            // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+            //assert(Reflect.getPrototypeOf(proxy) === null);
+            //assert(proxy.__proto__ === null);
+        }
+    }
+}
+
+{
+    let target = {};
+    target.__proto__ = null;
+    Reflect.preventExtensions(target);
+    let called = false;
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            called = true;
+            assert(theTarget === target);
+            assert(value === null);
+            return Reflect.setPrototypeOf(theTarget, value);
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let proto = null;
+        let setters = [
+            [() => Reflect.setPrototypeOf(proxy, null), true],
+            [() => Object.setPrototypeOf(proxy, null), proxy],
+            [() => proxy.__proto__ = null, null]
+        ];
+        for (let [set, expectedResult] of setters) {
+            let result = set();
+            assert(result === expectedResult);
+            assert(called);
+            called = false;
+            assert(Reflect.getPrototypeOf(target) === null);
+            // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+            //assert(Reflect.getPrototypeOf(proxy) === null);
+            //assert(proxy.__proto__ === null);
+        }
+    }
+}
+
+{
+    let target = {};
+    let obj = {};
+    target.__proto__ = obj;
+    Reflect.preventExtensions(target);
+    let called = false;
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            called = true;
+            assert(theTarget === target);
+            assert(value === obj);
+            return Reflect.setPrototypeOf(theTarget, value);
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let proto = null;
+        let setters = [
+            [() => Reflect.setPrototypeOf(proxy, obj), true],
+            [() => Object.setPrototypeOf(proxy, obj), proxy],
+            [() => proxy.__proto__ = obj, obj]
+        ];
+        for (let [set, expectedResult] of setters) {
+            let result = set();
+            assert(result === expectedResult);
+            assert(called);
+            called = false;
+            assert(Reflect.getPrototypeOf(target) === obj);
+            // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+            //assert(Reflect.getPrototypeOf(proxy) === null);
+            //assert(proxy.__proto__ === null);
+        }
+    }
+}
+
+{
+    let target = {};
+    target.__proto__ = null;
+    Reflect.preventExtensions(target);
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            return Reflect.setPrototypeOf(theTarget, value);
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let obj = {};
+        let threw = false;
+        try {
+            Object.setPrototypeOf(proxy, obj);
+        } catch(e) {
+            threw = true;
+            assert(e.toString() === "TypeError: Proxy 'setPrototypeOf' returned false indicating it could not set the prototype value. The operation was expected to succeed.");
+        }
+
+        assert(threw);
+        assert(Reflect.getPrototypeOf(target) === null);
+        // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+        //assert(Reflect.getPrototypeOf(proxy) === null);
+        //assert(proxy.__proto__ === null);
+    }
+}
+
+{
+    let target = {};
+    target.__proto__ = null;
+    Reflect.preventExtensions(target);
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            return Reflect.setPrototypeOf(theTarget, value);
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let obj = {};
+        let threw = false;
+        try {
+            proxy.__proto__ = obj;
+        } catch(e) {
+            threw = true;
+            assert(e.toString() === "TypeError: Proxy 'setPrototypeOf' returned false indicating it could not set the prototype value. The operation was expected to succeed.");
+        }
+
+        assert(threw);
+        assert(Reflect.getPrototypeOf(target) === null);
+        // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+        //assert(Reflect.getPrototypeOf(proxy) === null);
+        //assert(proxy.__proto__ === null);
+    }
+}
+
+{
+    let target = {};
+    target.__proto__ = null;
+    Reflect.preventExtensions(target);
+
+    let called = false;
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            called = true;
+            return Reflect.setPrototypeOf(theTarget, value);
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let result = Reflect.setPrototypeOf(proxy, {});
+        assert(!result);
+        assert(Reflect.getPrototypeOf(target) === null);
+
+        assert(called);
+        called = false;
+        // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+        //assert(Reflect.getPrototypeOf(proxy) === null);
+        //assert(proxy.__proto__ === null);
+    }
+}
+
+{
+    let target = {};
+    target.__proto__ = null;
+    Reflect.preventExtensions(target);
+
+    let called = false;
+    let handler = {
+        setPrototypeOf: function(theTarget, value) {
+            called = true;
+            return Reflect.setPrototypeOf(theTarget, value);
+        }
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let result = Reflect.setPrototypeOf(proxy, null);
+        assert(result);
+        assert(Reflect.getPrototypeOf(target) === null);
+        assert(called);
+        called = false;
+
+        // FIXME: when we implement Proxy.[[GetPrototypeOf]] this should work.
+        //assert(Reflect.getPrototypeOf(proxy) === null);
+        //assert(proxy.__proto__ === null);
+    }
+}
+
+{
+    let target = {};
+    let handler = {
+        setPrototypeOf: null
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let obj = {};
+        let result = Reflect.setPrototypeOf(proxy, obj);
+        assert(result);
+        assert(Reflect.getPrototypeOf(target) === obj);
+    }
+}
+
+{
+    let target = {};
+    let handler = {
+        setPrototypeOf: undefined
+    };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let obj = {};
+        let result = Reflect.setPrototypeOf(proxy, obj);
+        assert(result);
+        assert(Reflect.getPrototypeOf(target) === obj);
+    }
+}
+
+{
+    let target = {};
+    let handler = { };
+    
+    let proxy = new Proxy(target, handler);
+    for (let i = 0; i < 500; i++) {
+        let obj = {};
+        let result = Reflect.setPrototypeOf(proxy, obj);
+        assert(result);
+        assert(Reflect.getPrototypeOf(target) === obj);
+    }
+}
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to