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);
+ }
+}