Changeset 197136 in webkit for trunk/Source/JavaScriptCore/runtime/ProxyObject.cpp

Timestamp:

Feb 25, 2016, 2:58:23 PM (9 years ago)

Author:

[email protected]

Message:

[ES6] Implement Proxy.Set
​https://bugs.webkit.org/show_bug.cgi?id=154511

Reviewed by Filip Pizlo.

This patch is mostly an implementation of
Proxy.Set with respect to section 9.5.9
of the ECMAScript spec.
​https://tc39.github.io/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-set-p-v-receiver

This patch also changes JSObject::putInline and JSObject::putByIndex
to be aware that a Proxy in the prototype chain will intercept
property accesses.

• runtime/JSObject.cpp:

(JSC::JSObject::putInlineSlow):
(JSC::JSObject::attemptToInterceptPutByIndexOnHoleForPrototype):

• runtime/JSObject.h:
• runtime/JSObjectInlines.h:

(JSC::JSObject::canPerformFastPutInline):
(JSC::JSObject::putInline):

• runtime/JSType.h:
• runtime/ProxyObject.cpp:

(JSC::ProxyObject::getOwnPropertySlotByIndex):
(JSC::ProxyObject::performPut):
(JSC::ProxyObject::put):
(JSC::ProxyObject::putByIndexCommon):
(JSC::ProxyObject::putByIndex):
(JSC::performProxyCall):
(JSC::ProxyObject::getCallData):
(JSC::performProxyConstruct):
(JSC::ProxyObject::deletePropertyByIndex):
(JSC::ProxyObject::visitChildren):

• runtime/ProxyObject.h:

(JSC::ProxyObject::create):
(JSC::ProxyObject::createStructure):
(JSC::ProxyObject::target):
(JSC::ProxyObject::handler):

• tests/es6.yaml:
• tests/stress/proxy-set.js: Added.

(assert):
(throw.new.Error.let.handler.set 45):
(throw.new.Error):
(let.target.set x):
(let.target.get x):
(set let):

File:

• trunk/Source/JavaScriptCore/runtime/ProxyObject.cpp (modified) (3 diffs)

trunk/Source/JavaScriptCore/runtime/ProxyObject.cpp

@@ -301 +301 @@
 }
 
+template <typename PerformDefaultPutFunction>
+void ProxyObject::performPut(ExecState* exec, JSValue putValue, JSValue thisValue, PropertyName propertyName, PerformDefaultPutFunction performDefaultPutFunction)
+{
+    VM& vm = exec->vm();
+    JSValue handlerValue = this->handler();
+    if (handlerValue.isNull()) {
+        throwVMTypeError(exec, ASCIILiteral("Proxy 'handler' is null. It should be an Object."));
+        return;
+    }
+
+    JSObject* handler = jsCast<JSObject*>(handlerValue);
+    CallData callData;
+    CallType callType;
+    JSValue setMethod = handler->getMethod(exec, callData, callType, vm.propertyNames->set, ASCIILiteral("'set' property of a Proxy's handler should be callable."));
+    if (exec->hadException())
+        return;
+    JSObject* target = this->target();
+    if (setMethod.isUndefined()) {
+        performDefaultPutFunction();
+        return;
+    }
+
+    MarkedArgumentBuffer arguments;
+    arguments.append(target);
+    arguments.append(identifierToSafePublicJSValue(vm, Identifier::fromUid(&vm, propertyName.uid())));
+    arguments.append(putValue);
+    arguments.append(thisValue);
+    JSValue trapResult = call(exec, setMethod, callType, callData, handler, arguments);
+    if (exec->hadException())
+        return;
+    bool trapResultAsBool = trapResult.toBoolean(exec);
+    if (exec->hadException())
+        return;
+    if (!trapResultAsBool)
+        return;
+
+    PropertyDescriptor descriptor;
+    if (target->getOwnPropertyDescriptor(exec, propertyName, descriptor)) {
+        if (descriptor.isDataDescriptor() && !descriptor.configurable() && !descriptor.writable()) {
+            if (!sameValue(exec, descriptor.value(), putValue)) {
+                throwVMTypeError(exec, ASCIILiteral("Proxy handler's 'set' on a non-configurable and non-writable property on 'target' should either return false or be the same value already on the 'target'."));
+                return;
+            }
+        } else if (descriptor.isAccessorDescriptor() && !descriptor.configurable() && descriptor.setter().isUndefined()) {
+            throwVMTypeError(exec, ASCIILiteral("Proxy handler's 'set' method on a non-configurable accessor property without a setter should return false."));
+            return;
+        }
+    }
+}
+
+void ProxyObject::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
+{
+    VM& vm = exec->vm();
+    ProxyObject* thisObject = jsCast<ProxyObject*>(cell);
+    auto performDefaultPut = [&] () {
+        JSObject* target = jsCast<JSObject*>(thisObject->target());
+        target->methodTable(vm)->put(target, exec, propertyName, value, slot);
+    };
+    thisObject->performPut(exec, value, slot.thisValue(), propertyName, performDefaultPut);
+}
+
+void ProxyObject::putByIndexCommon(ExecState* exec, JSValue thisValue, unsigned propertyName, JSValue putValue, bool shouldThrow)
+{
+    VM& vm = exec->vm();
+    Identifier ident = Identifier::from(exec, propertyName); 
+    if (exec->hadException())
+        return;
+    auto performDefaultPut = [&] () {
+        JSObject* target = this->target();
+        bool isStrictMode = shouldThrow;
+        PutPropertySlot slot(thisValue, isStrictMode); // We must preserve the "this" target of the putByIndex.
+        target->methodTable(vm)->put(target, exec, ident.impl(), putValue, slot);
+    };
+    performPut(exec, putValue, thisValue, ident.impl(), performDefaultPut);
+}
+
+void ProxyObject::putByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow)
+{
+    ProxyObject* thisObject = jsCast<ProxyObject*>(cell);
+    thisObject->putByIndexCommon(exec, thisObject, propertyName, value, shouldThrow);
+}
+
 static EncodedJSValue JSC_HOST_CALL performProxyCall(ExecState* exec)
 {
@@ -346 +428 @@
 }
 
-void ProxyObject::visitChildren(JSCell* cell, SlotVisitor& visitor)
-{
-    ProxyObject* thisObject = jsCast<ProxyObject*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-
-    visitor.append(&thisObject->m_target);
-    visitor.append(&thisObject->m_handler);
-}
-
 static EncodedJSValue JSC_HOST_CALL performProxyConstruct(ExecState* exec)
 {
@@ -477 +549 @@
 }
 
+void ProxyObject::visitChildren(JSCell* cell, SlotVisitor& visitor)
+{
+    ProxyObject* thisObject = jsCast<ProxyObject*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+
+    visitor.append(&thisObject->m_target);
+    visitor.append(&thisObject->m_handler);
+}
+
 } // namespace JSC