Changeset 167199 in webkit for trunk/Source/JavaScriptCore/runtime/JSFunction.cpp

Timestamp:

Apr 13, 2014, 11:01:54 AM (11 years ago)

Author:

[email protected]

Message:

Rewrite Function.bind as a builtin
​https://bugs.webkit.org/show_bug.cgi?id=131083

Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

This change removes the existing function.bind implementation
entirely so JSBoundFunction is no more.

Instead we just return a regular JS closure with a few
private properties hanging off it that allow us to perform
the necessary bound function fakery. While most of this is
simple, a couple of key changes:

• The parser and lexer now directly track whether they're parsing code for call or construct and convert the private name @IsConstructor into TRUETOK or FALSETOK as appropriate. This automatically gives us the ability to vary behaviour from within the builtin. It also leaves a lot of headroom for trivial future improvements.
• The instanceof operator now uses the prototypeForHasInstance private name, and we have a helper function to ensure that all objects that need to can update their magical 'prototype' property pair correctly.

• API/JSScriptRef.cpp:

(parseScript):

• JavaScriptCore.xcodeproj/project.pbxproj:
• builtins/BuiltinExecutables.cpp:

(JSC::BuiltinExecutables::createBuiltinExecutable):

• builtins/Function.prototype.js:

(bind.bindingFunction):
(bind.else.bindingFunction):
(bind):

• bytecode/UnlinkedCodeBlock.cpp:

(JSC::generateFunctionCodeBlock):

• bytecompiler/NodesCodegen.cpp:

(JSC::InstanceOfNode::emitBytecode):

• interpreter/Interpreter.cpp:
• parser/Lexer.cpp:

(JSC::Lexer<T>::Lexer):
(JSC::Lexer<LChar>::parseIdentifier):
(JSC::Lexer<UChar>::parseIdentifier):

• parser/Lexer.h:
• parser/Parser.cpp:

(JSC::Parser<LexerType>::Parser):
(JSC::Parser<LexerType>::parseInner):

• parser/Parser.h:

(JSC::parse):

• parser/ParserModes.h:
• runtime/CodeCache.cpp:

(JSC::CodeCache::getGlobalCodeBlock):
(JSC::CodeCache::getFunctionExecutableFromGlobalCode):

• runtime/CommonIdentifiers.h:
• runtime/Completion.cpp:

(JSC::checkSyntax):

• runtime/Executable.cpp:

(JSC::ProgramExecutable::checkSyntax):

• runtime/FunctionPrototype.cpp:

(JSC::FunctionPrototype::addFunctionProperties):
(JSC::functionProtoFuncBind): Deleted.

• runtime/JSBoundFunction.cpp: Removed.
• runtime/JSBoundFunction.h: Removed.
• runtime/JSFunction.cpp:

(JSC::RetrieveCallerFunctionFunctor::RetrieveCallerFunctionFunctor):
(JSC::RetrieveCallerFunctionFunctor::operator()):
(JSC::retrieveCallerFunction):
(JSC::JSFunction::getOwnPropertySlot):
(JSC::JSFunction::defineOwnProperty):

• runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::reset):

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncSetTypeErrorAccessor):

• runtime/JSGlobalObjectFunctions.h:
• runtime/JSObject.h:

(JSC::JSObject::inlineGetOwnPropertySlot):

Source/WebCore:

Switch WebCore to use the helper functions when defining the
prototype properties on DOM constructors, and update bindings
tests accordingly.

• bindings/js/JSImageConstructor.cpp:

(WebCore::JSImageConstructor::finishCreation):

• bindings/scripts/CodeGeneratorJS.pm:

(GenerateConstructorHelperMethods):

• bindings/scripts/test/JS/JSTestActiveDOMObject.cpp:

(WebCore::JSTestActiveDOMObjectConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestCustomNamedGetter.cpp:

(WebCore::JSTestCustomNamedGetterConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestEventConstructor.cpp:

(WebCore::JSTestEventConstructorConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestEventTarget.cpp:

(WebCore::JSTestEventTargetConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestException.cpp:

(WebCore::JSTestExceptionConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp:

(WebCore::JSTestGenerateIsReachableConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestInterface.cpp:

(WebCore::JSTestInterfaceConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp:

(WebCore::JSTestMediaQueryListListenerConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestNamedConstructor.cpp:

(WebCore::JSTestNamedConstructorConstructor::finishCreation):
(WebCore::JSTestNamedConstructorNamedConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestNode.cpp:

(WebCore::JSTestNodeConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestObj.cpp:

(WebCore::JSTestObjConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp:

(WebCore::JSTestOverloadedConstructorsConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp:

(WebCore::JSTestSerializedScriptValueInterfaceConstructor::finishCreation):

• bindings/scripts/test/JS/JSTestTypedefs.cpp:

(WebCore::JSTestTypedefsConstructor::finishCreation):

• bindings/scripts/test/JS/JSattribute.cpp:

(WebCore::JSattributeConstructor::finishCreation):

• bindings/scripts/test/JS/JSreadonly.cpp:

(WebCore::JSreadonlyConstructor::finishCreation):

LayoutTests:

Testing.

• js/dom/function-bind-expected.txt:
• js/regress/function-bind-expected.txt: Added.
• js/regress/function-bind.html: Added.
• js/regress/script-tests/function-bind.js: Added.

(foo):

File:

• trunk/Source/JavaScriptCore/runtime/JSFunction.cpp (modified) (10 diffs)

trunk/Source/JavaScriptCore/runtime/JSFunction.cpp

@@ -34 +34 @@
 #include "GetterSetter.h"
 #include "JSArray.h"
-#include "JSBoundFunction.h"
 #include "JSFunctionInlines.h"
 #include "JSGlobalObject.h"
@@ -252 +251 @@
 class RetrieveCallerFunctionFunctor {
 public:
-    RetrieveCallerFunctionFunctor(JSFunction* functionObj)
-        : m_targetCallee(jsDynamicCast<JSObject*>(functionObj))
+    RetrieveCallerFunctionFunctor(ExecState* exec, JSFunction* functionObj)
+        : m_exec(exec)
+        , m_targetCallee(jsDynamicCast<JSObject*>(functionObj))
         , m_hasFoundFrame(false)
         , m_hasSkippedToCallerFrame(false)
@@ -266 +266 @@
         JSObject* callee = visitor->callee();
 
-        if (callee && callee->inherits(JSBoundFunction::info()))
+        if (callee && callee->hasOwnProperty(m_exec, m_exec->propertyNames().boundFunctionNamePrivateName))
             return StackVisitor::Continue;
 
@@ -284 +284 @@
 
 private:
+    ExecState* m_exec;
     JSObject* m_targetCallee;
     bool m_hasFoundFrame;
@@ -292 +293 @@
 static JSValue retrieveCallerFunction(ExecState* exec, JSFunction* functionObj)
 {
-    RetrieveCallerFunctionFunctor functor(functionObj);
+    RetrieveCallerFunctionFunctor functor(exec, functionObj);
     exec->iterate(functor);
     return functor.result();
@@ -329 +330 @@
 {
     JSFunction* thisObject = jsCast<JSFunction*>(object);
-    if (thisObject->isHostOrBuiltinFunction())
+    if (thisObject->isHostFunction())
         return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
-
-    if (propertyName == exec->propertyNames().prototype) {
+    if (thisObject->isBuiltinFunction()) {
+        if (propertyName == exec->propertyNames().caller) {
+            if (thisObject->jsExecutable()->isStrictMode()) {
+                bool result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
+                if (!result) {
+                    thisObject->putDirectAccessor(exec, propertyName, thisObject->globalObject()->throwTypeErrorGetterSetter(exec->vm()), DontDelete | DontEnum | Accessor);
+                    result = Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
+                    ASSERT(result);
+                }
+                return result;
+            }
+            slot.setCacheableCustom(thisObject, ReadOnly | DontEnum | DontDelete, callerGetter);
+            return true;
+        }
+        if (propertyName == exec->propertyNames().prototypeForHasInstancePrivateName) {
+            PropertySlot boundFunctionSlot(thisObject);
+            if (Base::getOwnPropertySlot(thisObject, exec, exec->propertyNames().boundFunctionPrivateName, boundFunctionSlot)) {
+                JSValue boundFunction = boundFunctionSlot.getValue(exec, exec->propertyNames().boundFunctionPrivateName);
+                PropertySlot boundPrototypeSlot(asObject(boundFunction));
+                if (asObject(boundFunction)->getPropertySlot(exec, propertyName, boundPrototypeSlot)) {
+                    slot.setValue(boundPrototypeSlot.slotBase(), boundPrototypeSlot.attributes(), boundPrototypeSlot.getValue(exec, propertyName));
+                    return true;
+                }
+            }
+        }
+        if (propertyName == exec->propertyNames().name) {
+            PropertySlot nameSlot(thisObject);
+            if (Base::getOwnPropertySlot(thisObject, exec, exec->vm().propertyNames->boundFunctionNamePrivateName, nameSlot)) {
+                slot.setValue(thisObject, DontEnum | DontDelete | ReadOnly, nameSlot.getValue(exec, exec->vm().propertyNames->boundFunctionNamePrivateName));
+                return true;
+            }
+        }
+        if (propertyName == exec->propertyNames().length) {
+            PropertySlot lengthSlot(thisObject);
+            if (Base::getOwnPropertySlot(thisObject, exec, exec->vm().propertyNames->boundFunctionLengthPrivateName, lengthSlot)) {
+                slot.setValue(thisObject, DontEnum | DontDelete | ReadOnly, lengthSlot.getValue(exec, exec->vm().propertyNames->boundFunctionLengthPrivateName));
+                return true;
+            }
+        }
+            
+        return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
+    }
+    
+    if (propertyName == exec->propertyNames().prototype || propertyName == exec->propertyNames().prototypeForHasInstancePrivateName) {
         VM& vm = exec->vm();
         unsigned attributes;
@@ -339 +382 @@
             JSObject* prototype = constructEmptyObject(exec);
             prototype->putDirect(vm, exec->propertyNames().constructor, thisObject, DontEnum);
-            thisObject->putDirect(vm, exec->propertyNames().prototype, prototype, DontDelete | DontEnum);
+            thisObject->putDirectPrototypeProperty(vm, prototype, DontDelete | DontEnum);
             offset = thisObject->getDirectOffset(vm, exec->propertyNames().prototype, attributes);
             ASSERT(isValidOffset(offset));
@@ -391 +434 @@
 {
     JSFunction* thisObject = jsCast<JSFunction*>(object);
-    if (!thisObject->isHostOrBuiltinFunction() && (mode == IncludeDontEnumProperties)) {
-        VM& vm = exec->vm();
-        // Make sure prototype has been reified.
-        PropertySlot slot(thisObject);
-        thisObject->methodTable(vm)->getOwnPropertySlot(thisObject, exec, vm.propertyNames->prototype, slot);
-
-        propertyNames.add(vm.propertyNames->arguments);
-        propertyNames.add(vm.propertyNames->caller);
-        propertyNames.add(vm.propertyNames->length);
-        propertyNames.add(vm.propertyNames->name);
+    if (mode == IncludeDontEnumProperties) {
+        bool shouldIncludeJSFunctionProperties = !thisObject->isHostOrBuiltinFunction();
+        if (!shouldIncludeJSFunctionProperties && thisObject->isBuiltinFunction()) {
+            PropertySlot boundFunctionSlot(thisObject);
+            shouldIncludeJSFunctionProperties = Base::getOwnPropertySlot(thisObject, exec, exec->propertyNames().boundFunctionPrivateName, boundFunctionSlot);
+        }
+        if (shouldIncludeJSFunctionProperties) {
+            VM& vm = exec->vm();
+            // Make sure prototype has been reified.
+            PropertySlot slot(thisObject);
+            thisObject->methodTable(vm)->getOwnPropertySlot(thisObject, exec, vm.propertyNames->prototype, slot);
+
+            propertyNames.add(vm.propertyNames->arguments);
+            propertyNames.add(vm.propertyNames->caller);
+            propertyNames.add(vm.propertyNames->length);
+            propertyNames.add(vm.propertyNames->name);
+        }
     }
     Base::getOwnNonIndexPropertyNames(thisObject, exec, propertyNames, mode);
@@ -420 +470 @@
         thisObject->m_allocationProfileWatchpoint.fireAll();
         // Don't allow this to be cached, since a [[Put]] must clear m_allocationProfile.
-        PutPropertySlot dontCache(thisObject);
-        Base::put(thisObject, exec, propertyName, value, dontCache);
+        PutPropertySlot dontCachePrototype(thisObject);
+        Base::put(thisObject, exec, propertyName, value, dontCachePrototype);
+        PutPropertySlot dontCachePrototypeForHasInstance(thisObject);
+        Base::put(thisObject, exec, exec->propertyNames().prototypeForHasInstancePrivateName, value, dontCachePrototypeForHasInstance);
         return;
     }
@@ -466 +518 @@
         thisObject->m_allocationProfile.clear();
         thisObject->m_allocationProfileWatchpoint.fireAll();
-        return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException);
+        if (!Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException))
+            return false;
+        Base::defineOwnProperty(object, exec, exec->propertyNames().prototypeForHasInstancePrivateName, descriptor, throwException);
+        return true;
     }