[JSC] CallData/ConstructData should include CallType/ConstructType
authorross.kirsling@sony.com <ross.kirsling@sony.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 27 Apr 2020 09:09:32 +0000 (09:09 +0000)
committerross.kirsling@sony.com <ross.kirsling@sony.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 27 Apr 2020 09:09:32 +0000 (09:09 +0000)
https://bugs.webkit.org/show_bug.cgi?id=211059

Reviewed by Darin Adler.

Source/JavaScriptCore:

getCallData/getConstructData return a CallType/ConstructType and have a CallData/ConstructData out param,
and then *both* of these are passed side-by-side to `call`/`construct`, which all seems a bit silly.

This patch merges CallType/ConstructType into CallData/ConstructData such that getCallData/getConstructData
no longer need an out param and `call`/`construct` require one less overt parameter.

In so doing, it also:
- removes ConstructData entirely as it's an exact duplicate of CallData
- renames enum value Host to Native in alignment with CallData's union

* API/JSCallbackConstructor.cpp:
(JSC::JSCallbackConstructor::getConstructData):
* API/JSCallbackConstructor.h:
* API/JSCallbackObject.h:
* API/JSCallbackObjectFunctions.h:
(JSC::JSCallbackObject<Parent>::getConstructData):
(JSC::JSCallbackObject<Parent>::getCallData):
* API/JSObjectRef.cpp:
(JSObjectCallAsFunction):
(JSObjectCallAsConstructor):
* bindings/ScriptFunctionCall.cpp:
(Deprecated::ScriptFunctionCall::call):
* bindings/ScriptFunctionCall.h:
* dfg/DFGOperations.cpp:
* inspector/InjectedScriptManager.cpp:
(Inspector::InjectedScriptManager::createInjectedScript):
* inspector/InspectorEnvironment.h:
* interpreter/Interpreter.cpp:
(JSC::Interpreter::executeProgram):
(JSC::Interpreter::executeCall):
(JSC::Interpreter::executeConstruct):
* interpreter/Interpreter.h:
* jit/JITOperations.cpp:
* jsc.cpp:
(functionDollarAgentReceiveBroadcast):
* llint/LLIntSlowPaths.cpp:
(JSC::LLInt::handleHostCall):
* runtime/ArrayPrototype.cpp:
(JSC::arrayProtoFuncToString):
(JSC::arrayProtoFuncToLocaleString):
* runtime/CallData.cpp:
(JSC::call):
(JSC::profiledCall):
* runtime/CallData.h:
* runtime/ClassInfo.h:
* runtime/CommonSlowPaths.cpp:
(JSC::SLOW_PATH_DECL):
* runtime/ConstructData.cpp:
(JSC::construct):
(JSC::profiledConstruct):
* runtime/ConstructData.h:
(JSC::construct):
(JSC::profiledConstruct):
(): Deleted.
* runtime/DatePrototype.cpp:
(JSC::dateProtoFuncToJSON):
* runtime/GetterSetter.cpp:
(JSC::callGetter):
(JSC::callSetter):
* runtime/InternalFunction.cpp:
(JSC::InternalFunction::getCallData):
(JSC::InternalFunction::getConstructData):
* runtime/InternalFunction.h:
* runtime/IteratorOperations.cpp:
(JSC::iteratorNext):
(JSC::iteratorClose):
(JSC::hasIteratorMethod):
(JSC::iteratorMethod):
(JSC::iteratorForIterable):
* runtime/JSBoundFunction.cpp:
(JSC::boundThisNoArgsFunctionCall):
(JSC::boundFunctionCall):
(JSC::boundThisNoArgsFunctionConstruct):
(JSC::boundFunctionConstruct):
* runtime/JSCJSValue.h:
* runtime/JSCell.cpp:
(JSC::JSCell::getCallData):
(JSC::JSCell::getConstructData):
* runtime/JSCell.h:
* runtime/JSCellInlines.h:
(JSC::JSCell::isFunction):
(JSC::JSCell::isConstructor):
* runtime/JSFunction.cpp:
(JSC::JSFunction::getCallData):
(JSC::JSFunction::getConstructData):
* runtime/JSFunction.h:
* runtime/JSInternalPromise.cpp:
(JSC::JSInternalPromise::then):
* runtime/JSMicrotask.cpp:
(JSC::JSMicrotask::run):
* runtime/JSModuleLoader.cpp:
(JSC::JSModuleLoader::dependencyKeysIfEvaluated):
(JSC::JSModuleLoader::provideFetch):
(JSC::JSModuleLoader::loadAndEvaluateModule):
(JSC::JSModuleLoader::loadModule):
(JSC::JSModuleLoader::linkAndEvaluateModule):
(JSC::JSModuleLoader::requestImportModule):
* runtime/JSONObject.cpp:
(JSC::Stringifier::isCallableReplacer const):
(JSC::Stringifier::Stringifier):
(JSC::Stringifier::toJSON):
(JSC::Stringifier::appendStringifiedValue):
(JSC::Walker::Walker):
(JSC::Walker::callReviver):
(JSC::JSONProtoFuncParse):
* runtime/JSObject.cpp:
(JSC::ordinarySetSlow):
(JSC::callToPrimitiveFunction):
(JSC::JSObject::hasInstance):
(JSC::JSObject::getMethod):
* runtime/JSObject.h:
* runtime/JSObjectInlines.h:
(JSC::getCallData):
(JSC::getConstructData):
* runtime/JSPromise.cpp:
(JSC::JSPromise::createDeferredData):
(JSC::JSPromise::resolvedPromise):
(JSC::callFunction):
* runtime/MapConstructor.cpp:
(JSC::constructMap):
* runtime/ObjectPrototype.cpp:
(JSC::objectProtoFuncToLocaleString):
* runtime/ProxyObject.cpp:
(JSC::performProxyGet):
(JSC::ProxyObject::performInternalMethodGetOwnProperty):
(JSC::ProxyObject::performHasProperty):
(JSC::ProxyObject::performPut):
(JSC::performProxyCall):
(JSC::ProxyObject::getCallData):
(JSC::performProxyConstruct):
(JSC::ProxyObject::getConstructData):
(JSC::ProxyObject::performDelete):
(JSC::ProxyObject::performPreventExtensions):
(JSC::ProxyObject::performIsExtensible):
(JSC::ProxyObject::performDefineOwnProperty):
(JSC::ProxyObject::performGetOwnPropertyNames):
(JSC::ProxyObject::performSetPrototype):
(JSC::ProxyObject::performGetPrototype):
* runtime/ProxyObject.h:
* runtime/ReflectObject.cpp:
(JSC::reflectObjectConstruct):
* runtime/SamplingProfiler.cpp:
(JSC::SamplingProfiler::processUnverifiedStackTraces):
* runtime/SetConstructor.cpp:
(JSC::constructSet):
* runtime/StringPrototype.cpp:
(JSC::replaceUsingRegExpSearch):
(JSC::operationStringProtoFuncReplaceRegExpEmptyStr):
(JSC::operationStringProtoFuncReplaceRegExpString):
(JSC::replaceUsingStringSearch):
* runtime/VM.cpp:
(JSC::VM::callPromiseRejectionCallback):
* runtime/WeakMapConstructor.cpp:
(JSC::constructWeakMap):
* runtime/WeakSetConstructor.cpp:
(JSC::constructWeakSet):
* tools/JSDollarVM.cpp:
(JSC::callWithStackSizeProbeFunction):
* wasm/js/WebAssemblyModuleRecord.cpp:
(JSC::WebAssemblyModuleRecord::evaluate):
* wasm/js/WebAssemblyWrapperFunction.cpp:
(JSC::callWebAssemblyWrapperFunction):

Source/WebCore:

* Modules/plugins/QuickTimePluginReplacement.mm:
(WebCore::QuickTimePluginReplacement::installReplacement):
* bindings/js/JSCallbackData.cpp:
(WebCore::JSCallbackData::invokeCallback):
* bindings/js/JSCustomElementInterface.cpp:
(WebCore::constructCustomElementSynchronously):
(WebCore::JSCustomElementInterface::upgradeElement):
(WebCore::JSCustomElementInterface::invokeCallback):
* bindings/js/JSCustomXPathNSResolver.cpp:
(WebCore::JSCustomXPathNSResolver::lookupNamespaceURI):
* bindings/js/JSDOMBuiltinConstructor.h:
(WebCore::JSDOMBuiltinConstructor<JSClass>::getConstructData):
* bindings/js/JSDOMBuiltinConstructorBase.cpp:
(WebCore::JSDOMBuiltinConstructorBase::callFunctionWithCurrentArguments):
* bindings/js/JSDOMConstructor.h:
(WebCore::JSDOMConstructor<JSClass>::getConstructData):
* bindings/js/JSDOMConstructorBase.cpp:
(WebCore::JSDOMConstructorBase::getCallData):
* bindings/js/JSDOMConstructorBase.h:
* bindings/js/JSDOMConstructorNotConstructable.h:
* bindings/js/JSDOMIterator.h:
(WebCore::iteratorForEach):
* bindings/js/JSDOMMapLike.cpp:
(WebCore::clearBackingMap):
(WebCore::setToBackingMap):
(WebCore::forwardFunctionCallToBackingMap):
(WebCore::forwardForEachCallToBackingMap):
* bindings/js/JSDOMNamedConstructor.h:
(WebCore::JSDOMNamedConstructor<JSClass>::getConstructData):
* bindings/js/JSDOMPromise.cpp:
(WebCore::DOMPromise::whenPromiseIsSettled):
* bindings/js/JSDOMPromiseDeferred.cpp:
(WebCore::createRejectedPromiseWithTypeError):
* bindings/js/JSDOMSetLike.cpp:
(WebCore::clearBackingSet):
(WebCore::addToBackingSet):
(WebCore::forwardFunctionCallToBackingSet):
(WebCore::forwardForEachCallToBackingSet):
* bindings/js/JSErrorHandler.cpp:
(WebCore::JSErrorHandler::handleEvent):
* bindings/js/JSEventListener.cpp:
(WebCore::JSEventListener::handleEvent):
* bindings/js/JSExecState.cpp:
(WebCore::functionCallHandlerFromAnyThread):
* bindings/js/JSExecState.h:
(WebCore::JSExecState::call):
(WebCore::JSExecState::profiledCall):
* bindings/js/JSExecStateInstrumentation.h:
(WebCore::JSExecState::instrumentFunction):
(WebCore::JSExecState::instrumentFunctionInternal): Deleted.
(WebCore::JSExecState::instrumentFunctionCall): Deleted.
(WebCore::JSExecState::instrumentFunctionConstruct): Deleted.
* bindings/js/JSNavigatorCustom.cpp:
(WebCore::JSNavigator::getUserMedia):
* bindings/js/JSPluginElementFunctions.cpp:
(WebCore::callPlugin):
(WebCore::pluginElementCustomGetCallData):
* bindings/js/JSPluginElementFunctions.h:
* bindings/js/ReadableStream.cpp:
(WebCore::ReadableStream::create):
(WebCore::ReadableStreamInternal::callFunction):
(WebCore::ReadableStream::lock):
* bindings/js/ReadableStreamDefaultController.cpp:
(WebCore::readableStreamCallFunction):
* bindings/js/ScheduledAction.cpp:
(WebCore::ScheduledAction::executeFunctionInContext):
* bindings/js/ScriptController.cpp:
(WebCore::ScriptController::callInWorld):
(WebCore::ScriptController::executeAsynchronousUserAgentScriptInWorld):
* bindings/scripts/CodeGeneratorJS.pm:
(GenerateHeader):
(GeneratePluginCall):
(GenerateLegacyCallerDefinitions):
* bindings/scripts/test/JS/JSTestObj.cpp:
(WebCore::JSTestObj::getCallData):
* bindings/scripts/test/JS/JSTestObj.h:
* bindings/scripts/test/JS/JSTestPluginInterface.cpp:
(WebCore::JSTestPluginInterface::getCallData):
* bindings/scripts/test/JS/JSTestPluginInterface.h:
* bridge/NP_jsobject.cpp:
* bridge/objc/WebScriptObject.mm:
(-[WebScriptObject callWebScriptMethod:withArguments:]):
* bridge/objc/objc_runtime.h:
* bridge/objc/objc_runtime.mm:
(JSC::Bindings::ObjcFallbackObjectImp::getCallData):
* bridge/runtime_object.cpp:
(JSC::Bindings::RuntimeObject::getCallData):
(JSC::Bindings::RuntimeObject::getConstructData):
* bridge/runtime_object.h:
* html/HTMLMediaElement.cpp:
(WebCore::HTMLMediaElement::updateCaptionContainer):
(WebCore::HTMLMediaElement::didAddUserAgentShadowRoot):
(WebCore::HTMLMediaElement::updateMediaControlsAfterPresentationModeChange):
(WebCore::HTMLMediaElement::getCurrentMediaControlsStatus):
* html/HTMLPlugInImageElement.cpp:
(WebCore::HTMLPlugInImageElement::didAddUserAgentShadowRoot):
* testing/Internals.cpp:
(WebCore::Internals::cloneArrayBuffer):

Source/WebKit:

* WebProcess/Plugins/Netscape/JSNPObject.cpp:
(WebKit::JSNPObject::getCallData):
(WebKit::JSNPObject::getConstructData):
* WebProcess/Plugins/Netscape/JSNPObject.h:
* WebProcess/Plugins/Netscape/NPJSObject.cpp:
(WebKit::NPJSObject::hasMethod):
(WebKit::NPJSObject::construct):
(WebKit::NPJSObject::invoke):

Source/WebKitLegacy/mac:

* Plugins/Hosted/NetscapePluginInstanceProxy.mm:
(WebKit::NetscapePluginInstanceProxy::invoke):
(WebKit::NetscapePluginInstanceProxy::invokeDefault):
(WebKit::NetscapePluginInstanceProxy::construct):

Source/WebKitLegacy/win:

* Plugins/PluginPackage.cpp:
(WebCore::NPN_Invoke):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@260744 268f45cc-cd09-0410-ab3c-d52691b4dbfc

108 files changed:
Source/JavaScriptCore/API/JSCallbackConstructor.cpp
Source/JavaScriptCore/API/JSCallbackConstructor.h
Source/JavaScriptCore/API/JSCallbackObject.h
Source/JavaScriptCore/API/JSCallbackObjectFunctions.h
Source/JavaScriptCore/API/JSObjectRef.cpp
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/bindings/ScriptFunctionCall.cpp
Source/JavaScriptCore/bindings/ScriptFunctionCall.h
Source/JavaScriptCore/dfg/DFGOperations.cpp
Source/JavaScriptCore/inspector/InjectedScriptManager.cpp
Source/JavaScriptCore/inspector/InspectorEnvironment.h
Source/JavaScriptCore/interpreter/Interpreter.cpp
Source/JavaScriptCore/interpreter/Interpreter.h
Source/JavaScriptCore/jit/JITOperations.cpp
Source/JavaScriptCore/jsc.cpp
Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
Source/JavaScriptCore/runtime/ArrayPrototype.cpp
Source/JavaScriptCore/runtime/CallData.cpp
Source/JavaScriptCore/runtime/CallData.h
Source/JavaScriptCore/runtime/ClassInfo.h
Source/JavaScriptCore/runtime/CommonSlowPaths.cpp
Source/JavaScriptCore/runtime/ConstructData.cpp
Source/JavaScriptCore/runtime/ConstructData.h
Source/JavaScriptCore/runtime/DatePrototype.cpp
Source/JavaScriptCore/runtime/GetterSetter.cpp
Source/JavaScriptCore/runtime/InternalFunction.cpp
Source/JavaScriptCore/runtime/InternalFunction.h
Source/JavaScriptCore/runtime/IteratorOperations.cpp
Source/JavaScriptCore/runtime/JSBoundFunction.cpp
Source/JavaScriptCore/runtime/JSCJSValue.h
Source/JavaScriptCore/runtime/JSCell.cpp
Source/JavaScriptCore/runtime/JSCell.h
Source/JavaScriptCore/runtime/JSCellInlines.h
Source/JavaScriptCore/runtime/JSFunction.cpp
Source/JavaScriptCore/runtime/JSFunction.h
Source/JavaScriptCore/runtime/JSInternalPromise.cpp
Source/JavaScriptCore/runtime/JSMicrotask.cpp
Source/JavaScriptCore/runtime/JSModuleLoader.cpp
Source/JavaScriptCore/runtime/JSONObject.cpp
Source/JavaScriptCore/runtime/JSObject.cpp
Source/JavaScriptCore/runtime/JSObject.h
Source/JavaScriptCore/runtime/JSObjectInlines.h
Source/JavaScriptCore/runtime/JSPromise.cpp
Source/JavaScriptCore/runtime/MapConstructor.cpp
Source/JavaScriptCore/runtime/ObjectPrototype.cpp
Source/JavaScriptCore/runtime/ProxyObject.cpp
Source/JavaScriptCore/runtime/ProxyObject.h
Source/JavaScriptCore/runtime/ReflectObject.cpp
Source/JavaScriptCore/runtime/SamplingProfiler.cpp
Source/JavaScriptCore/runtime/SetConstructor.cpp
Source/JavaScriptCore/runtime/StringPrototype.cpp
Source/JavaScriptCore/runtime/VM.cpp
Source/JavaScriptCore/runtime/WeakMapConstructor.cpp
Source/JavaScriptCore/runtime/WeakSetConstructor.cpp
Source/JavaScriptCore/tools/JSDollarVM.cpp
Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp
Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.cpp
Source/WebCore/ChangeLog
Source/WebCore/Modules/plugins/QuickTimePluginReplacement.mm
Source/WebCore/bindings/js/JSCallbackData.cpp
Source/WebCore/bindings/js/JSCustomElementInterface.cpp
Source/WebCore/bindings/js/JSCustomXPathNSResolver.cpp
Source/WebCore/bindings/js/JSDOMBuiltinConstructor.h
Source/WebCore/bindings/js/JSDOMBuiltinConstructorBase.cpp
Source/WebCore/bindings/js/JSDOMConstructor.h
Source/WebCore/bindings/js/JSDOMConstructorBase.cpp
Source/WebCore/bindings/js/JSDOMConstructorBase.h
Source/WebCore/bindings/js/JSDOMConstructorNotConstructable.h
Source/WebCore/bindings/js/JSDOMIterator.h
Source/WebCore/bindings/js/JSDOMMapLike.cpp
Source/WebCore/bindings/js/JSDOMNamedConstructor.h
Source/WebCore/bindings/js/JSDOMPromise.cpp
Source/WebCore/bindings/js/JSDOMPromiseDeferred.cpp
Source/WebCore/bindings/js/JSDOMSetLike.cpp
Source/WebCore/bindings/js/JSErrorHandler.cpp
Source/WebCore/bindings/js/JSEventListener.cpp
Source/WebCore/bindings/js/JSExecState.cpp
Source/WebCore/bindings/js/JSExecState.h
Source/WebCore/bindings/js/JSExecStateInstrumentation.h
Source/WebCore/bindings/js/JSNavigatorCustom.cpp
Source/WebCore/bindings/js/JSPluginElementFunctions.cpp
Source/WebCore/bindings/js/JSPluginElementFunctions.h
Source/WebCore/bindings/js/ReadableStream.cpp
Source/WebCore/bindings/js/ReadableStreamDefaultController.cpp
Source/WebCore/bindings/js/ScheduledAction.cpp
Source/WebCore/bindings/js/ScriptController.cpp
Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestObj.h
Source/WebCore/bindings/scripts/test/JS/JSTestPluginInterface.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestPluginInterface.h
Source/WebCore/bridge/NP_jsobject.cpp
Source/WebCore/bridge/objc/WebScriptObject.mm
Source/WebCore/bridge/objc/objc_runtime.h
Source/WebCore/bridge/objc/objc_runtime.mm
Source/WebCore/bridge/runtime_object.cpp
Source/WebCore/bridge/runtime_object.h
Source/WebCore/html/HTMLMediaElement.cpp
Source/WebCore/html/HTMLPlugInImageElement.cpp
Source/WebCore/testing/Internals.cpp
Source/WebKit/ChangeLog
Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.cpp
Source/WebKit/WebProcess/Plugins/Netscape/JSNPObject.h
Source/WebKit/WebProcess/Plugins/Netscape/NPJSObject.cpp
Source/WebKitLegacy/mac/ChangeLog
Source/WebKitLegacy/mac/Plugins/Hosted/NetscapePluginInstanceProxy.mm
Source/WebKitLegacy/win/ChangeLog
Source/WebKitLegacy/win/Plugins/PluginPackage.cpp

index 49f4ce7..fc10851 100644 (file)
@@ -64,10 +64,12 @@ void JSCallbackConstructor::destroy(JSCell* cell)
     static_cast<JSCallbackConstructor*>(cell)->JSCallbackConstructor::~JSCallbackConstructor();
 }
 
-ConstructType JSCallbackConstructor::getConstructData(JSCell*, ConstructData& constructData)
+CallData JSCallbackConstructor::getConstructData(JSCell*)
 {
+    CallData constructData;
+    constructData.type = CallData::Type::Native;
     constructData.native.function = APICallbackFunction::construct<JSCallbackConstructor>;
-    return ConstructType::Host;
+    return constructData;
 }
 
 } // namespace JSC
index fbd2431..d39850d 100644 (file)
@@ -68,7 +68,7 @@ private:
 
     friend struct APICallbackFunction;
 
-    static ConstructType getConstructData(JSCell*, ConstructData&);
+    static CallData getConstructData(JSCell*);
 
     JSObjectCallAsConstructorCallback constructCallback() { return m_callback; }
 
index e643513..a642a05 100644 (file)
@@ -208,8 +208,8 @@ private:
 
     static void getOwnNonIndexPropertyNames(JSObject*, JSGlobalObject*, PropertyNameArray&, EnumerationMode);
 
-    static ConstructType getConstructData(JSCell*, ConstructData&);
-    static CallType getCallData(JSCell*, CallData&);
+    static CallData getConstructData(JSCell*);
+    static CallData getCallData(JSCell*);
 
     static void visitChildren(JSCell* cell, SlotVisitor& visitor)
     {
index 6075b0b..d9934c9 100644 (file)
@@ -430,16 +430,18 @@ bool JSCallbackObject<Parent>::deletePropertyByIndex(JSCell* cell, JSGlobalObjec
 }
 
 template <class Parent>
-ConstructType JSCallbackObject<Parent>::getConstructData(JSCell* cell, ConstructData& constructData)
+CallData JSCallbackObject<Parent>::getConstructData(JSCell* cell)
 {
+    CallData constructData;
     JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(cell);
     for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
         if (jsClass->callAsConstructor) {
+            constructData.type = CallData::Type::Native;
             constructData.native.function = construct;
-            return ConstructType::Host;
+            break;
         }
     }
-    return ConstructType::None;
+    return constructData;
 }
 
 template <class Parent>
@@ -505,16 +507,18 @@ bool JSCallbackObject<Parent>::customHasInstance(JSObject* object, JSGlobalObjec
 }
 
 template <class Parent>
-CallType JSCallbackObject<Parent>::getCallData(JSCell* cell, CallData& callData)
+CallData JSCallbackObject<Parent>::getCallData(JSCell* cell)
 {
+    CallData callData;
     JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(cell);
     for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
         if (jsClass->callAsFunction) {
+            callData.type = CallData::Type::Native;
             callData.native.function = call;
-            return CallType::Host;
+            break;
         }
     }
-    return CallType::None;
+    return callData;
 }
 
 template <class Parent>
index fbd51ee..ee9449f 100644 (file)
@@ -735,12 +735,11 @@ JSValueRef JSObjectCallAsFunction(JSContextRef ctx, JSObjectRef object, JSObject
         return 0;
     }
 
-    CallData callData;
-    CallType callType = jsObject->methodTable(vm)->getCallData(jsObject, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, jsObject);
+    if (callData.type == CallData::Type::None)
         return 0;
 
-    JSValueRef result = toRef(globalObject, profiledCall(globalObject, ProfilingReason::API, jsObject, callType, callData, jsThisObject, argList));
+    JSValueRef result = toRef(globalObject, profiledCall(globalObject, ProfilingReason::API, jsObject, callData, jsThisObject, argList));
     if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
         result = 0;
     return result;
@@ -768,9 +767,8 @@ JSObjectRef JSObjectCallAsConstructor(JSContextRef ctx, JSObjectRef object, size
 
     JSObject* jsObject = toJS(object);
 
-    ConstructData constructData;
-    ConstructType constructType = jsObject->methodTable(vm)->getConstructData(jsObject, constructData);
-    if (constructType == ConstructType::None)
+    auto constructData = getConstructData(vm, jsObject);
+    if (constructData.type == CallData::Type::None)
         return 0;
 
     MarkedArgumentBuffer argList;
@@ -783,7 +781,7 @@ JSObjectRef JSObjectCallAsConstructor(JSContextRef ctx, JSObjectRef object, size
         return 0;
     }
 
-    JSObjectRef result = toRef(profiledConstruct(globalObject, ProfilingReason::API, jsObject, constructType, constructData, argList));
+    JSObjectRef result = toRef(profiledConstruct(globalObject, ProfilingReason::API, jsObject, constructData, argList));
     if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
         result = 0;
     return result;
index 61a5413..ffeda25 100644 (file)
@@ -1,3 +1,173 @@
+2020-04-27  Ross Kirsling  <ross.kirsling@sony.com>
+
+        [JSC] CallData/ConstructData should include CallType/ConstructType
+        https://bugs.webkit.org/show_bug.cgi?id=211059
+
+        Reviewed by Darin Adler.
+
+        getCallData/getConstructData return a CallType/ConstructType and have a CallData/ConstructData out param,
+        and then *both* of these are passed side-by-side to `call`/`construct`, which all seems a bit silly.
+
+        This patch merges CallType/ConstructType into CallData/ConstructData such that getCallData/getConstructData
+        no longer need an out param and `call`/`construct` require one less overt parameter.
+
+        In so doing, it also:
+        - removes ConstructData entirely as it's an exact duplicate of CallData
+        - renames enum value Host to Native in alignment with CallData's union
+
+        * API/JSCallbackConstructor.cpp:
+        (JSC::JSCallbackConstructor::getConstructData):
+        * API/JSCallbackConstructor.h:
+        * API/JSCallbackObject.h:
+        * API/JSCallbackObjectFunctions.h:
+        (JSC::JSCallbackObject<Parent>::getConstructData):
+        (JSC::JSCallbackObject<Parent>::getCallData):
+        * API/JSObjectRef.cpp:
+        (JSObjectCallAsFunction):
+        (JSObjectCallAsConstructor):
+        * bindings/ScriptFunctionCall.cpp:
+        (Deprecated::ScriptFunctionCall::call):
+        * bindings/ScriptFunctionCall.h:
+        * dfg/DFGOperations.cpp:
+        * inspector/InjectedScriptManager.cpp:
+        (Inspector::InjectedScriptManager::createInjectedScript):
+        * inspector/InspectorEnvironment.h:
+        * interpreter/Interpreter.cpp:
+        (JSC::Interpreter::executeProgram):
+        (JSC::Interpreter::executeCall):
+        (JSC::Interpreter::executeConstruct):
+        * interpreter/Interpreter.h:
+        * jit/JITOperations.cpp:
+        * jsc.cpp:
+        (functionDollarAgentReceiveBroadcast):
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::handleHostCall):
+        * runtime/ArrayPrototype.cpp:
+        (JSC::arrayProtoFuncToString):
+        (JSC::arrayProtoFuncToLocaleString):
+        * runtime/CallData.cpp:
+        (JSC::call):
+        (JSC::profiledCall):
+        * runtime/CallData.h:
+        * runtime/ClassInfo.h:
+        * runtime/CommonSlowPaths.cpp:
+        (JSC::SLOW_PATH_DECL):
+        * runtime/ConstructData.cpp:
+        (JSC::construct):
+        (JSC::profiledConstruct):
+        * runtime/ConstructData.h:
+        (JSC::construct):
+        (JSC::profiledConstruct):
+        (): Deleted.
+        * runtime/DatePrototype.cpp:
+        (JSC::dateProtoFuncToJSON):
+        * runtime/GetterSetter.cpp:
+        (JSC::callGetter):
+        (JSC::callSetter):
+        * runtime/InternalFunction.cpp:
+        (JSC::InternalFunction::getCallData):
+        (JSC::InternalFunction::getConstructData):
+        * runtime/InternalFunction.h:
+        * runtime/IteratorOperations.cpp:
+        (JSC::iteratorNext):
+        (JSC::iteratorClose):
+        (JSC::hasIteratorMethod):
+        (JSC::iteratorMethod):
+        (JSC::iteratorForIterable):
+        * runtime/JSBoundFunction.cpp:
+        (JSC::boundThisNoArgsFunctionCall):
+        (JSC::boundFunctionCall):
+        (JSC::boundThisNoArgsFunctionConstruct):
+        (JSC::boundFunctionConstruct):
+        * runtime/JSCJSValue.h:
+        * runtime/JSCell.cpp:
+        (JSC::JSCell::getCallData):
+        (JSC::JSCell::getConstructData):
+        * runtime/JSCell.h:
+        * runtime/JSCellInlines.h:
+        (JSC::JSCell::isFunction):
+        (JSC::JSCell::isConstructor):
+        * runtime/JSFunction.cpp:
+        (JSC::JSFunction::getCallData):
+        (JSC::JSFunction::getConstructData):
+        * runtime/JSFunction.h:
+        * runtime/JSInternalPromise.cpp:
+        (JSC::JSInternalPromise::then):
+        * runtime/JSMicrotask.cpp:
+        (JSC::JSMicrotask::run):
+        * runtime/JSModuleLoader.cpp:
+        (JSC::JSModuleLoader::dependencyKeysIfEvaluated):
+        (JSC::JSModuleLoader::provideFetch):
+        (JSC::JSModuleLoader::loadAndEvaluateModule):
+        (JSC::JSModuleLoader::loadModule):
+        (JSC::JSModuleLoader::linkAndEvaluateModule):
+        (JSC::JSModuleLoader::requestImportModule):
+        * runtime/JSONObject.cpp:
+        (JSC::Stringifier::isCallableReplacer const):
+        (JSC::Stringifier::Stringifier):
+        (JSC::Stringifier::toJSON):
+        (JSC::Stringifier::appendStringifiedValue):
+        (JSC::Walker::Walker):
+        (JSC::Walker::callReviver):
+        (JSC::JSONProtoFuncParse):
+        * runtime/JSObject.cpp:
+        (JSC::ordinarySetSlow):
+        (JSC::callToPrimitiveFunction):
+        (JSC::JSObject::hasInstance):
+        (JSC::JSObject::getMethod):
+        * runtime/JSObject.h:
+        * runtime/JSObjectInlines.h:
+        (JSC::getCallData):
+        (JSC::getConstructData):
+        * runtime/JSPromise.cpp:
+        (JSC::JSPromise::createDeferredData):
+        (JSC::JSPromise::resolvedPromise):
+        (JSC::callFunction):
+        * runtime/MapConstructor.cpp:
+        (JSC::constructMap):
+        * runtime/ObjectPrototype.cpp:
+        (JSC::objectProtoFuncToLocaleString):
+        * runtime/ProxyObject.cpp:
+        (JSC::performProxyGet):
+        (JSC::ProxyObject::performInternalMethodGetOwnProperty):
+        (JSC::ProxyObject::performHasProperty):
+        (JSC::ProxyObject::performPut):
+        (JSC::performProxyCall):
+        (JSC::ProxyObject::getCallData):
+        (JSC::performProxyConstruct):
+        (JSC::ProxyObject::getConstructData):
+        (JSC::ProxyObject::performDelete):
+        (JSC::ProxyObject::performPreventExtensions):
+        (JSC::ProxyObject::performIsExtensible):
+        (JSC::ProxyObject::performDefineOwnProperty):
+        (JSC::ProxyObject::performGetOwnPropertyNames):
+        (JSC::ProxyObject::performSetPrototype):
+        (JSC::ProxyObject::performGetPrototype):
+        * runtime/ProxyObject.h:
+        * runtime/ReflectObject.cpp:
+        (JSC::reflectObjectConstruct):
+        * runtime/SamplingProfiler.cpp:
+        (JSC::SamplingProfiler::processUnverifiedStackTraces):
+        * runtime/SetConstructor.cpp:
+        (JSC::constructSet):
+        * runtime/StringPrototype.cpp:
+        (JSC::replaceUsingRegExpSearch):
+        (JSC::operationStringProtoFuncReplaceRegExpEmptyStr):
+        (JSC::operationStringProtoFuncReplaceRegExpString):
+        (JSC::replaceUsingStringSearch):
+        * runtime/VM.cpp:
+        (JSC::VM::callPromiseRejectionCallback):
+        * runtime/WeakMapConstructor.cpp:
+        (JSC::constructWeakMap):
+        * runtime/WeakSetConstructor.cpp:
+        (JSC::constructWeakSet):
+        * tools/JSDollarVM.cpp:
+        (JSC::callWithStackSizeProbeFunction):
+        * wasm/js/WebAssemblyModuleRecord.cpp:
+        (JSC::WebAssemblyModuleRecord::evaluate):
+        * wasm/js/WebAssemblyWrapperFunction.cpp:
+        (JSC::callWebAssemblyWrapperFunction):
+
 2020-04-26  Ross Kirsling  <ross.kirsling@sony.com>
 
         [JSC] Clearly distinguish isConstructor from getConstructData
index 866aebc..ab0fed6 100644 (file)
@@ -114,17 +114,16 @@ Expected<JSValue, NakedPtr<Exception>> ScriptFunctionCall::call()
     if (UNLIKELY(scope.exception()))
         return makeUnexpected(scope.exception());
 
-    CallData callData;
-    CallType callType = getCallData(vm, function, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, function);
+    if (callData.type == CallData::Type::None)
         return { };
 
     JSValue result;
     NakedPtr<Exception> exception;
     if (m_callHandler)
-        result = m_callHandler(m_globalObject, function, callType, callData, thisObject, m_arguments, exception);
+        result = m_callHandler(m_globalObject, function, callData, thisObject, m_arguments, exception);
     else
-        result = JSC::call(m_globalObject, function, callType, callData, thisObject, m_arguments, exception);
+        result = JSC::call(m_globalObject, function, callData, thisObject, m_arguments, exception);
 
     if (exception) {
         // Do not treat a terminated execution exception as having an exception. Just treat it as an empty result.
index 455677d..a237d63 100644 (file)
@@ -70,7 +70,7 @@ private:
 
 class JS_EXPORT_PRIVATE ScriptFunctionCall : public ScriptCallArgumentHandler {
 public:
-    typedef JSC::JSValue (*ScriptFunctionCallHandler)(JSC::JSGlobalObject* globalObject, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>&);
+    typedef JSC::JSValue (*ScriptFunctionCallHandler)(JSC::JSGlobalObject* globalObject, JSC::JSValue functionObject, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>&);
     ScriptFunctionCall(const ScriptObject& thisObject, const String& name, ScriptFunctionCallHandler handler = nullptr);
     Expected<JSC::JSValue, NakedPtr<JSC::Exception>> call();
 
index 443876a..02cf5fc 100644 (file)
@@ -3043,14 +3043,13 @@ JSCell* JIT_OPERATION operationSpreadGeneric(JSGlobalObject* globalObject, JSCel
     JSArray* array;
     {
         JSFunction* iterationFunction = globalObject->iteratorProtocolFunction();
-        CallData callData;
-        CallType callType = JSC::getCallData(vm, iterationFunction, callData);
-        ASSERT(callType != CallType::None);
+        auto callData = getCallData(vm, iterationFunction);
+        ASSERT(callData.type != CallData::Type::None);
 
         MarkedArgumentBuffer arguments;
         arguments.append(iterable);
         ASSERT(!arguments.hasOverflowed());
-        JSValue arrayResult = call(globalObject, iterationFunction, callType, callData, jsNull(), arguments);
+        JSValue arrayResult = call(globalObject, iterationFunction, callData, jsNull(), arguments);
         RETURN_IF_EXCEPTION(throwScope, nullptr);
         array = jsCast<JSArray*>(arrayResult);
     }
index 51e3c1a..ed28df0 100644 (file)
@@ -158,9 +158,8 @@ Expected<JSObject*, NakedPtr<Exception>> InjectedScriptManager::createInjectedSc
     if (evaluationException)
         return makeUnexpected(evaluationException);
 
-    CallData callData;
-    CallType callType = getCallData(vm, functionValue, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, functionValue);
+    if (callData.type == CallData::Type::None)
         return nullptr;
 
     MarkedArgumentBuffer args;
@@ -169,7 +168,7 @@ Expected<JSObject*, NakedPtr<Exception>> InjectedScriptManager::createInjectedSc
     args.append(jsNumber(id));
     ASSERT(!args.hasOverflowed());
 
-    JSValue result = JSC::call(globalObject, functionValue, callType, callData, globalThisValue, args);
+    JSValue result = JSC::call(globalObject, functionValue, callData, globalThisValue, args);
     scope.clearException();
     return result.getObject();
 }
index 77c6cee..ead28cf 100644 (file)
@@ -40,7 +40,7 @@ class VM;
 namespace Inspector {
 
 class ScriptDebugServer;
-typedef JSC::JSValue (*InspectorFunctionCallHandler)(JSC::JSGlobalObject* globalObject, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException);
+typedef JSC::JSValue (*InspectorFunctionCallHandler)(JSC::JSGlobalObject* globalObject, JSC::JSValue functionObject, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException);
 typedef JSC::JSValue (*InspectorEvaluateHandler)(JSC::JSGlobalObject*, const JSC::SourceCode&, JSC::JSValue thisValue, NakedPtr<JSC::Exception>& returnedException);
 
 class InspectorEnvironment {
index ad4b215..af48ae3 100644 (file)
@@ -780,15 +780,14 @@ JSValue Interpreter::executeProgram(const SourceCode& source, JSGlobalObject*, J
             case JSONPPathEntryTypeCall: {
                 JSValue function = baseObject.get(globalObject, JSONPPath.last().m_pathEntryName);
                 RETURN_IF_EXCEPTION(throwScope, JSValue());
-                CallData callData;
-                CallType callType = getCallData(vm, function, callData);
-                if (callType == CallType::None)
+                auto callData = getCallData(vm, function);
+                if (callData.type == CallData::Type::None)
                     return throwException(globalObject, throwScope, createNotAFunctionError(globalObject, function));
                 MarkedArgumentBuffer jsonArg;
                 jsonArg.append(JSONPValue);
                 ASSERT(!jsonArg.hasOverflowed());
                 JSValue thisValue = JSONPPath.size() == 1 ? jsUndefined() : baseObject;
-                JSONPValue = JSC::call(globalObject, function, callType, callData, thisValue, jsonArg);
+                JSONPValue = JSC::call(globalObject, function, callData, thisValue, jsonArg);
                 RETURN_IF_EXCEPTION(throwScope, JSValue());
                 break;
             }
@@ -857,7 +856,7 @@ failedJSONP:
     return checkedReturn(result);
 }
 
-JSValue Interpreter::executeCall(JSGlobalObject* lexicalGlobalObject, JSObject* function, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args)
+JSValue Interpreter::executeCall(JSGlobalObject* lexicalGlobalObject, JSObject* function, const CallData& callData, JSValue thisValue, const ArgList& args)
 {
     VM& vm = lexicalGlobalObject->vm();
     auto throwScope = DECLARE_THROW_SCOPE(vm);
@@ -867,7 +866,7 @@ JSValue Interpreter::executeCall(JSGlobalObject* lexicalGlobalObject, JSObject*
     if (vm.isCollectorBusyOnCurrentThread())
         return jsNull();
 
-    bool isJSCall = (callType == CallType::JS);
+    bool isJSCall = (callData.type == CallData::Type::JS);
     JSScope* scope = nullptr;
     size_t argsCount = 1 + args.size(); // implicit "this" parameter
 
@@ -877,7 +876,7 @@ JSValue Interpreter::executeCall(JSGlobalObject* lexicalGlobalObject, JSObject*
         scope = callData.js.scope;
         globalObject = scope->globalObject(vm);
     } else {
-        ASSERT(callType == CallType::Host);
+        ASSERT(callData.type == CallData::Type::Native);
         globalObject = function->globalObject(vm);
     }
 
@@ -929,7 +928,7 @@ JSValue Interpreter::executeCall(JSGlobalObject* lexicalGlobalObject, JSObject*
     return checkedReturn(result);
 }
 
-JSObject* Interpreter::executeConstruct(JSGlobalObject* lexicalGlobalObject, JSObject* constructor, ConstructType constructType, const ConstructData& constructData, const ArgList& args, JSValue newTarget)
+JSObject* Interpreter::executeConstruct(JSGlobalObject* lexicalGlobalObject, JSObject* constructor, const CallData& constructData, const ArgList& args, JSValue newTarget)
 {
     VM& vm = lexicalGlobalObject->vm();
     auto throwScope = DECLARE_THROW_SCOPE(vm);
@@ -943,7 +942,7 @@ JSObject* Interpreter::executeConstruct(JSGlobalObject* lexicalGlobalObject, JSO
         return nullptr;
     }
 
-    bool isJSConstruct = (constructType == ConstructType::JS);
+    bool isJSConstruct = (constructData.type == CallData::Type::JS);
     JSScope* scope = nullptr;
     size_t argsCount = 1 + args.size(); // implicit "this" parameter
 
@@ -953,7 +952,7 @@ JSObject* Interpreter::executeConstruct(JSGlobalObject* lexicalGlobalObject, JSO
         scope = constructData.js.scope;
         globalObject = scope->globalObject(vm);
     } else {
-        ASSERT(constructType == ConstructType::Host);
+        ASSERT(constructData.type == CallData::Type::Native);
         globalObject = constructor->globalObject(vm);
     }
 
index 6453912..4f8bc78 100644 (file)
@@ -106,8 +106,8 @@ namespace JSC {
 
         JSValue executeProgram(const SourceCode&, JSGlobalObject*, JSObject* thisObj);
         JSValue executeModuleProgram(ModuleProgramExecutable*, JSGlobalObject*, JSModuleEnvironment*);
-        JSValue executeCall(JSGlobalObject*, JSObject* function, CallType, const CallData&, JSValue thisValue, const ArgList&);
-        JSObject* executeConstruct(JSGlobalObject*, JSObject* function, ConstructType, const ConstructData&, const ArgList&, JSValue newTarget);
+        JSValue executeCall(JSGlobalObject*, JSObject* function, const CallData&, JSValue thisValue, const ArgList&);
+        JSObject* executeConstruct(JSGlobalObject*, JSObject* function, const CallData&, const ArgList&, JSValue newTarget);
         JSValue execute(EvalExecutable*, JSGlobalObject*, JSValue thisValue, JSScope*);
 
         void getArgumentsData(CallFrame*, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);
index dd65f7b..000d437 100644 (file)
@@ -1058,12 +1058,10 @@ static SlowPathReturnType handleHostCall(JSGlobalObject* globalObject, CallFrame
     calleeFrame->setCodeBlock(0);
 
     if (callLinkInfo->specializationKind() == CodeForCall) {
-        CallData callData;
-        CallType callType = getCallData(vm, callee, callData);
-    
-        ASSERT(callType != CallType::JS);
-    
-        if (callType == CallType::Host) {
+        auto callData = getCallData(vm, callee);
+        ASSERT(callData.type != CallData::Type::JS);
+
+        if (callData.type == CallData::Type::Native) {
             NativeCallFrameTracer tracer(vm, calleeFrame);
             calleeFrame->setCallee(asObject(callee));
             vm.hostCallReturnValue = JSValue::decode(callData.native.function(asObject(callee)->globalObject(vm), calleeFrame));
@@ -1078,7 +1076,7 @@ static SlowPathReturnType handleHostCall(JSGlobalObject* globalObject, CallFrame
                 reinterpret_cast<void*>(callLinkInfo->callMode() == CallMode::Tail ? ReuseTheFrame : KeepTheFrame));
         }
     
-        ASSERT(callType == CallType::None);
+        ASSERT(callData.type == CallData::Type::None);
         throwException(globalObject, scope, createNotAFunctionError(globalObject, callee));
         return encodeResult(
             vm.getCTIStub(throwExceptionFromCallSlowPathGenerator).retaggedCode<JSEntryPtrTag>().executableAddress(),
@@ -1086,13 +1084,11 @@ static SlowPathReturnType handleHostCall(JSGlobalObject* globalObject, CallFrame
     }
 
     ASSERT(callLinkInfo->specializationKind() == CodeForConstruct);
-    
-    ConstructData constructData;
-    ConstructType constructType = getConstructData(vm, callee, constructData);
-    
-    ASSERT(constructType != ConstructType::JS);
-    
-    if (constructType == ConstructType::Host) {
+
+    auto constructData = getConstructData(vm, callee);
+    ASSERT(constructData.type != CallData::Type::JS);
+
+    if (constructData.type == CallData::Type::Native) {
         NativeCallFrameTracer tracer(vm, calleeFrame);
         calleeFrame->setCallee(asObject(callee));
         vm.hostCallReturnValue = JSValue::decode(constructData.native.function(asObject(callee)->globalObject(vm), calleeFrame));
@@ -1104,8 +1100,8 @@ static SlowPathReturnType handleHostCall(JSGlobalObject* globalObject, CallFrame
 
         return encodeResult(tagCFunction<void*, JSEntryPtrTag>(getHostCallReturnValue), reinterpret_cast<void*>(KeepTheFrame));
     }
-    
-    ASSERT(constructType == ConstructType::None);
+
+    ASSERT(constructData.type == CallData::Type::None);
     throwException(globalObject, scope, createNotAConstructorError(globalObject, callee));
     return encodeResult(
         vm.getCTIStub(throwExceptionFromCallSlowPathGenerator).retaggedCode<JSEntryPtrTag>().executableAddress(),
index d089335..1e15b34 100644 (file)
@@ -1941,9 +1941,8 @@ EncodedJSValue JSC_HOST_CALL functionDollarAgentReceiveBroadcast(JSGlobalObject*
     auto scope = DECLARE_THROW_SCOPE(vm);
 
     JSValue callback = callFrame->argument(0);
-    CallData callData;
-    CallType callType = getCallData(vm, callback, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, callback);
+    if (callData.type == CallData::Type::None)
         return JSValue::encode(throwException(globalObject, scope, createError(globalObject, "Expected callback"_s)));
     
     RefPtr<Message> message;
@@ -1961,7 +1960,7 @@ EncodedJSValue JSC_HOST_CALL functionDollarAgentReceiveBroadcast(JSGlobalObject*
     args.append(jsNumber(message->index()));
     if (UNLIKELY(args.hasOverflowed()))
         return JSValue::encode(throwOutOfMemoryError(globalObject, scope));
-    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, callback, callType, callData, jsNull(), args)));
+    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, callback, callData, jsNull(), args)));
 }
 
 EncodedJSValue JSC_HOST_CALL functionDollarAgentReport(JSGlobalObject* globalObject, CallFrame* callFrame)
index ab2271f..759c132 100644 (file)
@@ -1520,12 +1520,10 @@ static SlowPathReturnType handleHostCall(CallFrame* calleeFrame, JSValue callee,
     calleeFrame->clearReturnPC();
 
     if (kind == CodeForCall) {
-        CallData callData;
-        CallType callType = getCallData(vm, callee, callData);
-    
-        ASSERT(callType != CallType::JS);
-    
-        if (callType == CallType::Host) {
+        auto callData = getCallData(vm, callee);
+        ASSERT(callData.type != CallData::Type::JS);
+
+        if (callData.type == CallData::Type::Native) {
             SlowPathFrameTracer tracer(vm, calleeFrame);
             calleeFrame->setCallee(asObject(callee));
             vm.hostCallReturnValue = JSValue::decode(callData.native.function(asObject(callee)->globalObject(vm), calleeFrame));
@@ -1534,18 +1532,16 @@ static SlowPathReturnType handleHostCall(CallFrame* calleeFrame, JSValue callee,
         
         slowPathLog("Call callee is not a function: ", callee, "\n");
 
-        ASSERT(callType == CallType::None);
+        ASSERT(callData.type == CallData::Type::None);
         LLINT_CALL_THROW(globalObject, createNotAFunctionError(globalObject, callee));
     }
 
     ASSERT(kind == CodeForConstruct);
-    
-    ConstructData constructData;
-    ConstructType constructType = getConstructData(vm, callee, constructData);
-    
-    ASSERT(constructType != ConstructType::JS);
-    
-    if (constructType == ConstructType::Host) {
+
+    auto constructData = getConstructData(vm, callee);
+    ASSERT(constructData.type != CallData::Type::JS);
+
+    if (constructData.type == CallData::Type::Native) {
         SlowPathFrameTracer tracer(vm, calleeFrame);
         calleeFrame->setCallee(asObject(callee));
         vm.hostCallReturnValue = JSValue::decode(constructData.native.function(asObject(callee)->globalObject(vm), calleeFrame));
@@ -1554,7 +1550,7 @@ static SlowPathReturnType handleHostCall(CallFrame* calleeFrame, JSValue callee,
     
     slowPathLog("Constructor callee is not a function: ", callee, "\n");
 
-    ASSERT(constructType == ConstructType::None);
+    ASSERT(constructData.type == CallData::Type::None);
     LLINT_CALL_THROW(globalObject, createNotAConstructorError(globalObject, callee));
 }
 
index 2bbb6c3..d0d7c4c 100644 (file)
@@ -615,17 +615,16 @@ EncodedJSValue JSC_HOST_CALL arrayProtoFuncToString(JSGlobalObject* globalObject
         bool customJoinCase = false;
         if (!function.isCell())
             customJoinCase = true;
-        CallData callData;
-        CallType callType = getCallData(vm, function, callData);
-        if (callType == CallType::None)
+        auto callData = getCallData(vm, function);
+        if (callData.type == CallData::Type::None)
             customJoinCase = true;
 
         if (UNLIKELY(customJoinCase))
             RELEASE_AND_RETURN(scope, JSValue::encode(jsMakeNontrivialString(globalObject, "[object ", thisObject->methodTable(vm)->className(thisObject, vm), "]")));
 
         // 4. Return the result of calling the [[Call]] internal method of func providing array as the this value and an empty arguments list.
-        if (!isJSArray(thisObject) || callType != CallType::Host || callData.native.function != arrayProtoFuncJoin)
-            RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, function, callType, callData, thisObject, *vm.emptyList)));
+        if (!isJSArray(thisObject) || callData.type != CallData::Type::Native || callData.native.function != arrayProtoFuncJoin)
+            RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, function, callData, thisObject, *vm.emptyList)));
     }
 
     ASSERT(isJSArray(thisValue));
@@ -706,10 +705,9 @@ EncodedJSValue JSC_HOST_CALL arrayProtoFuncToLocaleString(JSGlobalObject* global
         else {
             JSValue conversionFunction = element.get(globalObject, vm.propertyNames->toLocaleString);
             RETURN_IF_EXCEPTION(scope, encodedJSValue());
-            CallData callData;
-            CallType callType = getCallData(vm, conversionFunction, callData);
-            if (callType != CallType::None) {
-                element = call(globalObject, conversionFunction, callType, callData, element, arguments);
+            auto callData = getCallData(vm, conversionFunction);
+            if (callData.type != CallData::Type::None) {
+                element = call(globalObject, conversionFunction, callData, element, arguments);
                 RETURN_IF_EXCEPTION(scope, encodedJSValue());
             }
         }
index af8b6c2..a12b3a1 100644 (file)
@@ -44,26 +44,25 @@ JSValue call(JSGlobalObject* globalObject, JSValue functionObject, JSValue thisV
     VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    CallData callData;
-    CallType callType = getCallData(vm, functionObject, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, functionObject);
+    if (callData.type == CallData::Type::None)
         return throwTypeError(globalObject, scope, errorMessage);
 
-    RELEASE_AND_RETURN(scope, call(globalObject, functionObject, callType, callData, thisValue, args));
+    RELEASE_AND_RETURN(scope, call(globalObject, functionObject, callData, thisValue, args));
 }
 
-JSValue call(JSGlobalObject* globalObject, JSValue functionObject, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args)
+JSValue call(JSGlobalObject* globalObject, JSValue functionObject, const CallData& callData, JSValue thisValue, const ArgList& args)
 {
     VM& vm = globalObject->vm();
-    ASSERT(callType == CallType::JS || callType == CallType::Host);
-    return vm.interpreter->executeCall(globalObject, asObject(functionObject), callType, callData, thisValue, args);
+    ASSERT(callData.type == CallData::Type::JS || callData.type == CallData::Type::Native);
+    return vm.interpreter->executeCall(globalObject, asObject(functionObject), callData, thisValue, args);
 }
 
-JSValue call(JSGlobalObject* globalObject, JSValue functionObject, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args, NakedPtr<Exception>& returnedException)
+JSValue call(JSGlobalObject* globalObject, JSValue functionObject, const CallData& callData, JSValue thisValue, const ArgList& args, NakedPtr<Exception>& returnedException)
 {
     VM& vm = globalObject->vm();
     auto scope = DECLARE_CATCH_SCOPE(vm);
-    JSValue result = call(globalObject, functionObject, callType, callData, thisValue, args);
+    JSValue result = call(globalObject, functionObject, callData, thisValue, args);
     if (UNLIKELY(scope.exception())) {
         returnedException = scope.exception();
         scope.clearException();
@@ -73,18 +72,18 @@ JSValue call(JSGlobalObject* globalObject, JSValue functionObject, CallType call
     return result;
 }
 
-JSValue profiledCall(JSGlobalObject* globalObject, ProfilingReason reason, JSValue functionObject, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args)
+JSValue profiledCall(JSGlobalObject* globalObject, ProfilingReason reason, JSValue functionObject, const CallData& callData, JSValue thisValue, const ArgList& args)
 {
     VM& vm = globalObject->vm();
     ScriptProfilingScope profilingScope(vm.deprecatedVMEntryGlobalObject(globalObject), reason);
-    return call(globalObject, functionObject, callType, callData, thisValue, args);
+    return call(globalObject, functionObject, callData, thisValue, args);
 }
 
-JSValue profiledCall(JSGlobalObject* globalObject, ProfilingReason reason, JSValue functionObject, CallType callType, const CallData& callData, JSValue thisValue, const ArgList& args, NakedPtr<Exception>& returnedException)
+JSValue profiledCall(JSGlobalObject* globalObject, ProfilingReason reason, JSValue functionObject, const CallData& callData, JSValue thisValue, const ArgList& args, NakedPtr<Exception>& returnedException)
 {
     VM& vm = globalObject->vm();
     ScriptProfilingScope profilingScope(vm.deprecatedVMEntryGlobalObject(globalObject), reason);
-    return call(globalObject, functionObject, callType, callData, thisValue, args, returnedException);
+    return call(globalObject, functionObject, callData, thisValue, args, returnedException);
 }
 
 } // namespace JSC
index f5abf4d..73a9c15 100644 (file)
 
 namespace JSC {
 
-class CallFrame;
 class ArgList;
 class Exception;
 class FunctionExecutable;
-class JSObject;
 class JSScope;
 
-enum class CallType : unsigned {
-    None,
-    Host,
-    JS
-};
-
 struct CallData {
+    enum class Type : uint8_t { None, Native, JS };
+    Type type { Type::None };
+
     union {
         struct {
             TaggedNativeFunction function;
@@ -58,20 +53,20 @@ struct CallData {
     };
 };
 
-enum class ProfilingReason {
+enum class ProfilingReason : uint8_t {
     API,
     Microtask,
     Other
 };
 
-// Convenience wrapper so you don't need to deal with CallData and CallType unless you are going to use them.
+// Convenience wrapper so you don't need to deal with CallData unless you are going to use it.
 JS_EXPORT_PRIVATE JSValue call(JSGlobalObject*, JSValue functionObject, const ArgList&, const char* errorMessage);
 JS_EXPORT_PRIVATE JSValue call(JSGlobalObject*, JSValue functionObject, JSValue thisValue, const ArgList&, const char* errorMessage);
 
-JS_EXPORT_PRIVATE JSValue call(JSGlobalObject*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
-JS_EXPORT_PRIVATE JSValue call(JSGlobalObject*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&, NakedPtr<Exception>& returnedException);
+JS_EXPORT_PRIVATE JSValue call(JSGlobalObject*, JSValue functionObject, const CallData&, JSValue thisValue, const ArgList&);
+JS_EXPORT_PRIVATE JSValue call(JSGlobalObject*, JSValue functionObject, const CallData&, JSValue thisValue, const ArgList&, NakedPtr<Exception>& returnedException);
 
-JS_EXPORT_PRIVATE JSValue profiledCall(JSGlobalObject*, ProfilingReason, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
-JS_EXPORT_PRIVATE JSValue profiledCall(JSGlobalObject*, ProfilingReason, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&, NakedPtr<Exception>& returnedException);
+JS_EXPORT_PRIVATE JSValue profiledCall(JSGlobalObject*, ProfilingReason, JSValue functionObject, const CallData&, JSValue thisValue, const ArgList&);
+JS_EXPORT_PRIVATE JSValue profiledCall(JSGlobalObject*, ProfilingReason, JSValue functionObject, const CallData&, JSValue thisValue, const ArgList&, NakedPtr<Exception>& returnedException);
 
 } // namespace JSC
index 7a59b8f..b32c8fd 100644 (file)
@@ -47,10 +47,10 @@ struct MethodTable {
     using VisitChildrenFunctionPtr = void (*)(JSCell*, SlotVisitor&);
     VisitChildrenFunctionPtr METHOD_TABLE_ENTRY(visitChildren);
 
-    using GetCallDataFunctionPtr = CallType (*)(JSCell*, CallData&);
+    using GetCallDataFunctionPtr = CallData (*)(JSCell*);
     GetCallDataFunctionPtr METHOD_TABLE_ENTRY(getCallData);
 
-    using GetConstructDataFunctionPtr = ConstructType (*)(JSCell*, ConstructData&);
+    using GetConstructDataFunctionPtr = CallData (*)(JSCell*);
     GetConstructDataFunctionPtr METHOD_TABLE_ENTRY(getConstructData);
 
     using PutFunctionPtr = bool (*)(JSCell*, JSGlobalObject*, PropertyName propertyName, JSValue, PutPropertySlot&);
index cef09f0..1ca96f4 100644 (file)
@@ -1502,14 +1502,13 @@ SLOW_PATH_DECL(slow_path_spread)
     JSArray* array;
     {
         JSFunction* iterationFunction = globalObject->iteratorProtocolFunction();
-        CallData callData;
-        CallType callType = JSC::getCallData(vm, iterationFunction, callData);
-        ASSERT(callType != CallType::None);
+        auto callData = getCallData(vm, iterationFunction);
+        ASSERT(callData.type != CallData::Type::None);
 
         MarkedArgumentBuffer arguments;
         arguments.append(iterable);
         ASSERT(!arguments.hasOverflowed());
-        JSValue arrayResult = call(globalObject, iterationFunction, callType, callData, jsNull(), arguments);
+        JSValue arrayResult = call(globalObject, iterationFunction, callData, jsNull(), arguments);
         CHECK_EXCEPTION();
         array = jsCast<JSArray*>(arrayResult);
     }
index 47b2474..db6138a 100644 (file)
@@ -44,28 +44,27 @@ JSObject* construct(JSGlobalObject* globalObject, JSValue constructorObject, JSV
     VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    ConstructData constructData;
-    ConstructType constructType = getConstructData(vm, constructorObject, constructData);
-    if (UNLIKELY(constructType == ConstructType::None)) {
+    auto constructData = getConstructData(vm, constructorObject);
+    if (UNLIKELY(constructData.type == CallData::Type::None)) {
         throwTypeError(globalObject, scope, errorMessage);
         return nullptr;
     }
 
-    RELEASE_AND_RETURN(scope, construct(globalObject, constructorObject, constructType, constructData, args, newTarget));  
+    RELEASE_AND_RETURN(scope, construct(globalObject, constructorObject, constructData, args, newTarget));
 }
 
-JSObject* construct(JSGlobalObject* globalObject, JSValue constructorObject, ConstructType constructType, const ConstructData& constructData, const ArgList& args, JSValue newTarget)
+JSObject* construct(JSGlobalObject* globalObject, JSValue constructorObject, const CallData& constructData, const ArgList& args, JSValue newTarget)
 {
     VM& vm = globalObject->vm();
-    ASSERT(constructType == ConstructType::JS || constructType == ConstructType::Host);
-    return vm.interpreter->executeConstruct(globalObject, asObject(constructorObject), constructType, constructData, args, newTarget);
+    ASSERT(constructData.type == CallData::Type::JS || constructData.type == CallData::Type::Native);
+    return vm.interpreter->executeConstruct(globalObject, asObject(constructorObject), constructData, args, newTarget);
 }
 
-JSObject* profiledConstruct(JSGlobalObject* globalObject, ProfilingReason reason, JSValue constructorObject, ConstructType constructType, const ConstructData& constructData, const ArgList& args, JSValue newTarget)
+JSObject* profiledConstruct(JSGlobalObject* globalObject, ProfilingReason reason, JSValue constructorObject, const CallData& constructData, const ArgList& args, JSValue newTarget)
 {
     VM& vm = globalObject->vm();
     ScriptProfilingScope profilingScope(vm.deprecatedVMEntryGlobalObject(globalObject), reason);
-    return construct(globalObject, constructorObject, constructType, constructData, args, newTarget);
+    return construct(globalObject, constructorObject, constructData, args, newTarget);
 }
 
 } // namespace JSC
index fb61974..5452ae2 100644 (file)
 #pragma once
 
 #include "CallData.h"
-#include "JSCJSValue.h"
-#include "NativeFunction.h"
 
 namespace JSC {
 
-class ArgList;
-class CallFrame;
-class FunctionExecutable;
 class JSObject;
-class JSScope;
 
-enum class ConstructType : unsigned {
-    None,
-    Host,
-    JS
-};
-
-struct ConstructData {
-    union {
-        struct {
-            TaggedNativeFunction function;
-        } native;
-        struct {
-            FunctionExecutable* functionExecutable;
-            JSScope* scope;
-        } js;
-    };
-};
-
-// Convenience wrapper so you don't need to deal with CallData and CallType unless you are going to use them.
+// Convenience wrapper so you don't need to deal with CallData unless you are going to use it.
 JS_EXPORT_PRIVATE JSObject* construct(JSGlobalObject*, JSValue functionObject, const ArgList&, const char* errorMessage);
 JS_EXPORT_PRIVATE JSObject* construct(JSGlobalObject*, JSValue functionObject, JSValue newTarget, const ArgList&, const char* errorMessage);
 
-JS_EXPORT_PRIVATE JSObject* construct(JSGlobalObject*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&, JSValue newTarget);
+JS_EXPORT_PRIVATE JSObject* construct(JSGlobalObject*, JSValue constructor, const CallData&, const ArgList&, JSValue newTarget);
 
-ALWAYS_INLINE JSObject* construct(JSGlobalObject* globalObject, JSValue constructorObject, ConstructType constructType, const ConstructData& constructData, const ArgList& args)
+ALWAYS_INLINE JSObject* construct(JSGlobalObject* globalObject, JSValue constructorObject, const CallData& callData, const ArgList& args)
 {
-    return construct(globalObject, constructorObject, constructType, constructData, args, constructorObject);
+    return construct(globalObject, constructorObject, callData, args, constructorObject);
 }
 
-JS_EXPORT_PRIVATE JSObject* profiledConstruct(JSGlobalObject*, ProfilingReason, JSValue constructor, ConstructType, const ConstructData&, const ArgList&, JSValue newTarget);
+JS_EXPORT_PRIVATE JSObject* profiledConstruct(JSGlobalObject*, ProfilingReason, JSValue constructor, const CallData&, const ArgList&, JSValue newTarget);
 
-ALWAYS_INLINE JSObject* profiledConstruct(JSGlobalObject* globalObject, ProfilingReason reason, JSValue constructorObject, ConstructType constructType, const ConstructData& constructData, const ArgList& args)
+ALWAYS_INLINE JSObject* profiledConstruct(JSGlobalObject* globalObject, ProfilingReason reason, JSValue constructorObject, const CallData& callData, const ArgList& args)
 {
-    return profiledConstruct(globalObject, reason, constructorObject, constructType, constructData, args, constructorObject);
+    return profiledConstruct(globalObject, reason, constructorObject, callData, args, constructorObject);
 }
 
 } // namespace JSC
index 8e680f6..70903c5 100644 (file)
@@ -1167,12 +1167,11 @@ EncodedJSValue JSC_HOST_CALL dateProtoFuncToJSON(JSGlobalObject* globalObject, C
     JSValue toISOValue = object->get(globalObject, vm.propertyNames->toISOString);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
 
-    CallData callData;
-    CallType callType = getCallData(vm, toISOValue, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, toISOValue);
+    if (callData.type == CallData::Type::None)
         return throwVMTypeError(globalObject, scope, "toISOString is not a function"_s);
 
-    JSValue result = call(globalObject, asObject(toISOValue), callType, callData, object, *vm.emptyList);
+    JSValue result = call(globalObject, asObject(toISOValue), callData, object, *vm.emptyList);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
     return JSValue::encode(result);
 }
index 66cc750..c18c9e0 100644 (file)
@@ -55,9 +55,8 @@ JSValue callGetter(JSGlobalObject* globalObject, JSValue base, JSValue getterSet
 
     JSObject* getter = jsCast<GetterSetter*>(getterSetter)->getter();
 
-    CallData callData;
-    CallType callType = getter->methodTable(vm)->getCallData(getter, callData);
-    RELEASE_AND_RETURN(scope, call(globalObject, getter, callType, callData, base, ArgList()));
+    auto callData = getCallData(vm, getter);
+    RELEASE_AND_RETURN(scope, call(globalObject, getter, callData, base, ArgList()));
 }
 
 bool callSetter(JSGlobalObject* globalObject, JSValue base, JSValue getterSetter, JSValue value, ECMAMode ecmaMode)
@@ -76,10 +75,9 @@ bool callSetter(JSGlobalObject* globalObject, JSValue base, JSValue getterSetter
     args.append(value);
     ASSERT(!args.hasOverflowed());
 
-    CallData callData;
-    CallType callType = setter->methodTable(vm)->getCallData(setter, callData);
+    auto callData = getCallData(vm, setter);
     scope.release();
-    call(globalObject, setter, callType, callData, base, args);
+    call(globalObject, setter, callData, base, args);
     return true;
 }
 
index 542f730..f84c573 100644 (file)
@@ -87,21 +87,26 @@ const String InternalFunction::displayName(VM& vm)
     return String();
 }
 
-CallType InternalFunction::getCallData(JSCell* cell, CallData& callData)
+CallData InternalFunction::getCallData(JSCell* cell)
 {
     auto* function = jsCast<InternalFunction*>(cell);
     ASSERT(function->m_functionForCall);
+
+    CallData callData;
+    callData.type = CallData::Type::Native;
     callData.native.function = function->m_functionForCall;
-    return CallType::Host;
+    return callData;
 }
 
-ConstructType InternalFunction::getConstructData(JSCell* cell, ConstructData& constructData)
+CallData InternalFunction::getConstructData(JSCell* cell)
 {
+    CallData constructData;
     auto* function = jsCast<InternalFunction*>(cell);
-    if (function->m_functionForConstruct == callHostFunctionAsConstructor)
-        return ConstructType::None;
-    constructData.native.function = function->m_functionForConstruct;
-    return ConstructType::Host;
+    if (function->m_functionForConstruct != callHostFunctionAsConstructor) {
+        constructData.type = CallData::Type::Native;
+        constructData.native.function = function->m_functionForConstruct;
+    }
+    return constructData;
 }
 
 const String InternalFunction::calculatedDisplayName(VM& vm)
index 00db11e..a90b7aa 100644 (file)
@@ -88,8 +88,8 @@ protected:
     enum class NameAdditionMode { WithStructureTransition, WithoutStructureTransition };
     JS_EXPORT_PRIVATE void finishCreation(VM&, const String& name, NameAdditionMode = NameAdditionMode::WithStructureTransition);
 
-    JS_EXPORT_PRIVATE static ConstructType getConstructData(JSCell*, ConstructData&);
-    JS_EXPORT_PRIVATE static CallType getCallData(JSCell*, CallData&);
+    JS_EXPORT_PRIVATE static CallData getConstructData(JSCell*);
+    JS_EXPORT_PRIVATE static CallData getCallData(JSCell*);
 
     TaggedNativeFunction m_functionForCall;
     TaggedNativeFunction m_functionForConstruct;
index 7773c17..75007e4 100644 (file)
@@ -42,16 +42,15 @@ JSValue iteratorNext(JSGlobalObject* globalObject, IterationRecord iterationReco
     JSValue iterator = iterationRecord.iterator;
     JSValue nextFunction = iterationRecord.nextMethod;
 
-    CallData nextFunctionCallData;
-    CallType nextFunctionCallType = getCallData(vm, nextFunction, nextFunctionCallData);
-    if (nextFunctionCallType == CallType::None)
+    auto nextFunctionCallData = getCallData(vm, nextFunction);
+    if (nextFunctionCallData.type == CallData::Type::None)
         return throwTypeError(globalObject, scope);
 
     MarkedArgumentBuffer nextFunctionArguments;
     if (!argument.isEmpty())
         nextFunctionArguments.append(argument);
     ASSERT(!nextFunctionArguments.hasOverflowed());
-    JSValue result = call(globalObject, nextFunction, nextFunctionCallType, nextFunctionCallData, iterator, nextFunctionArguments);
+    JSValue result = call(globalObject, nextFunction, nextFunctionCallData, iterator, nextFunctionArguments);
     RETURN_IF_EXCEPTION(scope, JSValue());
 
     if (!result.isObject())
@@ -105,9 +104,8 @@ void iteratorClose(JSGlobalObject* globalObject, IterationRecord iterationRecord
         return;
     }
 
-    CallData returnFunctionCallData;
-    CallType returnFunctionCallType = getCallData(vm, returnFunction, returnFunctionCallData);
-    if (returnFunctionCallType == CallType::None) {
+    auto returnFunctionCallData = getCallData(vm, returnFunction);
+    if (returnFunctionCallData.type == CallData::Type::None) {
         if (exception)
             throwException(globalObject, throwScope, exception);
         else
@@ -117,7 +115,7 @@ void iteratorClose(JSGlobalObject* globalObject, IterationRecord iterationRecord
 
     MarkedArgumentBuffer returnFunctionArguments;
     ASSERT(!returnFunctionArguments.hasOverflowed());
-    JSValue innerResult = call(globalObject, returnFunction, returnFunctionCallType, returnFunctionCallData, iterationRecord.iterator, returnFunctionArguments);
+    JSValue innerResult = call(globalObject, returnFunction, returnFunctionCallData, iterationRecord.iterator, returnFunctionArguments);
 
     if (exception) {
         throwException(globalObject, throwScope, exception);
@@ -165,8 +163,7 @@ bool hasIteratorMethod(JSGlobalObject* globalObject, JSValue value)
 
     JSObject* object = asObject(value);
     CallData callData;
-    CallType callType;
-    JSValue applyMethod = object->getMethod(globalObject, callData, callType, vm.propertyNames->iteratorSymbol, "Symbol.iterator property should be callable"_s);
+    JSValue applyMethod = object->getMethod(globalObject, callData, vm.propertyNames->iteratorSymbol, "Symbol.iterator property should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
 
     return !applyMethod.isUndefined();
@@ -178,8 +175,7 @@ JSValue iteratorMethod(JSGlobalObject* globalObject, JSObject* object)
     auto scope = DECLARE_THROW_SCOPE(vm);
 
     CallData callData;
-    CallType callType;
-    JSValue method = object->getMethod(globalObject, callData, callType, vm.propertyNames->iteratorSymbol, "Symbol.iterator property should be callable"_s);
+    JSValue method = object->getMethod(globalObject, callData, vm.propertyNames->iteratorSymbol, "Symbol.iterator property should be callable"_s);
     RETURN_IF_EXCEPTION(scope, jsUndefined());
 
     return method;
@@ -190,15 +186,14 @@ IterationRecord iteratorForIterable(JSGlobalObject* globalObject, JSObject* obje
     VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    CallData iteratorMethodCallData;
-    CallType iteratorMethodCallType = getCallData(vm, iteratorMethod, iteratorMethodCallData);
-    if (iteratorMethodCallType == CallType::None) {
+    auto iteratorMethodCallData = getCallData(vm, iteratorMethod);
+    if (iteratorMethodCallData.type == CallData::Type::None) {
         throwTypeError(globalObject, scope);
         return { };
     }
 
     ArgList iteratorMethodArguments;
-    JSValue iterator = call(globalObject, iteratorMethod, iteratorMethodCallType, iteratorMethodCallData, object, iteratorMethodArguments);
+    JSValue iterator = call(globalObject, iteratorMethod, iteratorMethodCallData, object, iteratorMethodArguments);
     RETURN_IF_EXCEPTION(scope, { });
 
     if (!iterator.isObject()) {
@@ -220,15 +215,14 @@ IterationRecord iteratorForIterable(JSGlobalObject* globalObject, JSValue iterab
     JSValue iteratorFunction = iterable.get(globalObject, vm.propertyNames->iteratorSymbol);
     RETURN_IF_EXCEPTION(scope, { });
     
-    CallData iteratorFunctionCallData;
-    CallType iteratorFunctionCallType = getCallData(vm, iteratorFunction, iteratorFunctionCallData);
-    if (iteratorFunctionCallType == CallType::None) {
+    auto iteratorFunctionCallData = getCallData(vm, iteratorFunction);
+    if (iteratorFunctionCallData.type == CallData::Type::None) {
         throwTypeError(globalObject, scope);
         return { };
     }
 
     ArgList iteratorFunctionArguments;
-    JSValue iterator = call(globalObject, iteratorFunction, iteratorFunctionCallType, iteratorFunctionCallData, iterable, iteratorFunctionArguments);
+    JSValue iterator = call(globalObject, iteratorFunction, iteratorFunctionCallData, iterable, iteratorFunctionArguments);
     RETURN_IF_EXCEPTION(scope, { });
 
     if (!iterator.isObject()) {
index 5b418f1..8168593 100644 (file)
@@ -57,10 +57,9 @@ EncodedJSValue JSC_HOST_CALL boundThisNoArgsFunctionCall(JSGlobalObject* globalO
         // Force the executable to cache its arity entrypoint.
         executable->entrypointFor(CodeForCall, MustCheckArity);
     }
-    CallData callData;
-    CallType callType = getCallData(globalObject->vm(), targetFunction, callData);
-    ASSERT(callType != CallType::None);
-    return JSValue::encode(call(globalObject, targetFunction, callType, callData, boundFunction->boundThis(), args));
+    auto callData = getCallData(globalObject->vm(), targetFunction);
+    ASSERT(callData.type != CallData::Type::None);
+    return JSValue::encode(call(globalObject, targetFunction, callData, boundFunction->boundThis(), args));
 }
 
 EncodedJSValue JSC_HOST_CALL boundFunctionCall(JSGlobalObject* globalObject, CallFrame* callFrame)
@@ -85,10 +84,9 @@ EncodedJSValue JSC_HOST_CALL boundFunctionCall(JSGlobalObject* globalObject, Cal
     }
 
     JSObject* targetFunction = boundFunction->targetFunction();
-    CallData callData;
-    CallType callType = getCallData(vm, targetFunction, callData);
-    ASSERT(callType != CallType::None);
-    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, targetFunction, callType, callData, boundFunction->boundThis(), args)));
+    auto callData = getCallData(vm, targetFunction);
+    ASSERT(callData.type != CallData::Type::None);
+    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, targetFunction, callData, boundFunction->boundThis(), args)));
 }
 
 EncodedJSValue JSC_HOST_CALL boundThisNoArgsFunctionConstruct(JSGlobalObject* globalObject, CallFrame* callFrame)
@@ -108,14 +106,13 @@ EncodedJSValue JSC_HOST_CALL boundThisNoArgsFunctionConstruct(JSGlobalObject* gl
     RELEASE_ASSERT(!args.hasOverflowed());
 
     JSFunction* targetFunction = jsCast<JSFunction*>(boundFunction->targetFunction());
-    ConstructData constructData;
-    ConstructType constructType = getConstructData(globalObject->vm(), targetFunction, constructData);
-    ASSERT(constructType != ConstructType::None);
+    auto constructData = getConstructData(globalObject->vm(), targetFunction);
+    ASSERT(constructData.type != CallData::Type::None);
 
     JSValue newTarget = callFrame->newTarget();
     if (newTarget == boundFunction)
         newTarget = targetFunction;
-    return JSValue::encode(construct(globalObject, targetFunction, constructType, constructData, args, newTarget));
+    return JSValue::encode(construct(globalObject, targetFunction, constructData, args, newTarget));
 }
 
 EncodedJSValue JSC_HOST_CALL boundFunctionConstruct(JSGlobalObject* globalObject, CallFrame* callFrame)
@@ -140,14 +137,13 @@ EncodedJSValue JSC_HOST_CALL boundFunctionConstruct(JSGlobalObject* globalObject
     }
 
     JSObject* targetFunction = boundFunction->targetFunction();
-    ConstructData constructData;
-    ConstructType constructType = getConstructData(vm, targetFunction, constructData);
-    ASSERT(constructType != ConstructType::None);
+    auto constructData = getConstructData(vm, targetFunction);
+    ASSERT(constructData.type != CallData::Type::None);
 
     JSValue newTarget = callFrame->newTarget();
     if (newTarget == boundFunction)
         newTarget = targetFunction;
-    RELEASE_AND_RETURN(scope, JSValue::encode(construct(globalObject, targetFunction, constructType, constructData, args, newTarget)));
+    RELEASE_AND_RETURN(scope, JSValue::encode(construct(globalObject, targetFunction, constructData, args, newTarget)));
 }
 
 EncodedJSValue JSC_HOST_CALL isBoundFunction(JSGlobalObject* globalObject, CallFrame* callFrame)
index 2d826d4..923863d 100644 (file)
@@ -83,10 +83,7 @@ using WriteBarrierTraitsSelect = typename std::conditional<std::is_same<T, Unkno
 
 enum PreferredPrimitiveType : uint8_t { NoPreference, PreferNumber, PreferString };
 
-enum class CallType : unsigned;
 struct CallData;
-enum class ConstructType : unsigned;
-struct ConstructData;
 
 typedef int64_t EncodedJSValue;
     
index 065979e..7d3a2d5 100644 (file)
@@ -95,20 +95,14 @@ const JSObject* JSCell::getObject() const
     return isObject() ? static_cast<const JSObject*>(this) : 0;
 }
 
-CallType JSCell::getCallData(JSCell*, CallData& callData)
+CallData JSCell::getCallData(JSCell*)
 {
-    callData.js.functionExecutable = nullptr;
-    callData.js.scope = nullptr;
-    callData.native.function = nullptr;
-    return CallType::None;
+    return { };
 }
 
-ConstructType JSCell::getConstructData(JSCell*, ConstructData& constructData)
+CallData JSCell::getConstructData(JSCell*)
 {
-    constructData.js.functionExecutable = nullptr;
-    constructData.js.scope = nullptr;
-    constructData.native.function = nullptr;
-    return ConstructType::None;
+    return { };
 }
 
 bool JSCell::put(JSCell* cell, JSGlobalObject* globalObject, PropertyName identifier, JSValue value, PutPropertySlot& slot)
index aa2e1d2..b8d6f65 100644 (file)
@@ -149,8 +149,8 @@ public:
     // this is an object, then typeof will return "function" instead of "object". These methods
     // cannot change their minds and must be thread-safe. They are sometimes called from compiler
     // threads.
-    JS_EXPORT_PRIVATE static CallType getCallData(JSCell*, CallData&);
-    JS_EXPORT_PRIVATE static ConstructType getConstructData(JSCell*, ConstructData&);
+    JS_EXPORT_PRIVATE static CallData getCallData(JSCell*);
+    JS_EXPORT_PRIVATE static CallData getConstructData(JSCell*);
 
     // Basic conversions.
     JS_EXPORT_PRIVATE JSValue toPrimitive(JSGlobalObject*, PreferredPrimitiveType) const;
index f32f29d..f260730 100644 (file)
@@ -233,17 +233,14 @@ ALWAYS_INLINE bool JSCell::isFunction(VM& vm)
 {
     if (type() == JSFunctionType)
         return true;
-    if (inlineTypeFlags() & OverridesGetCallData) {
-        CallData ignoredCallData;
-        return methodTable(vm)->getCallData(this, ignoredCallData) != CallType::None;
-    }
+    if (inlineTypeFlags() & OverridesGetCallData)
+        return methodTable(vm)->getCallData(this).type != CallData::Type::None;
     return false;
 }
 
 inline bool JSCell::isConstructor(VM& vm)
 {
-    ConstructData ignoredConstructData;
-    return methodTable(vm)->getConstructData(this, ignoredConstructData) != ConstructType::None;
+    return methodTable(vm)->getConstructData(this).type != CallData::Type::None;
 }
 
 inline bool JSCell::isAPIValueWrapper() const
index af08b8a..9e3491f 100644 (file)
@@ -274,16 +274,21 @@ void JSFunction::visitChildren(JSCell* cell, SlotVisitor& visitor)
     visitor.appendUnbarriered(bitwise_cast<JSCell*>(bitwise_cast<uintptr_t>(thisObject->m_executableOrRareData) & ~rareDataTag));
 }
 
-CallType JSFunction::getCallData(JSCell* cell, CallData& callData)
+CallData JSFunction::getCallData(JSCell* cell)
 {
+    CallData callData;
+
     JSFunction* thisObject = jsCast<JSFunction*>(cell);
     if (thisObject->isHostFunction()) {
+        callData.type = CallData::Type::Native;
         callData.native.function = thisObject->nativeFunction();
-        return CallType::Host;
+    } else {
+        callData.type = CallData::Type::JS;
+        callData.js.functionExecutable = thisObject->jsExecutable();
+        callData.js.scope = thisObject->scope();
     }
-    callData.js.functionExecutable = thisObject->jsExecutable();
-    callData.js.scope = thisObject->scope();
-    return CallType::JS;
+
+    return callData;
 }
 
 class RetrieveArgumentsFunctor {
@@ -691,24 +696,26 @@ bool JSFunction::defineOwnProperty(JSObject* object, JSGlobalObject* globalObjec
 }
 
 // ECMA 13.2.2 [[Construct]]
-ConstructType JSFunction::getConstructData(JSCell* cell, ConstructData& constructData)
+CallData JSFunction::getConstructData(JSCell* cell)
 {
-    JSFunction* thisObject = jsCast<JSFunction*>(cell);
+    CallData constructData;
 
+    JSFunction* thisObject = jsCast<JSFunction*>(cell);
     if (thisObject->isHostFunction()) {
-        if (thisObject->nativeConstructor() == callHostFunctionAsConstructor)
-            return ConstructType::None;
-        constructData.native.function = thisObject->nativeConstructor();
-        return ConstructType::Host;
+        if (thisObject->nativeConstructor() != callHostFunctionAsConstructor) {
+            constructData.type = CallData::Type::Native;
+            constructData.native.function = thisObject->nativeConstructor();
+        }
+    } else {
+        FunctionExecutable* functionExecutable = thisObject->jsExecutable();
+        if (functionExecutable->constructAbility() != ConstructAbility::CannotConstruct) {
+            constructData.type = CallData::Type::JS;
+            constructData.js.functionExecutable = functionExecutable;
+            constructData.js.scope = thisObject->scope();
+        }
     }
 
-    FunctionExecutable* functionExecutable = thisObject->jsExecutable();
-    if (functionExecutable->constructAbility() == ConstructAbility::CannotConstruct)
-        return ConstructType::None;
-
-    constructData.js.functionExecutable = functionExecutable;
-    constructData.js.scope = thisObject->scope();
-    return ConstructType::JS;
+    return constructData;
 }
 
 String getCalculatedDisplayName(VM& vm, JSObject* object)
index 7b02a95..243068d 100644 (file)
@@ -118,8 +118,8 @@ public:
     TaggedNativeFunction nativeFunction();
     TaggedNativeFunction nativeConstructor();
 
-    JS_EXPORT_PRIVATE static ConstructType getConstructData(JSCell*, ConstructData&);
-    JS_EXPORT_PRIVATE static CallType getCallData(JSCell*, CallData&);
+    JS_EXPORT_PRIVATE static CallData getConstructData(JSCell*);
+    JS_EXPORT_PRIVATE static CallData getCallData(JSCell*);
 
     static inline ptrdiff_t offsetOfExecutableOrRareData()
     {
index e1f0ab5..eeca836 100644 (file)
@@ -62,16 +62,15 @@ JSInternalPromise* JSInternalPromise::then(JSGlobalObject* globalObject, JSFunct
 
     JSObject* function = jsCast<JSObject*>(get(globalObject, vm.propertyNames->builtinNames().thenPublicName()));
     RETURN_IF_EXCEPTION(scope, nullptr);
-    CallData callData;
-    CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(onFulfilled ? onFulfilled : jsUndefined());
     arguments.append(onRejected ? onRejected : jsUndefined());
     ASSERT(!arguments.hasOverflowed());
 
-    RELEASE_AND_RETURN(scope, jsCast<JSInternalPromise*>(call(globalObject, function, callType, callData, this, arguments)));
+    RELEASE_AND_RETURN(scope, jsCast<JSInternalPromise*>(call(globalObject, function, callData, this, arguments)));
 }
 
 } // namespace JSC
index b03cc0c..3a53fcb 100644 (file)
@@ -76,9 +76,8 @@ void JSMicrotask::run(JSGlobalObject* globalObject)
     VM& vm = globalObject->vm();
     auto scope = DECLARE_CATCH_SCOPE(vm);
 
-    CallData handlerCallData;
-    CallType handlerCallType = getCallData(vm, m_job.get(), handlerCallData);
-    ASSERT(handlerCallType != CallType::None);
+    auto handlerCallData = getCallData(vm, m_job.get());
+    ASSERT(handlerCallData.type != CallData::Type::None);
 
     MarkedArgumentBuffer handlerArguments;
     for (unsigned index = 0; index < maxArguments; ++index) {
@@ -93,7 +92,7 @@ void JSMicrotask::run(JSGlobalObject* globalObject)
     if (UNLIKELY(globalObject->hasDebugger()))
         globalObject->debugger()->willRunMicrotask();
 
-    profiledCall(globalObject, ProfilingReason::Microtask, m_job.get(), handlerCallType, handlerCallData, jsUndefined(), handlerArguments);
+    profiledCall(globalObject, ProfilingReason::Microtask, m_job.get(), handlerCallData, jsUndefined(), handlerArguments);
     scope.clearException();
 }
 
index 274d2cc..89b3467 100644 (file)
@@ -131,14 +131,13 @@ JSArray* JSModuleLoader::dependencyKeysIfEvaluated(JSGlobalObject* globalObject,
 
     JSObject* function = jsCast<JSObject*>(get(globalObject, vm.propertyNames->builtinNames().dependencyKeysIfEvaluatedPublicName()));
     RETURN_IF_EXCEPTION(scope, nullptr);
-    CallData callData;
-    CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(key);
 
-    JSValue result = call(globalObject, function, callType, callData, this, arguments);
+    JSValue result = call(globalObject, function, callData, this, arguments);
     RETURN_IF_EXCEPTION(scope, nullptr);
 
     return jsDynamicCast<JSArray*>(vm, result);
@@ -151,9 +150,8 @@ JSValue JSModuleLoader::provideFetch(JSGlobalObject* globalObject, JSValue key,
 
     JSObject* function = jsCast<JSObject*>(get(globalObject, vm.propertyNames->builtinNames().provideFetchPublicName()));
     RETURN_IF_EXCEPTION(scope, { });
-    CallData callData;
-    CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != CallData::Type::None);
 
     SourceCode source { sourceCode };
     MarkedArgumentBuffer arguments;
@@ -161,7 +159,7 @@ JSValue JSModuleLoader::provideFetch(JSGlobalObject* globalObject, JSValue key,
     arguments.append(JSSourceCode::create(vm, WTFMove(source)));
     ASSERT(!arguments.hasOverflowed());
 
-    RELEASE_AND_RETURN(scope, call(globalObject, function, callType, callData, this, arguments));
+    RELEASE_AND_RETURN(scope, call(globalObject, function, callData, this, arguments));
 }
 
 JSInternalPromise* JSModuleLoader::loadAndEvaluateModule(JSGlobalObject* globalObject, JSValue moduleName, JSValue parameters, JSValue scriptFetcher)
@@ -171,9 +169,8 @@ JSInternalPromise* JSModuleLoader::loadAndEvaluateModule(JSGlobalObject* globalO
 
     JSObject* function = jsCast<JSObject*>(get(globalObject, vm.propertyNames->builtinNames().loadAndEvaluateModulePublicName()));
     RETURN_IF_EXCEPTION(scope, nullptr);
-    CallData callData;
-    CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(moduleName);
@@ -181,7 +178,7 @@ JSInternalPromise* JSModuleLoader::loadAndEvaluateModule(JSGlobalObject* globalO
     arguments.append(scriptFetcher);
     ASSERT(!arguments.hasOverflowed());
 
-    JSValue promise = call(globalObject, function, callType, callData, this, arguments);
+    JSValue promise = call(globalObject, function, callData, this, arguments);
     RETURN_IF_EXCEPTION(scope, nullptr);
     return jsCast<JSInternalPromise*>(promise);
 }
@@ -193,9 +190,8 @@ JSInternalPromise* JSModuleLoader::loadModule(JSGlobalObject* globalObject, JSVa
 
     JSObject* function = jsCast<JSObject*>(get(globalObject, vm.propertyNames->builtinNames().loadModulePublicName()));
     RETURN_IF_EXCEPTION(scope, nullptr);
-    CallData callData;
-    CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(moduleName);
@@ -203,7 +199,7 @@ JSInternalPromise* JSModuleLoader::loadModule(JSGlobalObject* globalObject, JSVa
     arguments.append(scriptFetcher);
     ASSERT(!arguments.hasOverflowed());
 
-    JSValue promise = call(globalObject, function, callType, callData, this, arguments);
+    JSValue promise = call(globalObject, function, callData, this, arguments);
     RETURN_IF_EXCEPTION(scope, nullptr);
     return jsCast<JSInternalPromise*>(promise);
 }
@@ -215,16 +211,15 @@ JSValue JSModuleLoader::linkAndEvaluateModule(JSGlobalObject* globalObject, JSVa
 
     JSObject* function = jsCast<JSObject*>(get(globalObject, vm.propertyNames->builtinNames().linkAndEvaluateModulePublicName()));
     RETURN_IF_EXCEPTION(scope, { });
-    CallData callData;
-    CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(moduleKey);
     arguments.append(scriptFetcher);
     ASSERT(!arguments.hasOverflowed());
 
-    RELEASE_AND_RETURN(scope, call(globalObject, function, callType, callData, this, arguments));
+    RELEASE_AND_RETURN(scope, call(globalObject, function, callData, this, arguments));
 }
 
 JSInternalPromise* JSModuleLoader::requestImportModule(JSGlobalObject* globalObject, const Identifier& moduleKey, JSValue parameters, JSValue scriptFetcher)
@@ -234,9 +229,8 @@ JSInternalPromise* JSModuleLoader::requestImportModule(JSGlobalObject* globalObj
 
     auto* function = jsCast<JSObject*>(get(globalObject, vm.propertyNames->builtinNames().requestImportModulePublicName()));
     RETURN_IF_EXCEPTION(scope, nullptr);
-    CallData callData;
-    auto callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(jsString(vm, moduleKey.impl()));
@@ -244,7 +238,7 @@ JSInternalPromise* JSModuleLoader::requestImportModule(JSGlobalObject* globalObj
     arguments.append(scriptFetcher);
     ASSERT(!arguments.hasOverflowed());
 
-    JSValue promise = call(globalObject, function, callType, callData, this, arguments);
+    JSValue promise = call(globalObject, function, callData, this, arguments);
     RETURN_IF_EXCEPTION(scope, nullptr);
     return jsCast<JSInternalPromise*>(promise);
 }
index b37458b..dbd7b2e 100644 (file)
@@ -121,13 +121,12 @@ private:
     void indent();
     void unindent();
     void startNewLine(StringBuilder&) const;
-    bool isCallableReplacer() const { return m_replacerCallType != CallType::None; }
+    bool isCallableReplacer() const { return m_replacerCallData.type != CallData::Type::None; }
 
     JSGlobalObject* const m_globalObject;
     JSValue m_replacer;
     bool m_usingArrayReplacer { false };
     PropertyNameArray m_arrayReplacerPropertyNames;
-    CallType m_replacerCallType { CallType::None };
     CallData m_replacerCallData;
     String m_gap;
 
@@ -231,8 +230,8 @@ Stringifier::Stringifier(JSGlobalObject* globalObject, JSValue replacer, JSValue
     if (m_replacer.isObject()) {
         JSObject* replacerObject = asObject(m_replacer);
 
-        m_replacerCallType = getCallData(vm, replacerObject, m_replacerCallData);
-        if (m_replacerCallType == CallType::None) {
+        m_replacerCallData = getCallData(vm, replacerObject);
+        if (m_replacerCallData.type == CallData::Type::None) {
             bool isArrayReplacer = JSC::isArray(globalObject, replacerObject);
             RETURN_IF_EXCEPTION(scope, );
             if (isArrayReplacer) {
@@ -304,15 +303,14 @@ ALWAYS_INLINE JSValue Stringifier::toJSON(JSValue baseValue, const PropertyNameF
     JSValue toJSONFunction = baseValue.get(m_globalObject, vm.propertyNames->toJSON);
     RETURN_IF_EXCEPTION(scope, { });
 
-    CallData callData;
-    CallType callType = getCallData(vm, toJSONFunction, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, toJSONFunction);
+    if (callData.type == CallData::Type::None)
         return baseValue;
 
     MarkedArgumentBuffer args;
     args.append(propertyName.value(m_globalObject));
     ASSERT(!args.hasOverflowed());
-    RELEASE_AND_RETURN(scope, call(m_globalObject, asObject(toJSONFunction), callType, callData, baseValue, args));
+    RELEASE_AND_RETURN(scope, call(m_globalObject, asObject(toJSONFunction), callData, baseValue, args));
 }
 
 Stringifier::StringifyResult Stringifier::appendStringifiedValue(StringBuilder& builder, JSValue value, const Holder& holder, const PropertyNameForFunctionCall& propertyName)
@@ -333,7 +331,7 @@ Stringifier::StringifyResult Stringifier::appendStringifiedValue(StringBuilder&
         args.append(value);
         ASSERT(!args.hasOverflowed());
         ASSERT(holder.object());
-        value = call(m_globalObject, m_replacer, m_replacerCallType, m_replacerCallData, holder.object(), args);
+        value = call(m_globalObject, m_replacer, m_replacerCallData, holder.object(), args);
         RETURN_IF_EXCEPTION(scope, StringifyFailed);
     }
 
@@ -591,10 +589,9 @@ class Walker {
     WTF_MAKE_NONCOPYABLE(Walker);
     WTF_FORBID_HEAP_ALLOCATION;
 public:
-    Walker(JSGlobalObject* globalObject, JSObject* function, CallType callType, CallData callData)
+    Walker(JSGlobalObject* globalObject, JSObject* function, CallData callData)
         : m_globalObject(globalObject)
         , m_function(function)
-        , m_callType(callType)
         , m_callData(callData)
     {
     }
@@ -606,14 +603,13 @@ private:
         args.append(property);
         args.append(unfiltered);
         ASSERT(!args.hasOverflowed());
-        return call(m_globalObject, m_function, m_callType, m_callData, thisObj, args);
+        return call(m_globalObject, m_function, m_callData, thisObj, args);
     }
 
     friend class Holder;
 
     JSGlobalObject* m_globalObject;
     JSObject* m_function;
-    CallType m_callType;
     CallData m_callData;
 };
 
@@ -800,12 +796,11 @@ EncodedJSValue JSC_HOST_CALL JSONProtoFuncParse(JSGlobalObject* globalObject, Ca
         return JSValue::encode(unfiltered);
     
     JSValue function = callFrame->uncheckedArgument(1);
-    CallData callData;
-    CallType callType = getCallData(vm, function, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, function);
+    if (callData.type == CallData::Type::None)
         return JSValue::encode(unfiltered);
     scope.release();
-    Walker walker(globalObject, asObject(function), callType, callData);
+    Walker walker(globalObject, asObject(function), callData);
     return JSValue::encode(walker.walk(unfiltered));
 }
 
index 9c5d55a..e3ce28d 100644 (file)
@@ -767,10 +767,9 @@ bool ordinarySetSlow(JSGlobalObject* globalObject, JSObject* object, PropertyNam
     args.append(value);
     ASSERT(!args.hasOverflowed());
 
-    CallData callData;
-    CallType callType = setterObject->methodTable(vm)->getCallData(setterObject, callData);
+    auto callData = getCallData(vm, setterObject);
     scope.release();
-    call(globalObject, setterObject, callType, callData, receiver, args);
+    call(globalObject, setterObject, callData, receiver, args);
 
     // 9.1.9.1-9 Return true.
     return true;
@@ -2117,9 +2116,8 @@ static ALWAYS_INLINE JSValue callToPrimitiveFunction(JSGlobalObject* globalObjec
     RETURN_IF_EXCEPTION(scope, scope.exception());
     if (function.isUndefinedOrNull() && mode == TypeHintMode::TakesHint)
         return JSValue();
-    CallData callData;
-    CallType callType = getCallData(vm, function, callData);
-    if (callType == CallType::None) {
+    auto callData = getCallData(vm, function);
+    if (callData.type == CallData::Type::None) {
         if (mode == TypeHintMode::TakesHint)
             throwTypeError(globalObject, scope, "Symbol.toPrimitive is not a function, undefined, or null"_s);
         return scope.exception();
@@ -2143,7 +2141,7 @@ static ALWAYS_INLINE JSValue callToPrimitiveFunction(JSGlobalObject* globalObjec
     }
     ASSERT(!callArgs.hasOverflowed());
 
-    JSValue result = call(globalObject, function, callType, callData, const_cast<JSObject*>(object), callArgs);
+    JSValue result = call(globalObject, function, callData, const_cast<JSObject*>(object), callArgs);
     RETURN_IF_EXCEPTION(scope, scope.exception());
     ASSERT(!result.isGetterSetter());
     if (result.isObject())
@@ -2240,9 +2238,8 @@ bool JSObject::hasInstance(JSGlobalObject* globalObject, JSValue value, JSValue
     auto scope = DECLARE_THROW_SCOPE(vm);
 
     if (!hasInstanceValue.isUndefinedOrNull() && hasInstanceValue != globalObject->functionProtoHasInstanceSymbolFunction()) {
-        CallData callData;
-        CallType callType = JSC::getCallData(vm, hasInstanceValue, callData);
-        if (callType == CallType::None) {
+        auto callData = JSC::getCallData(vm, hasInstanceValue);
+        if (callData.type == CallData::Type::None) {
             throwException(globalObject, scope, createInvalidInstanceofParameterErrorHasInstanceValueNotFunction(globalObject, this));
             return false;
         }
@@ -2250,7 +2247,7 @@ bool JSObject::hasInstance(JSGlobalObject* globalObject, JSValue value, JSValue
         MarkedArgumentBuffer args;
         args.append(value);
         ASSERT(!args.hasOverflowed());
-        JSValue result = call(globalObject, hasInstanceValue, callType, callData, this, args);
+        JSValue result = call(globalObject, hasInstanceValue, callData, this, args);
         RETURN_IF_EXCEPTION(scope, false);
         return result.toBoolean(globalObject);
     }
@@ -3869,7 +3866,7 @@ void JSObject::getGenericPropertyNames(JSObject* object, JSGlobalObject* globalO
 
 // Implements GetMethod(O, P) in section 7.3.9 of the spec.
 // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-getmethod
-JSValue JSObject::getMethod(JSGlobalObject* globalObject, CallData& callData, CallType& callType, const Identifier& ident, const String& errorMessage)
+JSValue JSObject::getMethod(JSGlobalObject* globalObject, CallData& callData, const Identifier& ident, const String& errorMessage)
 {
     VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
@@ -3885,8 +3882,8 @@ JSValue JSObject::getMethod(JSGlobalObject* globalObject, CallData& callData, Ca
         return jsUndefined();
     }
 
-    callType = method.asCell()->methodTable(vm)->getCallData(method.asCell(), callData);
-    if (callType == CallType::None) {
+    callData = JSC::getCallData(vm, method);
+    if (callData.type == CallData::Type::None) {
         throwVMTypeError(globalObject, scope, errorMessage);
         return jsUndefined();
     }
index a6878a6..5633f42 100644 (file)
@@ -900,7 +900,7 @@ public:
         return &m_butterfly;
     }
 
-    JS_EXPORT_PRIVATE JSValue getMethod(JSGlobalObject*, CallData&, CallType&, const Identifier&, const String& errorMessage);
+    JS_EXPORT_PRIVATE JSValue getMethod(JSGlobalObject*, CallData&, const Identifier&, const String& errorMessage);
 
     bool canPerformFastPutInline(VM&, PropertyName);
     bool canPerformFastPutInlineExcludingProto(VM&);
index 51e0bf3..ab44850 100644 (file)
@@ -511,27 +511,27 @@ inline bool JSObject::putOwnDataPropertyMayBeIndex(JSGlobalObject* globalObject,
     return putDirectInternal<PutModePut>(vm, propertyName, value, 0, slot);
 }
 
-inline CallType getCallData(VM& vm, JSValue value, CallData& callData)
+inline CallData getCallData(VM& vm, JSValue value)
 {
     if (!value.isCell())
-        return CallType::None;
+        return { };
     JSCell* cell = value.asCell();
     if (cell->type() == JSFunctionType)
-        return JSFunction::getCallData(cell, callData);
-    CallType result = cell->methodTable(vm)->getCallData(cell, callData);
-    ASSERT(result == CallType::None || value.isValidCallee());
+        return JSFunction::getCallData(cell);
+    CallData result = cell->methodTable(vm)->getCallData(cell);
+    ASSERT(result.type == CallData::Type::None || value.isValidCallee());
     return result;
 }
 
-inline ConstructType getConstructData(VM& vm, JSValue value, ConstructData& constructData)
+inline CallData getConstructData(VM& vm, JSValue value)
 {
     if (!value.isCell())
-        return ConstructType::None;
+        return { };
     JSCell* cell = value.asCell();
     if (cell->type() == JSFunctionType)
-        return JSFunction::getConstructData(cell, constructData);
-    ConstructType result = cell->methodTable(vm)->getConstructData(cell, constructData);
-    ASSERT(result == ConstructType::None || value.isValidCallee());
+        return JSFunction::getConstructData(cell);
+    CallData result = cell->methodTable(vm)->getConstructData(cell);
+    ASSERT(result.type == CallData::Type::None || value.isValidCallee());
     return result;
 }
 
index 09c36e5..e68b1c8 100644 (file)
@@ -107,14 +107,13 @@ JSPromise::DeferredData JSPromise::createDeferredData(JSGlobalObject* globalObje
     auto scope = DECLARE_THROW_SCOPE(vm);
 
     JSFunction* newPromiseCapabilityFunction = globalObject->newPromiseCapabilityFunction();
-    CallData callData;
-    CallType callType = JSC::getCallData(globalObject->vm(), newPromiseCapabilityFunction, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(globalObject->vm(), newPromiseCapabilityFunction);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(promiseConstructor);
     ASSERT(!arguments.hasOverflowed());
-    JSValue deferred = call(globalObject, newPromiseCapabilityFunction, callType, callData, jsUndefined(), arguments);
+    JSValue deferred = call(globalObject, newPromiseCapabilityFunction, callData, jsUndefined(), arguments);
     RETURN_IF_EXCEPTION(scope, { });
 
     DeferredData result;
@@ -134,13 +133,12 @@ JSPromise* JSPromise::resolvedPromise(JSGlobalObject* globalObject, JSValue valu
     auto scope = DECLARE_THROW_SCOPE(vm);
 
     JSFunction* function = globalObject->promiseResolveFunction();
-    CallData callData;
-    CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(value);
-    auto result = call(globalObject, function, callType, callData, globalObject->promiseConstructor(), arguments);
+    auto result = call(globalObject, function, callData, globalObject->promiseConstructor(), arguments);
     RETURN_IF_EXCEPTION(scope, nullptr);
     ASSERT(result.inherits<JSPromise>(vm));
     return jsCast<JSPromise*>(result);
@@ -148,16 +146,15 @@ JSPromise* JSPromise::resolvedPromise(JSGlobalObject* globalObject, JSValue valu
 
 static inline void callFunction(JSGlobalObject* globalObject, JSValue function, JSPromise* promise, JSValue value)
 {
-    CallData callData;
-    CallType callType = getCallData(globalObject->vm(), function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = getCallData(globalObject->vm(), function);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(promise);
     arguments.append(value);
     ASSERT(!arguments.hasOverflowed());
 
-    call(globalObject, function, callType, callData, jsUndefined(), arguments);
+    call(globalObject, function, callData, jsUndefined(), arguments);
 }
 
 void JSPromise::resolve(JSGlobalObject* lexicalGlobalObject, JSValue value)
index ebad029..2097892 100644 (file)
@@ -88,9 +88,8 @@ static EncodedJSValue JSC_HOST_CALL constructMap(JSGlobalObject* globalObject, C
     JSValue adderFunction = map->JSObject::get(globalObject, vm.propertyNames->set);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
 
-    CallData adderFunctionCallData;
-    CallType adderFunctionCallType = getCallData(vm, adderFunction, adderFunctionCallData);
-    if (adderFunctionCallType == CallType::None)
+    auto adderFunctionCallData = getCallData(vm, adderFunction);
+    if (adderFunctionCallData.type == CallData::Type::None)
         return JSValue::encode(throwTypeError(globalObject, scope));
 
     scope.release();
@@ -112,7 +111,7 @@ static EncodedJSValue JSC_HOST_CALL constructMap(JSGlobalObject* globalObject, C
         arguments.append(value);
         ASSERT(!arguments.hasOverflowed());
         scope.release();
-        call(globalObject, adderFunction, adderFunctionCallType, adderFunctionCallData, map, arguments);
+        call(globalObject, adderFunction, adderFunctionCallData, map, arguments);
     });
 
     return JSValue::encode(map);
index 5ee41fa..6fd67df 100644 (file)
@@ -299,13 +299,12 @@ EncodedJSValue JSC_HOST_CALL objectProtoFuncToLocaleString(JSGlobalObject* globa
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
 
     // If IsCallable(toString) is false, throw a TypeError exception.
-    CallData callData;
-    CallType callType = getCallData(vm, toString, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, toString);
+    if (callData.type == CallData::Type::None)
         return throwVMTypeError(globalObject, scope);
 
     // Return the result of calling the [[Call]] internal method of toString passing the this value and no arguments.
-    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, toString, callType, callData, thisValue, *vm.emptyList)));
+    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, toString, callData, thisValue, *vm.emptyList)));
 }
 
 EncodedJSValue JSC_HOST_CALL objectProtoFuncToString(JSGlobalObject* globalObject, CallFrame* callFrame)
index 6e4b15c..da70bd3 100644 (file)
@@ -138,8 +138,7 @@ static JSValue performProxyGet(JSGlobalObject* globalObject, ProxyObject* proxyO
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue getHandler = handler->getMethod(globalObject, callData, callType, vm.propertyNames->get, "'get' property of a Proxy's handler object should be callable"_s);
+    JSValue getHandler = handler->getMethod(globalObject, callData, vm.propertyNames->get, "'get' property of a Proxy's handler object should be callable"_s);
     RETURN_IF_EXCEPTION(scope, { });
 
     if (getHandler.isUndefined())
@@ -150,7 +149,7 @@ static JSValue performProxyGet(JSGlobalObject* globalObject, ProxyObject* proxyO
     arguments.append(identifierToSafePublicJSValue(vm, Identifier::fromUid(vm, propertyName.uid())));
     arguments.append(receiver);
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, getHandler, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, getHandler, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, { });
 
     PropertyDescriptor descriptor;
@@ -213,8 +212,7 @@ bool ProxyObject::performInternalMethodGetOwnProperty(JSGlobalObject* globalObje
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue getOwnPropertyDescriptorMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "getOwnPropertyDescriptor"), "'getOwnPropertyDescriptor' property of a Proxy's handler should be callable"_s);
+    JSValue getOwnPropertyDescriptorMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "getOwnPropertyDescriptor"), "'getOwnPropertyDescriptor' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
     if (getOwnPropertyDescriptorMethod.isUndefined())
         RELEASE_AND_RETURN(scope, performDefaultGetOwnProperty());
@@ -223,7 +221,7 @@ bool ProxyObject::performInternalMethodGetOwnProperty(JSGlobalObject* globalObje
     arguments.append(target);
     arguments.append(identifierToSafePublicJSValue(vm, Identifier::fromUid(vm, propertyName.uid())));
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, getOwnPropertyDescriptorMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, getOwnPropertyDescriptorMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, false);
 
     if (!trapResult.isUndefined() && !trapResult.isObject()) {
@@ -317,8 +315,7 @@ bool ProxyObject::performHasProperty(JSGlobalObject* globalObject, PropertyName
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue hasMethod = handler->getMethod(globalObject, callData, callType, vm.propertyNames->has, "'has' property of a Proxy's handler should be callable"_s);
+    JSValue hasMethod = handler->getMethod(globalObject, callData, vm.propertyNames->has, "'has' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
     if (hasMethod.isUndefined())
         RELEASE_AND_RETURN(scope, performDefaultHasProperty());
@@ -327,7 +324,7 @@ bool ProxyObject::performHasProperty(JSGlobalObject* globalObject, PropertyName
     arguments.append(target);
     arguments.append(identifierToSafePublicJSValue(vm, Identifier::fromUid(vm, propertyName.uid())));
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, hasMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, hasMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, false);
 
     bool trapResultAsBool = trapResult.toBoolean(globalObject);
@@ -420,8 +417,7 @@ bool ProxyObject::performPut(JSGlobalObject* globalObject, JSValue putValue, JSV
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue setMethod = handler->getMethod(globalObject, callData, callType, vm.propertyNames->set, "'set' property of a Proxy's handler should be callable"_s);
+    JSValue setMethod = handler->getMethod(globalObject, callData, vm.propertyNames->set, "'set' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
     JSObject* target = this->target();
     if (setMethod.isUndefined())
@@ -433,7 +429,7 @@ bool ProxyObject::performPut(JSGlobalObject* globalObject, JSValue putValue, JSV
     arguments.append(putValue);
     arguments.append(thisValue);
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, setMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, setMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, false);
     bool trapResultAsBool = trapResult.toBoolean(globalObject);
     RETURN_IF_EXCEPTION(scope, false);
@@ -513,15 +509,13 @@ static EncodedJSValue JSC_HOST_CALL performProxyCall(JSGlobalObject* globalObjec
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue applyMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "apply"), "'apply' property of a Proxy's handler should be callable"_s);
+    JSValue applyMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "apply"), "'apply' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
     JSObject* target = proxy->target();
     if (applyMethod.isUndefined()) {
-        CallData callData;
-        CallType callType = target->methodTable(vm)->getCallData(target, callData);
-        RELEASE_ASSERT(callType != CallType::None);
-        RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, target, callType, callData, callFrame->thisValue(), ArgList(callFrame))));
+        auto callData = getCallData(vm, target);
+        RELEASE_ASSERT(callData.type != CallData::Type::None);
+        RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, target, callData, callFrame->thisValue(), ArgList(callFrame))));
     }
 
     JSArray* argArray = constructArray(globalObject, static_cast<ArrayAllocationProfile*>(nullptr), ArgList(callFrame));
@@ -531,20 +525,18 @@ static EncodedJSValue JSC_HOST_CALL performProxyCall(JSGlobalObject* globalObjec
     arguments.append(callFrame->thisValue().toThis(globalObject, ECMAMode::strict()));
     arguments.append(argArray);
     ASSERT(!arguments.hasOverflowed());
-    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, applyMethod, callType, callData, handler, arguments)));
+    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, applyMethod, callData, handler, arguments)));
 }
 
-CallType ProxyObject::getCallData(JSCell* cell, CallData& callData)
+CallData ProxyObject::getCallData(JSCell* cell)
 {
+    CallData callData;
     ProxyObject* proxy = jsCast<ProxyObject*>(cell);
-    if (!proxy->m_isCallable) {
-        callData.js.functionExecutable = nullptr;
-        callData.js.scope = nullptr;
-        return CallType::None;
+    if (proxy->m_isCallable) {
+        callData.type = CallData::Type::Native;
+        callData.native.function = performProxyCall;
     }
-
-    callData.native.function = performProxyCall;
-    return CallType::Host;
+    return callData;
 }
 
 static EncodedJSValue JSC_HOST_CALL performProxyConstruct(JSGlobalObject* globalObject, CallFrame* callFrame)
@@ -564,15 +556,13 @@ static EncodedJSValue JSC_HOST_CALL performProxyConstruct(JSGlobalObject* global
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue constructMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "construct"), "'construct' property of a Proxy's handler should be callable"_s);
+    JSValue constructMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "construct"), "'construct' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
     JSObject* target = proxy->target();
     if (constructMethod.isUndefined()) {
-        ConstructData constructData;
-        ConstructType constructType = target->methodTable(vm)->getConstructData(target, constructData);
-        RELEASE_ASSERT(constructType != ConstructType::None);
-        RELEASE_AND_RETURN(scope, JSValue::encode(construct(globalObject, target, constructType, constructData, ArgList(callFrame), callFrame->newTarget())));
+        auto constructData = getConstructData(vm, target);
+        RELEASE_ASSERT(constructData.type != CallData::Type::None);
+        RELEASE_AND_RETURN(scope, JSValue::encode(construct(globalObject, target, constructData, ArgList(callFrame), callFrame->newTarget())));
     }
 
     JSArray* argArray = constructArray(globalObject, static_cast<ArrayAllocationProfile*>(nullptr), ArgList(callFrame));
@@ -582,24 +572,22 @@ static EncodedJSValue JSC_HOST_CALL performProxyConstruct(JSGlobalObject* global
     arguments.append(argArray);
     arguments.append(callFrame->newTarget());
     ASSERT(!arguments.hasOverflowed());
-    JSValue result = call(globalObject, constructMethod, callType, callData, handler, arguments);
+    JSValue result = call(globalObject, constructMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
     if (!result.isObject())
         return throwVMTypeError(globalObject, scope, "Result from Proxy handler's 'construct' method should be an object"_s);
     return JSValue::encode(result);
 }
 
-ConstructType ProxyObject::getConstructData(JSCell* cell, ConstructData& constructData)
+CallData ProxyObject::getConstructData(JSCell* cell)
 {
+    CallData constructData;
     ProxyObject* proxy = jsCast<ProxyObject*>(cell);
-    if (!proxy->m_isConstructible) {
-        constructData.js.functionExecutable = nullptr;
-        constructData.js.scope = nullptr;
-        return ConstructType::None;
+    if (proxy->m_isConstructible) {
+        constructData.type = CallData::Type::Native;
+        constructData.native.function = performProxyConstruct;
     }
-
-    constructData.native.function = performProxyConstruct;
-    return ConstructType::Host;
+    return constructData;
 }
 
 template <typename DefaultDeleteFunction>
@@ -625,8 +613,7 @@ bool ProxyObject::performDelete(JSGlobalObject* globalObject, PropertyName prope
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue deletePropertyMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "deleteProperty"), "'deleteProperty' property of a Proxy's handler should be callable"_s);
+    JSValue deletePropertyMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "deleteProperty"), "'deleteProperty' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
     JSObject* target = this->target();
     if (deletePropertyMethod.isUndefined())
@@ -636,7 +623,7 @@ bool ProxyObject::performDelete(JSGlobalObject* globalObject, PropertyName prope
     arguments.append(target);
     arguments.append(identifierToSafePublicJSValue(vm, Identifier::fromUid(vm, propertyName.uid())));
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, deletePropertyMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, deletePropertyMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, false);
 
     bool trapResultAsBool = trapResult.toBoolean(globalObject);
@@ -707,8 +694,7 @@ bool ProxyObject::performPreventExtensions(JSGlobalObject* globalObject)
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue preventExtensionsMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "preventExtensions"), "'preventExtensions' property of a Proxy's handler should be callable"_s);
+    JSValue preventExtensionsMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "preventExtensions"), "'preventExtensions' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
     JSObject* target = this->target();
     if (preventExtensionsMethod.isUndefined())
@@ -717,7 +703,7 @@ bool ProxyObject::performPreventExtensions(JSGlobalObject* globalObject)
     MarkedArgumentBuffer arguments;
     arguments.append(target);
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, preventExtensionsMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, preventExtensionsMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, false);
 
     bool trapResultAsBool = trapResult.toBoolean(globalObject);
@@ -759,8 +745,7 @@ bool ProxyObject::performIsExtensible(JSGlobalObject* globalObject)
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue isExtensibleMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "isExtensible"), "'isExtensible' property of a Proxy's handler should be callable"_s);
+    JSValue isExtensibleMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "isExtensible"), "'isExtensible' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
 
     JSObject* target = this->target();
@@ -770,7 +755,7 @@ bool ProxyObject::performIsExtensible(JSGlobalObject* globalObject)
     MarkedArgumentBuffer arguments;
     arguments.append(target);
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, isExtensibleMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, isExtensibleMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, false);
 
     bool trapResultAsBool = trapResult.toBoolean(globalObject);
@@ -825,8 +810,7 @@ bool ProxyObject::performDefineOwnProperty(JSGlobalObject* globalObject, Propert
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue definePropertyMethod = handler->getMethod(globalObject, callData, callType, vm.propertyNames->defineProperty, "'defineProperty' property of a Proxy's handler should be callable"_s);
+    JSValue definePropertyMethod = handler->getMethod(globalObject, callData, vm.propertyNames->defineProperty, "'defineProperty' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
 
     if (definePropertyMethod.isUndefined())
@@ -841,7 +825,7 @@ bool ProxyObject::performDefineOwnProperty(JSGlobalObject* globalObject, Propert
     arguments.append(identifierToSafePublicJSValue(vm, Identifier::fromUid(vm, propertyName.uid())));
     arguments.append(descriptorObject);
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, definePropertyMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, definePropertyMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, false);
 
     bool trapResultAsBool = trapResult.toBoolean(globalObject);
@@ -922,8 +906,7 @@ void ProxyObject::performGetOwnPropertyNames(JSGlobalObject* globalObject, Prope
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue ownKeysMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "ownKeys"), "'ownKeys' property of a Proxy's handler should be callable"_s);
+    JSValue ownKeysMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "ownKeys"), "'ownKeys' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, void());
     JSObject* target = this->target();
     EnumerationMode enumerationMode(DontEnumPropertiesMode::Include);
@@ -936,7 +919,7 @@ void ProxyObject::performGetOwnPropertyNames(JSGlobalObject* globalObject, Prope
     MarkedArgumentBuffer arguments;
     arguments.append(target);
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, ownKeysMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, ownKeysMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, void());
 
     HashSet<UniquedStringImpl*> uncheckedResultKeys;
@@ -1101,8 +1084,7 @@ bool ProxyObject::performSetPrototype(JSGlobalObject* globalObject, JSValue prot
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue setPrototypeOfMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "setPrototypeOf"), "'setPrototypeOf' property of a Proxy's handler should be callable"_s);
+    JSValue setPrototypeOfMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "setPrototypeOf"), "'setPrototypeOf' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, false);
 
     JSObject* target = this->target();
@@ -1113,7 +1095,7 @@ bool ProxyObject::performSetPrototype(JSGlobalObject* globalObject, JSValue prot
     arguments.append(target);
     arguments.append(prototype);
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, setPrototypeOfMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, setPrototypeOfMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, false);
 
     bool trapResultAsBool = trapResult.toBoolean(globalObject);
@@ -1166,8 +1148,7 @@ JSValue ProxyObject::performGetPrototype(JSGlobalObject* globalObject)
 
     JSObject* handler = jsCast<JSObject*>(handlerValue);
     CallData callData;
-    CallType callType;
-    JSValue getPrototypeOfMethod = handler->getMethod(globalObject, callData, callType, makeIdentifier(vm, "getPrototypeOf"), "'getPrototypeOf' property of a Proxy's handler should be callable"_s);
+    JSValue getPrototypeOfMethod = handler->getMethod(globalObject, callData, makeIdentifier(vm, "getPrototypeOf"), "'getPrototypeOf' property of a Proxy's handler should be callable"_s);
     RETURN_IF_EXCEPTION(scope, { });
 
     JSObject* target = this->target();
@@ -1177,7 +1158,7 @@ JSValue ProxyObject::performGetPrototype(JSGlobalObject* globalObject)
     MarkedArgumentBuffer arguments;
     arguments.append(target);
     ASSERT(!arguments.hasOverflowed());
-    JSValue trapResult = call(globalObject, getPrototypeOfMethod, callType, callData, handler, arguments);
+    JSValue trapResult = call(globalObject, getPrototypeOfMethod, callData, handler, arguments);
     RETURN_IF_EXCEPTION(scope, { });
 
     if (!trapResult.isObject() && !trapResult.isNull()) {
index ee5bd90..cc3772e 100644 (file)
@@ -83,8 +83,8 @@ private:
     static String toStringName(const JSObject*, JSGlobalObject*);
     static bool getOwnPropertySlot(JSObject*, JSGlobalObject*, PropertyName, PropertySlot&);
     static bool getOwnPropertySlotByIndex(JSObject*, JSGlobalObject*, unsigned propertyName, PropertySlot&);
-    static CallType getCallData(JSCell*, CallData&);
-    static ConstructType getConstructData(JSCell*, ConstructData&);
+    static CallData getCallData(JSCell*);
+    static CallData getConstructData(JSCell*);
     static bool deleteProperty(JSCell*, JSGlobalObject*, PropertyName, DeletePropertySlot&);
     static bool deletePropertyByIndex(JSCell*, JSGlobalObject*, unsigned propertyName);
     static bool preventExtensions(JSObject*, JSGlobalObject*);
index 4bc8d4c..3387cfe 100644 (file)
@@ -96,9 +96,8 @@ EncodedJSValue JSC_HOST_CALL reflectObjectConstruct(JSGlobalObject* globalObject
     if (!target.isObject())
         return JSValue::encode(throwTypeError(globalObject, scope, "Reflect.construct requires the first argument be a constructor"_s));
 
-    ConstructData constructData;
-    ConstructType constructType = getConstructData(vm, target, constructData);
-    if (constructType == ConstructType::None)
+    auto constructData = getConstructData(vm, target);
+    if (constructData.type == CallData::Type::None)
         return JSValue::encode(throwTypeError(globalObject, scope, "Reflect.construct requires the first argument be a constructor"_s));
 
     JSValue newTarget = target;
@@ -123,7 +122,7 @@ EncodedJSValue JSC_HOST_CALL reflectObjectConstruct(JSGlobalObject* globalObject
         return encodedJSValue();
     }
 
-    RELEASE_AND_RETURN(scope, JSValue::encode(construct(globalObject, target, constructType, constructData, arguments, newTarget)));
+    RELEASE_AND_RETURN(scope, JSValue::encode(construct(globalObject, target, constructData, arguments, newTarget)));
 }
 
 // https://tc39.github.io/ecma262/#sec-reflect.defineproperty
index bec1760..2147022 100644 (file)
@@ -523,10 +523,8 @@ void SamplingProfiler::processUnverifiedStackTraces(const AbstractLocker&)
             auto setFallbackFrameType = [&] {
                 ASSERT(!alreadyHasExecutable);
                 FrameType result = FrameType::Unknown;
-                CallData callData;
-                CallType callType;
-                callType = getCallData(m_vm, calleeCell, callData);
-                if (callType == CallType::Host)
+                auto callData = getCallData(m_vm, calleeCell);
+                if (callData.type == CallData::Type::Native)
                     result = FrameType::Host;
 
                 stackFrame.frameType = result;
index 690998f..427654a 100644 (file)
@@ -88,9 +88,8 @@ static EncodedJSValue JSC_HOST_CALL constructSet(JSGlobalObject* globalObject, C
     JSValue adderFunction = set->JSObject::get(globalObject, vm.propertyNames->add);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
 
-    CallData adderFunctionCallData;
-    CallType adderFunctionCallType = getCallData(vm, adderFunction, adderFunctionCallData);
-    if (UNLIKELY(adderFunctionCallType == CallType::None))
+    auto adderFunctionCallData = getCallData(vm, adderFunction);
+    if (UNLIKELY(adderFunctionCallData.type == CallData::Type::None))
         return JSValue::encode(throwTypeError(globalObject, scope));
 
     scope.release();
@@ -98,7 +97,7 @@ static EncodedJSValue JSC_HOST_CALL constructSet(JSGlobalObject* globalObject, C
         MarkedArgumentBuffer arguments;
         arguments.append(nextValue);
         ASSERT(!arguments.hasOverflowed());
-        call(globalObject, adderFunction, adderFunctionCallType, adderFunctionCallData, set, arguments);
+        call(globalObject, adderFunction, adderFunctionCallData, set, arguments);
     });
 
     return JSValue::encode(set);
index 4ac5416..50e2b2a 100644 (file)
@@ -514,8 +514,8 @@ static ALWAYS_INLINE JSString* removeUsingRegExpSearch(VM& vm, JSGlobalObject* g
 }
 
 static ALWAYS_INLINE JSString* replaceUsingRegExpSearch(
-    VM& vm, JSGlobalObject* globalObject, CallFrame* callFrame, JSString* string, JSValue searchValue, CallData& callData,
-    CallType callType, String& replacementString, JSValue replaceValue)
+    VM& vm, JSGlobalObject* globalObject, CallFrame* callFrame, JSString* string, JSValue searchValue, const CallData& callData,
+    String& replacementString, JSValue replaceValue)
 {
     auto scope = DECLARE_THROW_SCOPE(vm);
 
@@ -533,7 +533,7 @@ static ALWAYS_INLINE JSString* replaceUsingRegExpSearch(
         regExpObject->setLastIndex(globalObject, 0);
         RETURN_IF_EXCEPTION(scope, nullptr);
 
-        if (callType == CallType::None && !replacementString.length()) 
+        if (callData.type == CallData::Type::None && !replacementString.length())
             RELEASE_AND_RETURN(scope, removeUsingRegExpSearch(vm, globalObject, string, source, regExp));
     }
 
@@ -544,7 +544,7 @@ static ALWAYS_INLINE JSString* replaceUsingRegExpSearch(
     Vector<String, 16> replacements;
 
     // This is either a loop (if global is set) or a one-way (if not).
-    if (global && callType == CallType::JS) {
+    if (global && callData.type == CallData::Type::JS) {
         // regExp->numSubpatterns() + 1 for pattern args, + 2 for match start and string
         int argCount = regExp->numSubpatterns() + 1 + 2;
         if (hasNamedCaptures)
@@ -619,7 +619,7 @@ static ALWAYS_INLINE JSString* replaceUsingRegExpSearch(
             if (!result)
                 break;
 
-            if (callType != CallType::None) {
+            if (callData.type != CallData::Type::None) {
                 if (UNLIKELY(!sourceRanges.tryConstructAndAppend(lastIndex, result.start - lastIndex)))
                     OUT_OF_MEMORY(globalObject, scope);
 
@@ -657,7 +657,7 @@ static ALWAYS_INLINE JSString* replaceUsingRegExpSearch(
                     return nullptr;
                 }
 
-                JSValue replacement = call(globalObject, replaceValue, callType, callData, jsUndefined(), args);
+                JSValue replacement = call(globalObject, replaceValue, callData, jsUndefined(), args);
                 RETURN_IF_EXCEPTION(scope, nullptr);
                 String replacementString = replacement.toWTFString(globalObject);
                 RETURN_IF_EXCEPTION(scope, nullptr);
@@ -724,7 +724,7 @@ JSCell* JIT_OPERATION operationStringProtoFuncReplaceRegExpEmptyStr(JSGlobalObje
     CallData callData;
     String replacementString = emptyString();
     RELEASE_AND_RETURN(scope, replaceUsingRegExpSearch(
-        vm, globalObject, callFrame, thisValue, searchValue, callData, CallType::None, replacementString, JSValue()));
+        vm, globalObject, callFrame, thisValue, searchValue, callData, replacementString, JSValue()));
 }
 
 JSCell* JIT_OPERATION operationStringProtoFuncReplaceRegExpString(JSGlobalObject* globalObject, JSString* thisValue, RegExpObject* searchValue, JSString* replaceString)
@@ -738,7 +738,7 @@ JSCell* JIT_OPERATION operationStringProtoFuncReplaceRegExpString(JSGlobalObject
     String replacementString = replaceString->value(globalObject);
     RETURN_IF_EXCEPTION(scope, nullptr);
     RELEASE_AND_RETURN(scope, replaceUsingRegExpSearch(
-        vm, globalObject, callFrame, thisValue, searchValue, callData, CallType::None, replacementString, replaceString));
+        vm, globalObject, callFrame, thisValue, searchValue, callData, replacementString, replaceString));
 }
 
 static ALWAYS_INLINE JSString* replaceUsingRegExpSearch(VM& vm, JSGlobalObject* globalObject, CallFrame* callFrame, JSString* string, JSValue searchValue, JSValue replaceValue)
@@ -746,15 +746,14 @@ static ALWAYS_INLINE JSString* replaceUsingRegExpSearch(VM& vm, JSGlobalObject*
     auto scope = DECLARE_THROW_SCOPE(vm);
 
     String replacementString;
-    CallData callData;
-    CallType callType = getCallData(vm, replaceValue, callData);
-    if (callType == CallType::None) {
+    auto callData = getCallData(vm, replaceValue);
+    if (callData.type == CallData::Type::None) {
         replacementString = replaceValue.toWTFString(globalObject);
         RETURN_IF_EXCEPTION(scope, nullptr);
     }
 
     RELEASE_AND_RETURN(scope, replaceUsingRegExpSearch(
-        vm, globalObject, callFrame, string, searchValue, callData, callType, replacementString, replaceValue));
+        vm, globalObject, callFrame, string, searchValue, callData, replacementString, replaceValue));
 }
 
 enum class ReplaceMode : bool { Single, Global };
@@ -768,14 +767,13 @@ static ALWAYS_INLINE JSString* replaceUsingStringSearch(VM& vm, JSGlobalObject*
     String searchString = searchValue.toWTFString(globalObject);
     RETURN_IF_EXCEPTION(scope, nullptr);
 
-    CallData callData;
-    CallType callType = getCallData(vm, replaceValue, callData);
+    auto callData = getCallData(vm, replaceValue);
     Optional<CachedCall> cachedCall;
     String replaceString;
-    if (callType == CallType::None) {
+    if (callData.type == CallData::Type::None) {
         replaceString = replaceValue.toWTFString(globalObject);
         RETURN_IF_EXCEPTION(scope, nullptr);
-    } else if (callType == CallType::JS) {
+    } else if (callData.type == CallData::Type::JS) {
         cachedCall.emplace(globalObject, callFrame, jsCast<JSFunction*>(replaceValue), 3);
         RETURN_IF_EXCEPTION(scope, nullptr);
         cachedCall->setThis(jsUndefined());
@@ -790,7 +788,7 @@ static ALWAYS_INLINE JSString* replaceUsingStringSearch(VM& vm, JSGlobalObject*
     Vector<StringRange, 16> sourceRanges;
     Vector<String, 16> replacements;
     do {
-        if (callType != CallType::None) {
+        if (callData.type != CallData::Type::None) {
             JSValue replacement;
             if (cachedCall) {
                 auto* substring = jsSubstring(vm, string, matchStart, searchStringLength);
@@ -809,7 +807,7 @@ static ALWAYS_INLINE JSString* replaceUsingStringSearch(VM& vm, JSGlobalObject*
                 args.append(jsNumber(matchStart));
                 args.append(jsString);
                 ASSERT(!args.hasOverflowed());
-                replacement = call(globalObject, replaceValue, callType, callData, jsUndefined(), args);
+                replacement = call(globalObject, replaceValue, callData, jsUndefined(), args);
             }
             RETURN_IF_EXCEPTION(scope, nullptr);
             replaceString = replacement.toWTFString(globalObject);
@@ -820,7 +818,7 @@ static ALWAYS_INLINE JSString* replaceUsingStringSearch(VM& vm, JSGlobalObject*
             OUT_OF_MEMORY(globalObject, scope);
 
         size_t matchEnd = matchStart + searchStringLength;
-        if (callType != CallType::None)
+        if (callData.type != CallData::Type::None)
             replacements.append(replaceString);
         else {
             StringBuilder replacement(StringBuilder::OverflowHandler::RecordOverflow);
index 162e99d..4b96dd5 100644 (file)
@@ -1258,14 +1258,13 @@ void VM::callPromiseRejectionCallback(Strong<JSPromise>& promise)
 
     auto scope = DECLARE_CATCH_SCOPE(*this);
 
-    CallData callData;
-    CallType callType = getCallData(*this, callback, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = getCallData(*this, callback);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer args;
     args.append(promise.get());
     args.append(promise->result(*this));
-    call(promise->globalObject(), callback, callType, callData, jsNull(), args);
+    call(promise->globalObject(), callback, callData, jsNull(), args);
     scope.clearException();
 }
 
index f7dfa6b..f701c7a 100644 (file)
@@ -79,9 +79,8 @@ static EncodedJSValue JSC_HOST_CALL constructWeakMap(JSGlobalObject* globalObjec
     JSValue adderFunction = weakMap->JSObject::get(globalObject, vm.propertyNames->set);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
 
-    CallData adderFunctionCallData;
-    CallType adderFunctionCallType = getCallData(vm, adderFunction, adderFunctionCallData);
-    if (adderFunctionCallType == CallType::None)
+    auto adderFunctionCallData = getCallData(vm, adderFunction);
+    if (adderFunctionCallData.type == CallData::Type::None)
         return JSValue::encode(throwTypeError(globalObject, scope));
 
     scope.release();
@@ -103,7 +102,7 @@ static EncodedJSValue JSC_HOST_CALL constructWeakMap(JSGlobalObject* globalObjec
         arguments.append(value);
         ASSERT(!arguments.hasOverflowed());
         scope.release();
-        call(globalObject, adderFunction, adderFunctionCallType, adderFunctionCallData, weakMap, arguments);
+        call(globalObject, adderFunction, adderFunctionCallData, weakMap, arguments);
     });
 
     return JSValue::encode(weakMap);
index a7190f9..d83a40f 100644 (file)
@@ -79,9 +79,8 @@ static EncodedJSValue JSC_HOST_CALL constructWeakSet(JSGlobalObject* globalObjec
     JSValue adderFunction = weakSet->JSObject::get(globalObject, vm.propertyNames->add);
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
 
-    CallData adderFunctionCallData;
-    CallType adderFunctionCallType = getCallData(vm, adderFunction, adderFunctionCallData);
-    if (adderFunctionCallType == CallType::None)
+    auto adderFunctionCallData = getCallData(vm, adderFunction);
+    if (adderFunctionCallData.type == CallData::Type::None)
         return JSValue::encode(throwTypeError(globalObject, scope));
 
     scope.release();
@@ -89,7 +88,7 @@ static EncodedJSValue JSC_HOST_CALL constructWeakSet(JSGlobalObject* globalObjec
         MarkedArgumentBuffer arguments;
         arguments.append(nextValue);
         ASSERT(!arguments.hasOverflowed());
-        call(globalObject, adderFunction, adderFunctionCallType, adderFunctionCallData, weakSet, arguments);
+        call(globalObject, adderFunction, adderFunctionCallData, weakSet, arguments);
     });
 
     return JSValue::encode(weakSet);
index dd1d49c..a70d611 100644 (file)
@@ -2147,10 +2147,9 @@ static void callWithStackSizeProbeFunction(Probe::State* state)
     DollarVMAssertScope assertScope;
     VM& vm = globalObject->vm();
 
-    CallData callData;
-    CallType callType = getCallData(vm, function, callData);
+    auto callData = getCallData(vm, function);
     MarkedArgumentBuffer args;
-    call(globalObject, function, callType, callData, jsUndefined(), args);
+    call(globalObject, function, callData, jsUndefined(), args);
 }
 #endif // ENABLE(MASM_PROBE)
 
index 796c868..dbc8dfb 100644 (file)
@@ -657,9 +657,8 @@ JSValue WebAssemblyModuleRecord::evaluate(JSGlobalObject* globalObject)
     ASSERT(!exception);
 
     if (JSObject* startFunction = m_startFunction.get()) {
-        CallData callData;
-        CallType callType = JSC::getCallData(vm, startFunction, callData);
-        call(globalObject, startFunction, callType, callData, jsUndefined(), *vm.emptyList);
+        auto callData = JSC::getCallData(vm, startFunction);
+        call(globalObject, startFunction, callData, jsUndefined(), *vm.emptyList);
         RETURN_IF_EXCEPTION(scope, { });
     }
 
index 2ffb4db..9568e66 100644 (file)
@@ -43,11 +43,10 @@ static EncodedJSValue JSC_HOST_CALL callWebAssemblyWrapperFunction(JSGlobalObjec
     VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
     WebAssemblyWrapperFunction* wasmFunction = jsCast<WebAssemblyWrapperFunction*>(callFrame->jsCallee());
-    CallData callData;
     JSObject* function = wasmFunction->function();
-    CallType callType = function->methodTable(vm)->getCallData(function, callData);
-    RELEASE_ASSERT(callType != CallType::None);
-    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, function, callType, callData, jsUndefined(), ArgList(callFrame))));
+    auto callData = getCallData(vm, function);
+    RELEASE_ASSERT(callData.type != CallData::Type::None);
+    RELEASE_AND_RETURN(scope, JSValue::encode(call(globalObject, function, callData, jsUndefined(), ArgList(callFrame))));
 }
 
 WebAssemblyWrapperFunction::WebAssemblyWrapperFunction(VM& vm, NativeExecutable* executable, JSGlobalObject* globalObject, Structure* structure, Wasm::WasmToWasmImportableFunction importableFunction)
index c743bf0..4338c91 100644 (file)
@@ -1,3 +1,109 @@
+2020-04-27  Ross Kirsling  <ross.kirsling@sony.com>
+
+        [JSC] CallData/ConstructData should include CallType/ConstructType
+        https://bugs.webkit.org/show_bug.cgi?id=211059
+
+        Reviewed by Darin Adler.
+
+        * Modules/plugins/QuickTimePluginReplacement.mm:
+        (WebCore::QuickTimePluginReplacement::installReplacement):
+        * bindings/js/JSCallbackData.cpp:
+        (WebCore::JSCallbackData::invokeCallback):
+        * bindings/js/JSCustomElementInterface.cpp:
+        (WebCore::constructCustomElementSynchronously):
+        (WebCore::JSCustomElementInterface::upgradeElement):
+        (WebCore::JSCustomElementInterface::invokeCallback):
+        * bindings/js/JSCustomXPathNSResolver.cpp:
+        (WebCore::JSCustomXPathNSResolver::lookupNamespaceURI):
+        * bindings/js/JSDOMBuiltinConstructor.h:
+        (WebCore::JSDOMBuiltinConstructor<JSClass>::getConstructData):
+        * bindings/js/JSDOMBuiltinConstructorBase.cpp:
+        (WebCore::JSDOMBuiltinConstructorBase::callFunctionWithCurrentArguments):
+        * bindings/js/JSDOMConstructor.h:
+        (WebCore::JSDOMConstructor<JSClass>::getConstructData):
+        * bindings/js/JSDOMConstructorBase.cpp:
+        (WebCore::JSDOMConstructorBase::getCallData):
+        * bindings/js/JSDOMConstructorBase.h:
+        * bindings/js/JSDOMConstructorNotConstructable.h:
+        * bindings/js/JSDOMIterator.h:
+        (WebCore::iteratorForEach):
+        * bindings/js/JSDOMMapLike.cpp:
+        (WebCore::clearBackingMap):
+        (WebCore::setToBackingMap):
+        (WebCore::forwardFunctionCallToBackingMap):
+        (WebCore::forwardForEachCallToBackingMap):
+        * bindings/js/JSDOMNamedConstructor.h:
+        (WebCore::JSDOMNamedConstructor<JSClass>::getConstructData):
+        * bindings/js/JSDOMPromise.cpp:
+        (WebCore::DOMPromise::whenPromiseIsSettled):
+        * bindings/js/JSDOMPromiseDeferred.cpp:
+        (WebCore::createRejectedPromiseWithTypeError):
+        * bindings/js/JSDOMSetLike.cpp:
+        (WebCore::clearBackingSet):
+        (WebCore::addToBackingSet):
+        (WebCore::forwardFunctionCallToBackingSet):
+        (WebCore::forwardForEachCallToBackingSet):
+        * bindings/js/JSErrorHandler.cpp:
+        (WebCore::JSErrorHandler::handleEvent):
+        * bindings/js/JSEventListener.cpp:
+        (WebCore::JSEventListener::handleEvent):
+        * bindings/js/JSExecState.cpp:
+        (WebCore::functionCallHandlerFromAnyThread):
+        * bindings/js/JSExecState.h:
+        (WebCore::JSExecState::call):
+        (WebCore::JSExecState::profiledCall):
+        * bindings/js/JSExecStateInstrumentation.h:
+        (WebCore::JSExecState::instrumentFunction):
+        (WebCore::JSExecState::instrumentFunctionInternal): Deleted.
+        (WebCore::JSExecState::instrumentFunctionCall): Deleted.
+        (WebCore::JSExecState::instrumentFunctionConstruct): Deleted.
+        * bindings/js/JSNavigatorCustom.cpp:
+        (WebCore::JSNavigator::getUserMedia):
+        * bindings/js/JSPluginElementFunctions.cpp:
+        (WebCore::callPlugin):
+        (WebCore::pluginElementCustomGetCallData):
+        * bindings/js/JSPluginElementFunctions.h:
+        * bindings/js/ReadableStream.cpp:
+        (WebCore::ReadableStream::create):
+        (WebCore::ReadableStreamInternal::callFunction):
+        (WebCore::ReadableStream::lock):
+        * bindings/js/ReadableStreamDefaultController.cpp:
+        (WebCore::readableStreamCallFunction):
+        * bindings/js/ScheduledAction.cpp:
+        (WebCore::ScheduledAction::executeFunctionInContext):
+        * bindings/js/ScriptController.cpp:
+        (WebCore::ScriptController::callInWorld):
+        (WebCore::ScriptController::executeAsynchronousUserAgentScriptInWorld):
+        * bindings/scripts/CodeGeneratorJS.pm:
+        (GenerateHeader):
+        (GeneratePluginCall):
+        (GenerateLegacyCallerDefinitions):
+        * bindings/scripts/test/JS/JSTestObj.cpp:
+        (WebCore::JSTestObj::getCallData):
+        * bindings/scripts/test/JS/JSTestObj.h:
+        * bindings/scripts/test/JS/JSTestPluginInterface.cpp:
+        (WebCore::JSTestPluginInterface::getCallData):
+        * bindings/scripts/test/JS/JSTestPluginInterface.h:
+        * bridge/NP_jsobject.cpp:
+        * bridge/objc/WebScriptObject.mm:
+        (-[WebScriptObject callWebScriptMethod:withArguments:]):
+        * bridge/objc/objc_runtime.h:
+        * bridge/objc/objc_runtime.mm:
+        (JSC::Bindings::ObjcFallbackObjectImp::getCallData):
+        * bridge/runtime_object.cpp:
+        (JSC::Bindings::RuntimeObject::getCallData):
+        (JSC::Bindings::RuntimeObject::getConstructData):
+        * bridge/runtime_object.h:
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::updateCaptionContainer):
+        (WebCore::HTMLMediaElement::didAddUserAgentShadowRoot):
+        (WebCore::HTMLMediaElement::updateMediaControlsAfterPresentationModeChange):
+        (WebCore::HTMLMediaElement::getCurrentMediaControlsStatus):
+        * html/HTMLPlugInImageElement.cpp:
+        (WebCore::HTMLPlugInImageElement::didAddUserAgentShadowRoot):
+        * testing/Internals.cpp:
+        (WebCore::Internals::cloneArrayBuffer):
+
 2020-04-27  Diego Pino Garcia  <dpino@igalia.com>
 
         Unreviewed, reverting r260672.
index 537eee7..8974e6a 100644 (file)
@@ -188,9 +188,8 @@ bool QuickTimePluginReplacement::installReplacement(ShadowRoot& root)
         return false;
     JSC::JSObject* replacementObject = replacementFunction.toObject(lexicalGlobalObject);
     scope.assertNoException();
-    JSC::CallData callData;
-    JSC::CallType callType = replacementObject->methodTable(vm)->getCallData(replacementObject, callData);
-    if (callType == JSC::CallType::None)
+    auto callData = getCallData(vm, replacementObject);
+    if (callData.type == JSC::CallData::Type::None)
         return false;
 
     JSC::MarkedArgumentBuffer argList;
@@ -200,7 +199,7 @@ bool QuickTimePluginReplacement::installReplacement(ShadowRoot& root)
     argList.append(toJS<IDLSequence<IDLNullable<IDLDOMString>>>(*lexicalGlobalObject, *globalObject, m_names));
     argList.append(toJS<IDLSequence<IDLNullable<IDLDOMString>>>(*lexicalGlobalObject, *globalObject, m_values));
     ASSERT(!argList.hasOverflowed());
-    JSC::JSValue replacement = call(lexicalGlobalObject, replacementObject, callType, callData, globalObject, argList);
+    JSC::JSValue replacement = call(lexicalGlobalObject, replacementObject, callData, globalObject, argList);
     if (UNLIKELY(scope.exception())) {
         scope.clearException();
         return false;
index 6b77949..ce30af4 100644 (file)
@@ -48,13 +48,12 @@ JSValue JSCallbackData::invokeCallback(JSDOMGlobalObject& globalObject, JSObject
 
     JSValue function;
     CallData callData;
-    CallType callType = CallType::None;
 
     if (method != CallbackType::Object) {
         function = callback;
-        callType = callback->methodTable(vm)->getCallData(callback, callData);
+        callData = getCallData(vm, callback);
     }
-    if (callType == CallType::None) {
+    if (callData.type == CallData::Type::None) {
         if (method == CallbackType::Function) {
             returnedException = JSC::Exception::create(vm, createTypeError(lexicalGlobalObject));
             return JSValue();
@@ -68,25 +67,25 @@ JSValue JSCallbackData::invokeCallback(JSDOMGlobalObject& globalObject, JSObject
             return JSValue();
         }
 
-        callType = getCallData(vm, function, callData);
-        if (callType == CallType::None) {
+        callData = getCallData(vm, function);
+        if (callData.type == CallData::Type::None) {
             returnedException = JSC::Exception::create(vm, createTypeError(lexicalGlobalObject));
             return JSValue();
         }
     }
 
     ASSERT(!function.isEmpty());
-    ASSERT(callType != CallType::None);
+    ASSERT(callData.type != CallData::Type::None);
 
     ScriptExecutionContext* context = globalObject.scriptExecutionContext();
     // We will fail to get the context if the frame has been detached.
     if (!context)
         return JSValue();
 
-    JSExecState::instrumentFunctionCall(context, callType, callData);
+    JSExecState::instrumentFunction(context, callData);
 
     returnedException = nullptr;
-    JSValue result = JSExecState::profiledCall(lexicalGlobalObject, JSC::ProfilingReason::Other, function, callType, callData, thisValue, args, returnedException);
+    JSValue result = JSExecState::profiledCall(lexicalGlobalObject, JSC::ProfilingReason::Other, function, callData, thisValue, args, returnedException);
 
     InspectorInstrumentation::didCallFunction(context);
 
index 81624e3..030e805 100644 (file)
@@ -117,17 +117,16 @@ RefPtr<Element> JSCustomElementInterface::tryToConstructCustomElement(Document&
 static RefPtr<Element> constructCustomElementSynchronously(Document& document, VM& vm, JSGlobalObject& lexicalGlobalObject, JSObject* constructor, const AtomString& localName)
 {
     auto scope = DECLARE_THROW_SCOPE(vm);
-    ConstructData constructData;
-    ConstructType constructType = constructor->methodTable(vm)->getConstructData(constructor, constructData);
-    if (constructType == ConstructType::None) {
+    auto constructData = getConstructData(vm, constructor);
+    if (constructData.type == CallData::Type::None) {
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 
-    JSExecState::instrumentFunctionConstruct(&document, constructType, constructData);
+    JSExecState::instrumentFunction(&document, constructData);
     MarkedArgumentBuffer args;
     ASSERT(!args.hasOverflowed());
-    JSValue newElement = construct(&lexicalGlobalObject, constructor, constructType, constructData, args);
+    JSValue newElement = construct(&lexicalGlobalObject, constructor, constructData, args);
     InspectorInstrumentation::didCallFunction(&document);
     RETURN_IF_EXCEPTION(scope, nullptr);
 
@@ -186,9 +185,8 @@ void JSCustomElementInterface::upgradeElement(Element& element)
         return;
     JSGlobalObject* lexicalGlobalObject = globalObject;
 
-    ConstructData constructData;
-    ConstructType constructType = m_constructor->methodTable(vm)->getConstructData(m_constructor.get(), constructData);
-    if (constructType == ConstructType::None) {
+    auto constructData = getConstructData(vm, m_constructor.get());
+    if (constructData.type == CallData::Type::None) {
         ASSERT_NOT_REACHED();
         return;
     }
@@ -199,8 +197,8 @@ void JSCustomElementInterface::upgradeElement(Element& element)
 
     MarkedArgumentBuffer args;
     ASSERT(!args.hasOverflowed());
-    JSExecState::instrumentFunctionConstruct(context, constructType, constructData);
-    JSValue returnedElement = construct(lexicalGlobalObject, m_constructor.get(), constructType, constructData, args);
+    JSExecState::instrumentFunction(context, constructData);
+    JSValue returnedElement = construct(lexicalGlobalObject, m_constructor.get(), constructData, args);
     InspectorInstrumentation::didCallFunction(context);
 
     m_constructionStack.removeLast();
@@ -240,18 +238,17 @@ void JSCustomElementInterface::invokeCallback(Element& element, JSObject* callba
 
     JSObject* jsElement = asObject(toJS(lexicalGlobalObject, globalObject, element));
 
-    CallData callData;
-    CallType callType = callback->methodTable(vm)->getCallData(callback, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = getCallData(vm, callback);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer args;
     addArguments(lexicalGlobalObject, globalObject, args);
     RELEASE_ASSERT(!args.hasOverflowed());
 
-    JSExecState::instrumentFunctionCall(context, callType, callData);
+    JSExecState::instrumentFunction(context, callData);
 
     NakedPtr<JSC::Exception> exception;
-    JSExecState::call(lexicalGlobalObject, callback, callType, callData, jsElement, args, exception);
+    JSExecState::call(lexicalGlobalObject, callback, callData, jsElement, args, exception);
 
     InspectorInstrumentation::didCallFunction(context);
 
index 4903853..df562d0 100644 (file)
@@ -74,11 +74,10 @@ String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
     VM& vm = lexicalGlobalObject->vm();
         
     JSValue function = m_customResolver->get(lexicalGlobalObject, Identifier::fromString(vm, "lookupNamespaceURI"));
-    CallData callData;
-    CallType callType = getCallData(vm, function, callData);
-    if (callType == CallType::None) {
-        callType = m_customResolver->methodTable(vm)->getCallData(m_customResolver.get(), callData);
-        if (callType == CallType::None) {
+    auto callData = getCallData(vm, function);
+    if (callData.type == CallData::Type::None) {
+        callData = getCallData(vm, m_customResolver.get());
+        if (callData.type == CallData::Type::None) {
             if (PageConsoleClient* console = m_globalObject->wrapped().console())
                 console->addMessage(MessageSource::JS, MessageLevel::Error, "XPathNSResolver does not have a lookupNamespaceURI method."_s);
             return String();
@@ -93,7 +92,7 @@ String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
     ASSERT(!args.hasOverflowed());
 
     NakedPtr<JSC::Exception> exception;
-    JSValue retval = JSExecState::call(lexicalGlobalObject, function, callType, callData, m_customResolver.get(), args, exception);
+    JSValue retval = JSExecState::call(lexicalGlobalObject, function, callData, m_customResolver.get(), args, exception);
 
     String result;
     if (exception)
index 95ad06e..c61ccf2 100644 (file)
@@ -44,7 +44,7 @@ private:
     }
 
     void finishCreation(JSC::VM&, JSDOMGlobalObject&);
-    static JSC::ConstructType getConstructData(JSC::JSCell*, JSC::ConstructData&);
+    static JSC::CallData getConstructData(JSC::JSCell*);
     static JSC::EncodedJSValue JSC_HOST_CALL construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
     JSC::EncodedJSValue callConstructor(JSC::JSGlobalObject&, JSC::CallFrame&, JSC::JSObject&);
@@ -118,10 +118,12 @@ template<typename JSClass> inline JSC::EncodedJSValue JSC_HOST_CALL JSDOMBuiltin
     return castedThis->callConstructor(*lexicalGlobalObject, *callFrame, createJSObject(*castedThis));
 }
 
-template<typename JSClass> inline JSC::ConstructType JSDOMBuiltinConstructor<JSClass>::getConstructData(JSC::JSCell*, JSC::ConstructData& constructData)
+template<typename JSClass> inline JSC::CallData JSDOMBuiltinConstructor<JSClass>::getConstructData(JSC::JSCell*)
 {
+    CallData constructData;
+    constructData.type = JSC::CallData::Type::Native;
     constructData.native.function = construct;
-    return JSC::ConstructType::Host;
+    return constructData;
 }
 
 } // namespace WebCore
index 8f3ff4b..6bde657 100644 (file)
@@ -32,9 +32,8 @@ void JSDOMBuiltinConstructorBase::callFunctionWithCurrentArguments(JSC::JSGlobal
 {
     JSC::VM& vm = lexicalGlobalObject.vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
-    JSC::CallData callData;
-    JSC::CallType callType = JSC::getCallData(vm, &function, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = JSC::getCallData(vm, &function);
+    ASSERT(callData.type != CallData::Type::None);
 
     JSC::MarkedArgumentBuffer arguments;
     for (unsigned i = 0; i < callFrame.argumentCount(); ++i)
@@ -43,7 +42,7 @@ void JSDOMBuiltinConstructorBase::callFunctionWithCurrentArguments(JSC::JSGlobal
         throwOutOfMemoryError(&lexicalGlobalObject, scope);
         return;
     }
-    JSC::call(&lexicalGlobalObject, &function, callType, callData, &thisObject, arguments);
+    JSC::call(&lexicalGlobalObject, &function, callData, &thisObject, arguments);
 }
 
 void JSDOMBuiltinConstructorBase::visitChildren(JSC::JSCell* cell, JSC::SlotVisitor& visitor)
index 393dceb..3f6ea75 100644 (file)
@@ -42,7 +42,7 @@ private:
     }
 
     void finishCreation(JSC::VM&, JSDOMGlobalObject&);
-    static JSC::ConstructType getConstructData(JSC::JSCell*, JSC::ConstructData&);
+    static JSC::CallData getConstructData(JSC::JSCell*);
 
     // Usually defined for each specialization class.
     void initializeProperties(JSC::VM&, JSDOMGlobalObject&) { }
@@ -69,10 +69,12 @@ template<typename JSClass> inline void JSDOMConstructor<JSClass>::finishCreation
     initializeProperties(vm, globalObject);
 }
 
-template<typename JSClass> inline JSC::ConstructType JSDOMConstructor<JSClass>::getConstructData(JSC::JSCell*, JSC::ConstructData& constructData)
+template<typename JSClass> inline JSC::CallData JSDOMConstructor<JSClass>::getConstructData(JSC::JSCell*)
 {
+    JSC::CallData constructData;
+    constructData.type = JSC::CallData::Type::Native;
     constructData.native.function = construct;
-    return JSC::ConstructType::Host;
+    return constructData;
 }
 
 
index 40003dd..1d94b5d 100644 (file)
@@ -38,10 +38,12 @@ static EncodedJSValue JSC_HOST_CALL callThrowTypeError(JSGlobalObject* globalObj
     return JSValue::encode(jsNull());
 }
 
-CallType JSDOMConstructorBase::getCallData(JSCell*, CallData& callData)
+CallData JSDOMConstructorBase::getCallData(JSCell*)
 {
+    CallData callData;
+    callData.type = CallData::Type::Native;
     callData.native.function = callThrowTypeError;
-    return CallType::Host;
+    return callData;
 }
 
 String JSDOMConstructorBase::className(const JSObject*, JSC::VM&)
index c528b09..2e0c5ac 100644 (file)
@@ -51,7 +51,7 @@ protected:
 
     static String className(const JSObject*, JSC::VM&);
     static String toStringName(const JSObject*, JSC::JSGlobalObject*);
-    static JSC::CallType getCallData(JSCell*, JSC::CallData&);
+    static JSC::CallData getCallData(JSC::JSCell*);
 };
 
 inline JSC::Structure* JSDOMConstructorBase::createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
index 330c592..4cc55ec 100644 (file)
@@ -54,10 +54,12 @@ private:
         return JSC::JSValue::encode(JSC::jsNull());
     }
 
-    static JSC::CallType getCallData(JSC::JSCell*, JSC::CallData& callData)
+    static JSC::CallData getCallData(JSC::JSCell*)
     {
+        JSC::CallData callData;
+        callData.type = JSC::CallData::Type::Native;
         callData.native.function = callThrowTypeError;
-        return JSC::CallType::Host;
+        return callData;
     }
 };
 
index 073fc76..b0373a6 100644 (file)
@@ -204,9 +204,8 @@ template<typename JSIterator> JSC::JSValue iteratorForEach(JSC::JSGlobalObject&
     JSC::JSValue callback = callFrame.argument(0);
     JSC::JSValue thisValue = callFrame.argument(1);
 
-    JSC::CallData callData;
-    JSC::CallType callType = JSC::getCallData(JSC::getVM(&lexicalGlobalObject), callback, callData);
-    if (callType == JSC::CallType::None)
+    auto callData = JSC::getCallData(JSC::getVM(&lexicalGlobalObject), callback);
+    if (callData.type == JSC::CallData::Type::None)
         return throwTypeError(&lexicalGlobalObject, scope, "Cannot call callback"_s);
 
     auto iterator = thisObject.wrapped().createIterator();
@@ -218,7 +217,7 @@ template<typename JSIterator> JSC::JSValue iteratorForEach(JSC::JSGlobalObject&
             throwOutOfMemoryError(&lexicalGlobalObject, scope);
             return { };
         }
-        JSC::call(&lexicalGlobalObject, callback, callType, callData, thisValue, arguments);
+        JSC::call(&lexicalGlobalObject, callback, callData, thisValue, arguments);
         if (UNLIKELY(scope.exception()))
             break;
     }
index 2364ad9..f3ebbad 100644 (file)
@@ -53,13 +53,12 @@ void clearBackingMap(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& ba
     auto& vm = JSC::getVM(&lexicalGlobalObject);
     auto function = backingMap.get(&lexicalGlobalObject, vm.propertyNames->clear);
 
-    JSC::CallData callData;
-    auto callType = JSC::getCallData(vm, function, callData);
-    if (callType == JSC::CallType::None)
+    auto callData = JSC::getCallData(vm, function);
+    if (callData.type == JSC::CallData::Type::None)
         return;
 
     JSC::MarkedArgumentBuffer arguments;
-    JSC::call(&lexicalGlobalObject, function, callType, callData, &backingMap, arguments);
+    JSC::call(&lexicalGlobalObject, function, callData, &backingMap, arguments);
 }
 
 void setToBackingMap(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& backingMap, JSC::JSValue key, JSC::JSValue value)
@@ -67,15 +66,14 @@ void setToBackingMap(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& ba
     auto& vm = JSC::getVM(&lexicalGlobalObject);
     auto function = backingMap.get(&lexicalGlobalObject, vm.propertyNames->set);
 
-    JSC::CallData callData;
-    auto callType = JSC::getCallData(vm, function, callData);
-    if (callType == JSC::CallType::None)
+    auto callData = JSC::getCallData(vm, function);
+    if (callData.type == JSC::CallData::Type::None)
         return;
 
     JSC::MarkedArgumentBuffer arguments;
     arguments.append(key);
     arguments.append(value);
-    JSC::call(&lexicalGlobalObject, function, callType, callData, &backingMap, arguments);
+    JSC::call(&lexicalGlobalObject, function, callData, &backingMap, arguments);
 }
 
 JSC::JSValue forwardAttributeGetterToBackingMap(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& backingMap, const JSC::Identifier& attributeName)
@@ -87,16 +85,15 @@ JSC::JSValue forwardFunctionCallToBackingMap(JSC::JSGlobalObject& lexicalGlobalO
 {
     auto function = backingMap.get(&lexicalGlobalObject, functionName);
 
-    JSC::CallData callData;
-    auto callType = JSC::getCallData(lexicalGlobalObject.vm(), function, callData);
-    if (callType == JSC::CallType::None)
+    auto callData = JSC::getCallData(lexicalGlobalObject.vm(), function);
+    if (callData.type == JSC::CallData::Type::None)
         return JSC::jsUndefined();
 
     JSC::MarkedArgumentBuffer arguments;
     for (size_t cptr = 0; cptr < callFrame.argumentCount(); ++cptr)
         arguments.append(callFrame.uncheckedArgument(cptr));
     ASSERT(!arguments.hasOverflowed());
-    return JSC::call(&lexicalGlobalObject, function, callType, callData, &backingMap, arguments);
+    return JSC::call(&lexicalGlobalObject, function, callData, &backingMap, arguments);
 }
 
 JSC::JSValue forwardForEachCallToBackingMap(JSDOMGlobalObject& globalObject, JSC::CallFrame& callFrame, JSC::JSObject& mapLike)
@@ -107,16 +104,15 @@ JSC::JSValue forwardForEachCallToBackingMap(JSDOMGlobalObject& globalObject, JSC
     auto* function = globalObject.builtinInternalFunctions().jsDOMBindingInternals().m_forEachWrapperFunction.get();
     ASSERT(function);
 
-    JSC::CallData callData;
-    auto callType = JSC::getCallData(globalObject.vm(), function, callData);
-    ASSERT(callType != JSC::CallType::None);
+    auto callData = JSC::getCallData(globalObject.vm(), function);
+    ASSERT(callData.type != JSC::CallData::Type::None);
 
     JSC::MarkedArgumentBuffer arguments;
     arguments.append(&result.second.get());
     for (size_t cptr = 0; cptr < callFrame.argumentCount(); ++cptr)
         arguments.append(callFrame.uncheckedArgument(cptr));
     ASSERT(!arguments.hasOverflowed());
-    return JSC::call(&globalObject, function, callType, callData, &mapLike, arguments);
+    return JSC::call(&globalObject, function, callData, &mapLike, arguments);
 }
 
 void DOMMapAdapter::clear()
index b03ca1d..f3484f6 100644 (file)
@@ -43,7 +43,7 @@ private:
     }
 
     void finishCreation(JSC::VM&, JSDOMGlobalObject&);
-    static JSC::ConstructType getConstructData(JSC::JSCell*, JSC::ConstructData&);
+    static JSC::CallData getConstructData(JSC::JSCell*);
 
     // Usually defined for each specialization class.
     void initializeProperties(JSC::VM&, JSDOMGlobalObject&) { }
@@ -70,10 +70,12 @@ template<typename JSClass> inline void JSDOMNamedConstructor<JSClass>::finishCre
     initializeProperties(vm, globalObject);
 }
 
-template<typename JSClass> inline JSC::ConstructType JSDOMNamedConstructor<JSClass>::getConstructData(JSC::JSCell*, JSC::ConstructData& constructData)
+template<typename JSClass> inline JSC::CallData JSDOMNamedConstructor<JSClass>::getConstructData(JSC::JSCell*)
 {
+    JSC::CallData constructData;
+    constructData.type = JSC::CallData::Type::Native;
     constructData.native.function = construct;
-    return JSC::ConstructType::Host;
+    return constructData;
 }
 
 } // namespace WebCore
index 703f37f..e85d75b 100644 (file)
@@ -67,10 +67,9 @@ void DOMPromise::whenPromiseIsSettled(JSDOMGlobalObject* globalObject, JSC::JSOb
     arguments.append(handler);
     arguments.append(handler);
 
-    JSC::CallData callData;
-    auto callType = JSC::getCallData(vm, thenFunction, callData);
-    ASSERT(callType != JSC::CallType::None);
-    call(&lexicalGlobalObject, thenFunction, callType, callData, promise, arguments);
+    auto callData = JSC::getCallData(vm, thenFunction);
+    ASSERT(callData.type != JSC::CallData::Type::None);
+    call(&lexicalGlobalObject, thenFunction, callData, promise, arguments);
 
     EXCEPTION_ASSERT(!scope.exception() || isTerminatedExecutionException(lexicalGlobalObject.vm(), scope.exception()));
 }
index f4700f9..286b4d8 100644 (file)
@@ -228,15 +228,14 @@ JSC::EncodedJSValue createRejectedPromiseWithTypeError(JSC::JSGlobalObject& lexi
     if (cause == RejectedPromiseWithTypeErrorCause::NativeGetter)
         rejectionValue->setNativeGetterTypeError();
 
-    CallData callData;
-    auto callType = getCallData(lexicalGlobalObject.vm(), rejectFunction, callData);
-    ASSERT(callType != CallType::None);
+    auto callData = getCallData(lexicalGlobalObject.vm(), rejectFunction);
+    ASSERT(callData.type != CallData::Type::None);
 
     MarkedArgumentBuffer arguments;
     arguments.append(rejectionValue);
     ASSERT(!arguments.hasOverflowed());
 
-    return JSValue::encode(call(&lexicalGlobalObject, rejectFunction, callType, callData, promiseConstructor, arguments));
+    return JSValue::encode(call(&lexicalGlobalObject, rejectFunction, callData, promiseConstructor, arguments));
 }
 
 static inline JSC::JSValue parseAsJSON(JSC::JSGlobalObject* lexicalGlobalObject, const String& data)
index 46392d6..1a2bc01 100644 (file)
@@ -60,11 +60,10 @@ void clearBackingSet(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& ba
     JSC::JSValue function = backingSet.get(&lexicalGlobalObject, vm.propertyNames->clear);
     ASSERT(!function.isUndefined());
 
-    JSC::CallData callData;
-    JSC::CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != JSC::CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != JSC::CallData::Type::None);
     JSC::MarkedArgumentBuffer arguments;
-    JSC::call(&lexicalGlobalObject, function, callType, callData, &backingSet, arguments);
+    JSC::call(&lexicalGlobalObject, function, callData, &backingSet, arguments);
 }
 
 void addToBackingSet(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& backingSet, JSC::JSValue item)
@@ -73,12 +72,11 @@ void addToBackingSet(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& ba
     JSC::JSValue function = backingSet.get(&lexicalGlobalObject, vm.propertyNames->add);
     ASSERT(!function.isUndefined());
 
-    JSC::CallData callData;
-    JSC::CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != JSC::CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != JSC::CallData::Type::None);
     JSC::MarkedArgumentBuffer arguments;
     arguments.append(item);
-    JSC::call(&lexicalGlobalObject, function, callType, callData, &backingSet, arguments);
+    JSC::call(&lexicalGlobalObject, function, callData, &backingSet, arguments);
 }
 
 JSC::JSValue forwardAttributeGetterToBackingSet(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& backingSet, const JSC::Identifier& attributeName)
@@ -91,14 +89,13 @@ JSC::JSValue forwardFunctionCallToBackingSet(JSC::JSGlobalObject& lexicalGlobalO
     JSC::JSValue function = backingSet.get(&lexicalGlobalObject, functionName);
     ASSERT(!function.isUndefined());
 
-    JSC::CallData callData;
-    JSC::CallType callType = JSC::getCallData(lexicalGlobalObject.vm(), function, callData);
-    ASSERT(callType != JSC::CallType::None);
+    auto callData = JSC::getCallData(lexicalGlobalObject.vm(), function);
+    ASSERT(callData.type != JSC::CallData::Type::None);
     JSC::MarkedArgumentBuffer arguments;
     for (size_t cptr = 0; cptr < callFrame.argumentCount(); ++cptr)
         arguments.append(callFrame.uncheckedArgument(cptr));
     ASSERT(!arguments.hasOverflowed());
-    return JSC::call(&lexicalGlobalObject, function, callType, callData, &backingSet, arguments);
+    return JSC::call(&lexicalGlobalObject, function, callData, &backingSet, arguments);
 }
 
 JSC::JSValue forwardForEachCallToBackingSet(JSDOMGlobalObject& globalObject, JSC::CallFrame& callFrame, JSC::JSObject& setLike)
@@ -109,16 +106,15 @@ JSC::JSValue forwardForEachCallToBackingSet(JSDOMGlobalObject& globalObject, JSC
     auto* function = globalObject.builtinInternalFunctions().jsDOMBindingInternals().m_forEachWrapperFunction.get();
     ASSERT(function);
 
-    JSC::CallData callData;
-    JSC::CallType callType = JSC::getCallData(globalObject.vm(), function, callData);
-    ASSERT(callType != JSC::CallType::None);
+    auto callData = JSC::getCallData(globalObject.vm(), function);
+    ASSERT(callData.type != JSC::CallData::Type::None);
 
     JSC::MarkedArgumentBuffer arguments;
     arguments.append(&result.second.get());
     for (size_t cptr = 0; cptr < callFrame.argumentCount(); ++cptr)
         arguments.append(callFrame.uncheckedArgument(cptr));
     ASSERT(!arguments.hasOverflowed());
-    return JSC::call(&globalObject, function, callType, callData, &setLike, arguments);
+    return JSC::call(&globalObject, function, callData, &setLike, arguments);
 }
 
 }
index 1babc9b..dca84a5 100644 (file)
@@ -75,10 +75,8 @@ void JSErrorHandler::handleEvent(ScriptExecutionContext& scriptExecutionContext,
     if (!globalObject)
         return;
 
-    CallData callData;
-    CallType callType = jsFunction->methodTable(vm)->getCallData(jsFunction, callData);
-
-    if (callType != CallType::None) {
+    auto callData = getCallData(vm, jsFunction);
+    if (callData.type != CallData::Type::None) {
         Ref<JSErrorHandler> protectedThis(*this);
 
         Event* savedEvent = globalObject->currentEvent();
@@ -97,10 +95,10 @@ void JSErrorHandler::handleEvent(ScriptExecutionContext& scriptExecutionContext,
         VM& vm = globalObject->vm();
         VMEntryScope entryScope(vm, vm.entryScope ? vm.entryScope->globalObject() : globalObject);
 
-        JSExecState::instrumentFunctionCall(&scriptExecutionContext, callType, callData);
+        JSExecState::instrumentFunction(&scriptExecutionContext, callData);
 
         NakedPtr<JSC::Exception> exception;
-        JSValue returnValue = JSExecState::profiledCall(globalObject, JSC::ProfilingReason::Other, jsFunction, callType, callData, globalObject, args, exception);
+        JSValue returnValue = JSExecState::profiledCall(globalObject, JSC::ProfilingReason::Other, jsFunction, callData, globalObject, args, exception);
 
         InspectorInstrumentation::didCallFunction(&scriptExecutionContext);
 
index 8cdb8f7..448c3bb 100644 (file)
@@ -134,11 +134,10 @@ void JSEventListener::handleEvent(ScriptExecutionContext& scriptExecutionContext
 
     JSValue handleEventFunction = jsFunction;
 
-    CallData callData;
-    CallType callType = getCallData(vm, handleEventFunction, callData);
+    auto callData = getCallData(vm, handleEventFunction);
 
     // If jsFunction is not actually a function and this is an EventListener, see if it implements callback interface.
-    if (callType == CallType::None) {
+    if (callData.type == CallData::Type::None) {
         if (m_isAttribute)
             return;
 
@@ -150,8 +149,8 @@ void JSEventListener::handleEvent(ScriptExecutionContext& scriptExecutionContext
             reportException(lexicalGlobalObject, exception);
             return;
         }
-        callType = getCallData(vm, handleEventFunction, callData);
-        if (callType == CallType::None) {
+        callData = getCallData(vm, handleEventFunction);
+        if (callData.type == CallData::Type::None) {
             event.target()->uncaughtExceptionInEventHandler();
             reportException(lexicalGlobalObject, createTypeError(lexicalGlobalObject, "'handleEvent' property of event listener should be callable"_s));
             return;
@@ -173,11 +172,11 @@ void JSEventListener::handleEvent(ScriptExecutionContext& scriptExecutionContext
 
     VMEntryScope entryScope(vm, vm.entryScope ? vm.entryScope->globalObject() : globalObject);
 
-    JSExecState::instrumentFunctionCall(&scriptExecutionContext, callType, callData);
+    JSExecState::instrumentFunction(&scriptExecutionContext, callData);
 
     JSValue thisValue = handleEventFunction == jsFunction ? toJS(lexicalGlobalObject, globalObject, event.currentTarget()) : jsFunction;
     NakedPtr<JSC::Exception> exception;
-    JSValue retval = JSExecState::profiledCall(lexicalGlobalObject, JSC::ProfilingReason::Other, handleEventFunction, callType, callData, thisValue, args, exception);
+    JSValue retval = JSExecState::profiledCall(lexicalGlobalObject, JSC::ProfilingReason::Other, handleEventFunction, callData, thisValue, args, exception);
 
     InspectorInstrumentation::didCallFunction(&scriptExecutionContext);
 
index 93a2605..beca563 100644 (file)
@@ -43,9 +43,9 @@ void JSExecState::didLeaveScriptContext(JSC::JSGlobalObject* lexicalGlobalObject
     context->ensureRejectedPromiseTracker().processQueueSoon();
 }
 
-JSC::JSValue functionCallHandlerFromAnyThread(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException)
+JSC::JSValue functionCallHandlerFromAnyThread(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSValue functionObject, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException)
 {
-    return JSExecState::call(lexicalGlobalObject, functionObject, callType, callData, thisValue, args, returnedException);
+    return JSExecState::call(lexicalGlobalObject, functionObject, callData, thisValue, args, returnedException);
 }
 
 JSC::JSValue evaluateHandlerFromAnyThread(JSC::JSGlobalObject* lexicalGlobalObject, const JSC::SourceCode& source, JSC::JSValue thisValue, NakedPtr<JSC::Exception>& returnedException)
index 16b3393..99c00de 100644 (file)
@@ -49,10 +49,10 @@ public:
         return threadGlobalData().currentState();
     };
     
-    static JSC::JSValue call(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException)
+    static JSC::JSValue call(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSValue functionObject, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException)
     {
         JSExecState currentState(lexicalGlobalObject);
-        return JSC::call(lexicalGlobalObject, functionObject, callType, callData, thisValue, args, returnedException);
+        return JSC::call(lexicalGlobalObject, functionObject, callData, thisValue, args, returnedException);
     };
 
     static JSC::JSValue evaluate(JSC::JSGlobalObject* lexicalGlobalObject, const JSC::SourceCode& source, JSC::JSValue thisValue, NakedPtr<JSC::Exception>& returnedException)
@@ -67,10 +67,10 @@ public:
         return evaluate(lexicalGlobalObject, source, thisValue, unused);
     };
 
-    static JSC::JSValue profiledCall(JSC::JSGlobalObject* lexicalGlobalObject, JSC::ProfilingReason reason, JSC::JSValue functionObject, JSC::CallType callType, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException)
+    static JSC::JSValue profiledCall(JSC::JSGlobalObject* lexicalGlobalObject, JSC::ProfilingReason reason, JSC::JSValue functionObject, const JSC::CallData& callData, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException)
     {
         JSExecState currentState(lexicalGlobalObject);
-        return JSC::profiledCall(lexicalGlobalObject, reason, functionObject, callType, callData, thisValue, args, returnedException);
+        return JSC::profiledCall(lexicalGlobalObject, reason, functionObject, callData, thisValue, args, returnedException);
     }
 
     static JSC::JSValue profiledEvaluate(JSC::JSGlobalObject* lexicalGlobalObject, JSC::ProfilingReason reason, const JSC::SourceCode& source, JSC::JSValue thisValue, NakedPtr<JSC::Exception>& returnedException)
@@ -118,8 +118,7 @@ public:
         return returnValue;
     }
 
-    static void instrumentFunctionCall(ScriptExecutionContext*, JSC::CallType, const JSC::CallData&);
-    static void instrumentFunctionConstruct(ScriptExecutionContext*, JSC::ConstructType, const JSC::ConstructData&);
+    static void instrumentFunction(ScriptExecutionContext*, const JSC::CallData&);
 
 private:
     explicit JSExecState(JSC::JSGlobalObject* lexicalGlobalObject)
@@ -149,8 +148,6 @@ private:
         threadGlobalData().setCurrentState(lexicalGlobalObject);
     }
 
-    template<typename Type, Type jsType, typename DataType> static void instrumentFunctionInternal(ScriptExecutionContext*, Type, const DataType&);
-
     JSC::JSGlobalObject* m_previousState;
     JSC::JSLockHolder m_lock;
 
@@ -182,7 +179,7 @@ private:
     CustomElementReactionStack m_customElementReactionStack;
 };
 
-JSC::JSValue functionCallHandlerFromAnyThread(JSC::JSGlobalObject*, JSC::JSValue functionObject, JSC::CallType, const JSC::CallData&, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException);
+JSC::JSValue functionCallHandlerFromAnyThread(JSC::JSGlobalObject*, JSC::JSValue functionObject, const JSC::CallData&, JSC::JSValue thisValue, const JSC::ArgList& args, NakedPtr<JSC::Exception>& returnedException);
 JSC::JSValue evaluateHandlerFromAnyThread(JSC::JSGlobalObject*, const JSC::SourceCode&, JSC::JSValue thisValue, NakedPtr<JSC::Exception>& returnedException);
 
 } // namespace WebCore
index 7674777..3a62010 100644 (file)
@@ -32,8 +32,7 @@
 
 namespace WebCore {
 
-template<typename Type, Type jsType, class DataType>
-inline void JSExecState::instrumentFunctionInternal(ScriptExecutionContext* context, Type callType, const DataType& callData)
+inline void JSExecState::instrumentFunction(ScriptExecutionContext* context, const CallData& callData)
 {
     if (!InspectorInstrumentation::timelineAgentTracking(context))
         return;
@@ -41,7 +40,7 @@ inline void JSExecState::instrumentFunctionInternal(ScriptExecutionContext* cont
     String resourceName;
     int lineNumber = 1;
     int columnNumber = 1;
-    if (callType == jsType) {
+    if (callData.type == CallData::Type::JS) {
         resourceName = callData.js.functionExecutable->sourceURL();
         lineNumber = callData.js.functionExecutable->firstLine();
         columnNumber = callData.js.functionExecutable->startColumn();
@@ -50,14 +49,4 @@ inline void JSExecState::instrumentFunctionInternal(ScriptExecutionContext* cont
     InspectorInstrumentation::willCallFunction(context, resourceName, lineNumber, columnNumber);
 }
 
-inline void JSExecState::instrumentFunctionCall(ScriptExecutionContext* context, JSC::CallType type, const JSC::CallData& data)
-{
-    instrumentFunctionInternal<JSC::CallType, JSC::CallType::JS, JSC::CallData>(context, type, data);
-}
-
-inline void JSExecState::instrumentFunctionConstruct(ScriptExecutionContext* context, JSC::ConstructType type, const JSC::ConstructData& data)
-{
-    instrumentFunctionInternal<JSC::ConstructType, JSC::ConstructType::JS, JSC::ConstructData>(context, type, data);
-}
-
 } // namespace WebCore
index 37c5e23..d9ce5db 100644 (file)
@@ -43,14 +43,13 @@ JSC::JSValue JSNavigator::getUserMedia(JSC::JSGlobalObject& lexicalGlobalObject,
     auto* function = globalObject()->builtinInternalFunctions().jsDOMBindingInternals().m_getUserMediaShimFunction.get();
     ASSERT(function);
 
-    JSC::CallData callData;
-    JSC::CallType callType = JSC::getCallData(lexicalGlobalObject.vm(), function, callData);
-    ASSERT(callType != JSC::CallType::None);
+    auto callData = JSC::getCallData(lexicalGlobalObject.vm(), function);
+    ASSERT(callData.type != JSC::CallData::Type::None);
     JSC::MarkedArgumentBuffer arguments;
     for (size_t cptr = 0; cptr < callFrame.argumentCount(); ++cptr)
         arguments.append(callFrame.uncheckedArgument(cptr));
     ASSERT(!arguments.hasOverflowed());
-    JSC::call(&lexicalGlobalObject, function, callType, callData, this, arguments);
+    JSC::call(&lexicalGlobalObject, function, callData, this, arguments);
     return JSC::jsUndefined();
 }
 #endif
index ddcf285..0648378 100644 (file)
@@ -153,34 +153,35 @@ static EncodedJSValue JSC_HOST_CALL callPlugin(JSGlobalObject* lexicalGlobalObje
         argumentList.append(callFrame->argument(i));
     ASSERT(!argumentList.hasOverflowed());
 
-    CallData callData;
-    CallType callType = getCallData(lexicalGlobalObject->vm(), scriptObject, callData);
-    ASSERT(callType == CallType::Host);
+    auto callData = getCallData(lexicalGlobalObject->vm(), scriptObject);
+    ASSERT(callData.type == CallData::Type::Native);
 
     // Call the object.
-    JSValue result = call(lexicalGlobalObject, scriptObject, callType, callData, callFrame->thisValue(), argumentList);
+    JSValue result = call(lexicalGlobalObject, scriptObject, callData, callFrame->thisValue(), argumentList);
     return JSValue::encode(result);
 }
 
-CallType pluginElementCustomGetCallData(JSHTMLElement* element, CallData& callData)
+CallData pluginElementCustomGetCallData(JSHTMLElement* element)
 {
+    CallData callData;
+
     // First, ask the plug-in view base for its runtime object.
     if (JSObject* scriptObject = pluginScriptObjectFromPluginViewBase(element)) {
-        CallData scriptObjectCallData;
-        
         VM& vm = scriptObject->vm();
-        if (scriptObject->methodTable(vm)->getCallData(scriptObject, scriptObjectCallData) == CallType::None)
-            return CallType::None;
-
-        callData.native.function = callPlugin;
-        return CallType::Host;
+        auto scriptObjectCallData = getCallData(vm, scriptObject);
+        if (scriptObjectCallData.type != CallData::Type::None) {
+            callData.type = CallData::Type::Native;
+            callData.native.function = callPlugin;
+        }
+    } else {
+        Instance* instance = pluginInstance(element->wrapped());
+        if (instance && instance->supportsInvokeDefaultMethod()) {
+            callData.type = CallData::Type::Native;
+            callData.native.function = callPlugin;
+        }
     }
-    
-    Instance* instance = pluginInstance(element->wrapped());
-    if (!instance || !instance->supportsInvokeDefaultMethod())
-        return CallType::None;
-    callData.native.function = callPlugin;
-    return CallType::Host;
+
+    return callData;
 }
 
 } // namespace WebCore
index 8d5b28d..8d8505e 100644 (file)
@@ -39,6 +39,6 @@ namespace WebCore {
 
     bool pluginElementCustomGetOwnPropertySlot(JSHTMLElement*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::PropertySlot&);
     bool pluginElementCustomPut(JSHTMLElement*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::JSValue, JSC::PutPropertySlot&, bool& putResult);
-    JSC::CallType pluginElementCustomGetCallData(JSHTMLElement*, JSC::CallData&);
+    JSC::CallData pluginElementCustomGetCallData(JSHTMLElement*);
 
 } // namespace WebCore
index e4c2504..57eeb57 100644 (file)
@@ -45,15 +45,14 @@ Ref<ReadableStream> ReadableStream::create(JSC::JSGlobalObject& lexicalGlobalObj
 
     auto* constructor = JSC::asObject(globalObject.get(&lexicalGlobalObject, clientData.builtinNames().ReadableStreamPrivateName()));
 
-    ConstructData constructData;
-    ConstructType constructType = constructor->methodTable(vm)->getConstructData(constructor, constructData);
-    ASSERT(constructType != ConstructType::None);
+    auto constructData = getConstructData(vm, constructor);
+    ASSERT(constructData.type != CallData::Type::None);
 
     MarkedArgumentBuffer args;
     args.append(source ? toJSNewlyCreated(&lexicalGlobalObject, &globalObject, source.releaseNonNull()) : JSC::jsUndefined());
     ASSERT(!args.hasOverflowed());
 
-    auto newReadableStream = jsDynamicCast<JSReadableStream*>(vm, JSC::construct(&lexicalGlobalObject, constructor, constructType, constructData, args));
+    auto newReadableStream = jsDynamicCast<JSReadableStream*>(vm, JSC::construct(&lexicalGlobalObject, constructor, constructData, args));
     scope.assertNoException();
 
     return create(globalObject, *newReadableStream);
@@ -64,10 +63,9 @@ static inline JSC::JSValue callFunction(JSC::JSGlobalObject& lexicalGlobalObject
 {
     VM& vm = lexicalGlobalObject.vm();
     auto scope = DECLARE_CATCH_SCOPE(vm);
-    JSC::CallData callData;
-    auto callType = JSC::getCallData(vm, jsFunction, callData);
-    ASSERT(callType != JSC::CallType::None);
-    auto result = call(&lexicalGlobalObject, jsFunction, callType, callData, thisValue, arguments);
+    auto callData = JSC::getCallData(vm, jsFunction);
+    ASSERT(callData.type != JSC::CallData::Type::None);
+    auto result = call(&lexicalGlobalObject, jsFunction, callData, thisValue, arguments);
     scope.assertNoException();
     return result;
 }
@@ -120,15 +118,14 @@ void ReadableStream::lock()
 
     auto* constructor = JSC::asObject(m_globalObject->get(&lexicalGlobalObject, clientData.builtinNames().ReadableStreamDefaultReaderPrivateName()));
 
-    ConstructData constructData;
-    ConstructType constructType = constructor->methodTable(vm)->getConstructData(constructor, constructData);
-    ASSERT(constructType != ConstructType::None);
+    auto constructData = getConstructData(vm, constructor);
+    ASSERT(constructData.type != CallData::Type::None);
 
     MarkedArgumentBuffer args;
     args.append(readableStream());
     ASSERT(!args.hasOverflowed());
 
-    JSC::construct(&lexicalGlobalObject, constructor, constructType, constructData, args);
+    JSC::construct(&lexicalGlobalObject, constructor, constructData, args);
     scope.assertNoException();
 }
 
index 01d5151..d99be89 100644 (file)
@@ -43,9 +43,8 @@ namespace WebCore {
 
 static inline JSC::JSValue readableStreamCallFunction(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSValue jsFunction, JSC::JSValue thisValue, const JSC::ArgList& arguments)
 {
-    JSC::CallData callData;
-    auto callType = JSC::getCallData(lexicalGlobalObject.vm(), jsFunction, callData);
-    return call(&lexicalGlobalObject, jsFunction, callType, callData, thisValue, arguments);
+    auto callData = JSC::getCallData(lexicalGlobalObject.vm(), jsFunction);
+    return call(&lexicalGlobalObject, jsFunction, callData, thisValue, arguments);
 }
 
 JSC::JSValue ReadableStreamDefaultController::invoke(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSObject& object, const char* propertyName, JSC::JSValue parameter)
index 8e4c7b3..567a00e 100644 (file)
@@ -95,9 +95,8 @@ void ScheduledAction::executeFunctionInContext(JSGlobalObject* globalObject, JSV
     JSLockHolder lock(vm);
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    CallData callData;
-    CallType callType = getCallData(vm, m_function.get(), callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, m_function.get());
+    if (callData.type == CallData::Type::None)
         return;
 
     JSGlobalObject* lexicalGlobalObject = globalObject;
@@ -112,10 +111,10 @@ void ScheduledAction::executeFunctionInContext(JSGlobalObject* globalObject, JSV
         return;
     }
 
-    JSExecState::instrumentFunctionCall(&context, callType, callData);
+    JSExecState::instrumentFunction(&context, callData);
 
     NakedPtr<JSC::Exception> exception;
-    JSExecState::profiledCall(lexicalGlobalObject, JSC::ProfilingReason::Other, m_function.get(), callType, callData, thisValue, arguments, exception);
+    JSExecState::profiledCall(lexicalGlobalObject, JSC::ProfilingReason::Other, m_function.get(), callData, thisValue, arguments, exception);
 
     InspectorInstrumentation::didCallFunction(&context);
 
index 3a48022..11789a9 100644 (file)
@@ -665,15 +665,14 @@ ValueOrException ScriptController::callInWorld(RunJavaScriptParameters&& paramet
         }
 
         // FIXME: https://bugs.webkit.org/show_bug.cgi?id=205562
-        // Getting CallData/CallType shouldn't be required to call into JS.
-        CallData callData;
-        CallType callType = getCallData(world.vm(), functionObject, callData);
-        if (callType == CallType::None) {
+        // Getting CallData shouldn't be required to call into JS.
+        auto callData = getCallData(world.vm(), functionObject);
+        if (callData.type == CallData::Type::None) {
             optionalDetails = { { "Unable to prepare JavaScript async function to be called"_s } };
             break;
         }
 
-        returnValue = JSExecState::profiledCall(&globalObject, JSC::ProfilingReason::Other, functionObject, callType, callData, &proxy, markedArguments, evaluationException);
+        returnValue = JSExecState::profiledCall(&globalObject, JSC::ProfilingReason::Other, functionObject, callData, &proxy, markedArguments, evaluationException);
     } while (false);
 
     InspectorInstrumentation::didEvaluateScript(m_frame);
@@ -732,9 +731,8 @@ void ScriptController::executeAsynchronousUserAgentScriptInWorld(DOMWrapperWorld
         return;
     }
 
-    CallData callData;
-    CallType callType = asObject(thenFunction)->methodTable(world.vm())->getCallData(asObject(thenFunction), callData);
-    if (callType == CallType::None) {
+    auto callData = getCallData(world.vm(), thenFunction);
+    if (callData.type == CallData::Type::None) {
         resolveCompletionHandler(result);
         return;
     }
@@ -772,7 +770,7 @@ void ScriptController::executeAsynchronousUserAgentScriptInWorld(DOMWrapperWorld
     arguments.append(fulfillHandler);
     arguments.append(rejectHandler);
 
-    call(&globalObject, thenFunction, callType, callData, result.value(), arguments);
+    call(&globalObject, thenFunction, callData, result.value(), arguments);
 }
 
 Expected<void, ExceptionDetails> ScriptController::shouldAllowUserAgentScripts(Document& document) const
index 371d78e..654e783 100644 (file)
@@ -2704,7 +2704,7 @@ sub GenerateHeader
     }
 
     if (InstanceOverridesGetCallData($interface)) {
-        push(@headerContent, "    static JSC::CallType getCallData(JSC::JSCell*, JSC::CallData&);\n\n");
+        push(@headerContent, "    static JSC::CallData getCallData(JSC::JSCell*);\n\n");
         $headerIncludes{"<JavaScriptCore/CallData.h>"} = 1;
         $structureFlags{"JSC::OverridesGetCallData"} = 1;
     }
@@ -5619,12 +5619,12 @@ sub GeneratePluginCall
 
     AddToImplIncludes("JSPluginElementFunctions.h");
 
-    push(@$outputArray, "CallType ${className}::getCallData(JSCell* cell, CallData& callData)\n");
+    push(@$outputArray, "CallData ${className}::getCallData(JSCell* cell)\n");
     push(@$outputArray, "{\n");
     push(@$outputArray, "    auto* thisObject = jsCast<${className}*>(cell);\n");
     push(@$outputArray, "    ASSERT_GC_OBJECT_INHERITS(thisObject, info());\n\n");
 
-    push(@$outputArray, "    return pluginElementCustomGetCallData(thisObject, callData);\n");
+    push(@$outputArray, "    return pluginElementCustomGetCallData(thisObject);\n");
     push(@$outputArray, "}\n");
     push(@$outputArray, "\n");
 }
@@ -5654,10 +5654,12 @@ sub GenerateLegacyCallerDefinitions
         GenerateLegacyCallerDefinition($outputArray, $interface, $className, $legacyCallers[0]);
     }
 
-    push(@$outputArray, "CallType ${className}::getCallData(JSCell*, CallData& callData)\n");
+    push(@$outputArray, "CallData ${className}::getCallData(JSCell*)\n");
     push(@$outputArray, "{\n");
+    push(@$outputArray, "    CallData callData;\n");
+    push(@$outputArray, "    callData.type = CallData::Type::Native;\n");
     push(@$outputArray, "    callData.native.function = call${className};\n");
-    push(@$outputArray, "    return CallType::Host;\n");
+    push(@$outputArray, "    return callData;\n");
     push(@$outputArray, "}\n");
     push(@$outputArray, "\n");
 }
index 450b835..12b8632 100644 (file)
@@ -2609,10 +2609,12 @@ EncodedJSValue JSC_HOST_CALL callJSTestObj(JSGlobalObject* lexicalGlobalObject,
     return throwVMTypeError(lexicalGlobalObject, throwScope);
 }
 
-CallType JSTestObj::getCallData(JSCell*, CallData& callData)
+CallData JSTestObj::getCallData(JSCell*)
 {
+    CallData callData;
+    callData.type = CallData::Type::Native;
     callData.native.function = callJSTestObj;
-    return CallType::Host;
+    return callData;
 }
 
 template<> inline JSTestObj* IDLAttribute<JSTestObj>::cast(JSGlobalObject& lexicalGlobalObject, EncodedJSValue thisValue)
index a64d4fb..be69f6c 100644 (file)
@@ -45,7 +45,7 @@ public:
     static bool getOwnPropertySlot(JSC::JSObject*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::PropertySlot&);
     static bool getOwnPropertySlotByIndex(JSC::JSObject*, JSC::JSGlobalObject*, unsigned propertyName, JSC::PropertySlot&);
     static void getOwnPropertyNames(JSC::JSObject*, JSC::JSGlobalObject*, JSC::PropertyNameArray&, JSC::EnumerationMode = JSC::EnumerationMode());
-    static JSC::CallType getCallData(JSC::JSCell*, JSC::CallData&);
+    static JSC::CallData getCallData(JSC::JSCell*);
 
     static void destroy(JSC::JSCell*);
 
index 7432460..0980001 100644 (file)
@@ -196,12 +196,12 @@ bool JSTestPluginInterface::putByIndex(JSCell* cell, JSGlobalObject* lexicalGlob
     return JSObject::putByIndex(cell, lexicalGlobalObject, index, value, shouldThrow);
 }
 
-CallType JSTestPluginInterface::getCallData(JSCell* cell, CallData& callData)
+CallData JSTestPluginInterface::getCallData(JSCell* cell)
 {
     auto* thisObject = jsCast<JSTestPluginInterface*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
 
-    return pluginElementCustomGetCallData(thisObject, callData);
+    return pluginElementCustomGetCallData(thisObject);
 }
 
 EncodedJSValue jsTestPluginInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
index f947ba8..ecee4a9 100644 (file)
@@ -44,7 +44,7 @@ public:
     static bool getOwnPropertySlotByIndex(JSC::JSObject*, JSC::JSGlobalObject*, unsigned propertyName, JSC::PropertySlot&);
     static bool put(JSC::JSCell*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::JSValue, JSC::PutPropertySlot&);
     static bool putByIndex(JSC::JSCell*, JSC::JSGlobalObject*, unsigned propertyName, JSC::JSValue, bool shouldThrow);
-    static JSC::CallType getCallData(JSC::JSCell*, JSC::CallData&);
+    static JSC::CallData getCallData(JSC::JSCell*);
 
     static void destroy(JSC::JSCell*);
 
index a417f5c..33cd4c0 100644 (file)
@@ -188,15 +188,14 @@ bool _NPN_InvokeDefault(NPP, NPObject* o, const NPVariant* args, uint32_t argCou
         
         // Call the function object.
         JSValue function = obj->imp;
-        CallData callData;
-        CallType callType = getCallData(vm, function, callData);
-        if (callType == CallType::None)
+        auto callData = getCallData(vm, function);
+        if (callData.type == CallData::Type::None)
             return false;
         
         MarkedArgumentBuffer argList;
         getListFromVariantArgs(lexicalGlobalObject, args, argCount, rootObject, argList);
         RELEASE_ASSERT(!argList.hasOverflowed());
-        JSValue resultV = JSC::call(lexicalGlobalObject, function, callType, callData, function, argList);
+        JSValue resultV = JSC::call(lexicalGlobalObject, function, callData, function, argList);
 
         // Convert and return the result of the function call.
         convertValueToNPVariant(lexicalGlobalObject, resultV, result);
@@ -240,16 +239,15 @@ bool _NPN_Invoke(NPP npp, NPObject* o, NPIdentifier methodName, const NPVariant*
 
         JSGlobalObject* lexicalGlobalObject = globalObject;
         JSValue function = obj->imp->get(lexicalGlobalObject, identifierFromNPIdentifier(lexicalGlobalObject, i->string()));
-        CallData callData;
-        CallType callType = getCallData(vm, function, callData);
-        if (callType == CallType::None)
+        auto callData = getCallData(vm, function);
+        if (callData.type == CallData::Type::None)
             return false;
 
         // Call the function object.
         MarkedArgumentBuffer argList;
         getListFromVariantArgs(lexicalGlobalObject, args, argCount, rootObject, argList);
         RELEASE_ASSERT(!argList.hasOverflowed());
-        JSValue resultV = JSC::call(lexicalGlobalObject, function, callType, callData, obj->imp, argList);
+        JSValue resultV = JSC::call(lexicalGlobalObject, function, callData, obj->imp, argList);
 
         // Convert and return the result of the function call.
         convertValueToNPVariant(lexicalGlobalObject, resultV, result);
@@ -531,15 +529,14 @@ bool _NPN_Construct(NPP, NPObject* o, const NPVariant* args, uint32_t argCount,
         
         // Call the constructor object.
         JSValue constructor = obj->imp;
-        ConstructData constructData;
-        ConstructType constructType = getConstructData(vm, constructor, constructData);
-        if (constructType == ConstructType::None)
+        auto constructData = getConstructData(vm, constructor);
+        if (constructData.type == CallData::Type::None)
             return false;
         
         MarkedArgumentBuffer argList;
         getListFromVariantArgs(lexicalGlobalObject, args, argCount, rootObject, argList);
         RELEASE_ASSERT(!argList.hasOverflowed());
-        JSValue resultV = JSC::construct(lexicalGlobalObject, constructor, constructType, constructData, argList);
+        JSValue resultV = JSC::construct(lexicalGlobalObject, constructor, constructData, argList);
         
         // Convert and return the result.
         convertValueToNPVariant(lexicalGlobalObject, resultV, result);
index e906221..f9cedc1 100644 (file)
@@ -58,7 +58,6 @@ using namespace JSC::Bindings;
 using namespace WebCore;
 
 using JSC::CallData;
-using JSC::CallType;
 using JSC::Identifier;
 using JSC::JSLockHolder;
 using JSC::JSObject;
@@ -347,9 +346,8 @@ static void getListFromNSArray(JSC::JSGlobalObject* lexicalGlobalObject, NSArray
     UNUSED_PARAM(scope);
 
     JSC::JSValue function = [self _imp]->get(lexicalGlobalObject, Identifier::fromString(vm, String(name)));
-    CallData callData;
-    CallType callType = getCallData(vm, function, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, function);
+    if (callData.type == CallData::Type::None)
         return nil;
 
     MarkedArgumentBuffer argList;
@@ -360,7 +358,7 @@ static void getListFromNSArray(JSC::JSGlobalObject* lexicalGlobalObject, NSArray
         return nil;
 
     NakedPtr<JSC::Exception> exception;
-    JSC::JSValue result = JSExecState::profiledCall(lexicalGlobalObject, JSC::ProfilingReason::Other, function, callType, callData, [self _imp], argList, exception);
+    JSC::JSValue result = JSExecState::profiledCall(lexicalGlobalObject, JSC::ProfilingReason::Other, function, callData, [self _imp], argList, exception);
 
     if (exception) {
         addExceptionToConsole(lexicalGlobalObject, exception);
index 069abe2..e3ae226 100644 (file)
@@ -131,7 +131,7 @@ private:
     static void destroy(JSCell*);
     static bool getOwnPropertySlot(JSObject*, JSGlobalObject*, PropertyName, PropertySlot&);
     static bool put(JSCell*, JSGlobalObject*, PropertyName, JSValue, PutPropertySlot&);
-    static CallType getCallData(JSCell*, CallData&);
+    static CallData getCallData(JSCell*);
     static bool deleteProperty(JSCell*, JSGlobalObject*, PropertyName, DeletePropertySlot&);
     static JSValue defaultValue(const JSObject*, JSGlobalObject*, PreferredPrimitiveType);
 
index 6e877d2..e657c01 100644 (file)
@@ -280,14 +280,18 @@ static EncodedJSValue JSC_HOST_CALL callObjCFallbackObject(JSGlobalObject* lexic
     return JSValue::encode(result);
 }
 
-CallType ObjcFallbackObjectImp::getCallData(JSCell* cell, CallData& callData)
+CallData ObjcFallbackObjectImp::getCallData(JSCell* cell)
 {
+    CallData callData;
+
     ObjcFallbackObjectImp* thisObject = jsCast<ObjcFallbackObjectImp*>(cell);
     id targetObject = thisObject->_instance->getObject();
-    if (![targetObject respondsToSelector:@selector(invokeUndefinedMethodFromWebScript:withArguments:)])
-        return CallType::None;
-    callData.native.function = callObjCFallbackObject;
-    return CallType::Host;
+    if ([targetObject respondsToSelector:@selector(invokeUndefinedMethodFromWebScript:withArguments:)]) {
+        callData.type = CallData::Type::Native;
+        callData.native.function = callObjCFallbackObject;
+    }
+
+    return callData;
 }
 
 bool ObjcFallbackObjectImp::deleteProperty(JSCell*, JSGlobalObject*, PropertyName, DeletePropertySlot&)
index 9d5d60d..8051e6e 100644 (file)
@@ -233,18 +233,17 @@ static EncodedJSValue JSC_HOST_CALL callRuntimeObject(JSGlobalObject* globalObje
     return JSValue::encode(result);
 }
 
-CallType RuntimeObject::getCallData(JSCell* cell, CallData& callData)
+CallData RuntimeObject::getCallData(JSCell* cell)
 {
+    CallData callData;
+
     RuntimeObject* thisObject = jsCast<RuntimeObject*>(cell);
-    if (!thisObject->m_instance)
-        return CallType::None;
-    
-    RefPtr<Instance> instance = thisObject->m_instance;
-    if (!instance->supportsInvokeDefaultMethod())
-        return CallType::None;
-    
-    callData.native.function = callRuntimeObject;
-    return CallType::Host;
+    if (thisObject->m_instance && thisObject->m_instance->supportsInvokeDefaultMethod()) {
+        callData.type = CallData::Type::Native;
+        callData.native.function = callRuntimeObject;
+    }
+
+    return callData;
 }
 
 static EncodedJSValue JSC_HOST_CALL callRuntimeConstructor(JSGlobalObject* globalObject, CallFrame* callFrame)
@@ -261,18 +260,17 @@ static EncodedJSValue JSC_HOST_CALL callRuntimeConstructor(JSGlobalObject* globa
     return JSValue::encode(result.isObject() ? jsCast<JSObject*>(result.asCell()) : constructor);
 }
 
-ConstructType RuntimeObject::getConstructData(JSCell* cell, ConstructData& constructData)
+CallData RuntimeObject::getConstructData(JSCell* cell)
 {
+    CallData constructData;
+
     RuntimeObject* thisObject = jsCast<RuntimeObject*>(cell);
-    if (!thisObject->m_instance)
-        return ConstructType::None;
-    
-    RefPtr<Instance> instance = thisObject->m_instance;
-    if (!instance->supportsConstruct())
-        return ConstructType::None;
-    
-    constructData.native.function = callRuntimeConstructor;
-    return ConstructType::Host;
+    if (thisObject->m_instance && thisObject->m_instance->supportsConstruct()) {
+        constructData.type = CallData::Type::Native;
+        constructData.native.function = callRuntimeConstructor;
+    }
+
+    return constructData;
 }
 
 void RuntimeObject::getOwnPropertyNames(JSObject* object, JSGlobalObject* lexicalGlobalObject, PropertyNameArray& propertyNames, EnumerationMode)
index 3c10d8b..040a3a0 100644 (file)
@@ -59,8 +59,8 @@ public:
     static bool put(JSCell*, JSGlobalObject*, PropertyName, JSValue, PutPropertySlot&);
     static bool deleteProperty(JSCell*, JSGlobalObject*, PropertyName, DeletePropertySlot&);
     static JSValue defaultValue(const JSObject*, JSGlobalObject*, PreferredPrimitiveType);
-    static CallType getCallData(JSCell*, CallData&);
-    static ConstructType getConstructData(JSCell*, ConstructData&);
+    static CallData getCallData(JSCell*);
+    static CallData getConstructData(JSCell*);
 
     static void getOwnPropertyNames(JSObject*, JSGlobalObject*, PropertyNameArray&, EnumerationMode);
 
index b7e2f3a..69b4bf1 100644 (file)
@@ -4362,14 +4362,13 @@ void HTMLMediaElement::updateCaptionContainer()
         if (!methodObject)
             return false;
 
-        JSC::CallData callData;
-        auto callType = methodObject->methodTable(vm)->getCallData(methodObject, callData);
-        if (callType == JSC::CallType::None)
+        auto callData = JSC::getCallData(vm, methodObject);
+        if (callData.type == JSC::CallData::Type::None)
             return false;
 
         JSC::MarkedArgumentBuffer noArguments;
         ASSERT(!noArguments.hasOverflowed());
-        JSC::call(&lexicalGlobalObject, methodObject, callType, callData, controllerObject, noArguments);
+        JSC::call(&lexicalGlobalObject, methodObject, callData, controllerObject, noArguments);
         scope.clearException();
 
         m_haveSetUpCaptionContainer = true;
@@ -7243,12 +7242,11 @@ void HTMLMediaElement::didAddUserAgentShadowRoot(ShadowRoot& root)
 
         auto* function = functionValue.toObject(&lexicalGlobalObject);
         scope.assertNoException();
-        JSC::CallData callData;
-        auto callType = function->methodTable(vm)->getCallData(function, callData);
-        if (callType == JSC::CallType::None)
+        auto callData = JSC::getCallData(vm, function);
+        if (callData.type == JSC::CallData::Type::None)
             return false;
 
-        auto controllerValue = JSC::call(&lexicalGlobalObject, function, callType, callData, &globalObject, argList);
+        auto controllerValue = JSC::call(&lexicalGlobalObject, function, callData, &globalObject, argList);
         scope.clearException();
         auto* controllerObject = JSC::jsDynamicCast<JSC::JSObject*>(vm, controllerValue);
         if (!controllerObject)
@@ -7321,14 +7319,13 @@ void HTMLMediaElement::updateMediaControlsAfterPresentationModeChange()
 
         auto* function = functionValue.toObject(&lexicalGlobalObject);
         scope.assertNoException();
-        JSC::CallData callData;
-        auto callType = function->methodTable(vm)->getCallData(function, callData);
-        if (callType == JSC::CallType::None)
+        auto callData = JSC::getCallData(vm, function);
+        if (callData.type == JSC::CallData::Type::None)
             return false;
 
         JSC::MarkedArgumentBuffer argList;
         ASSERT(!argList.hasOverflowed());
-        JSC::call(&lexicalGlobalObject, function, callType, callData, controllerObject, argList);
+        JSC::call(&lexicalGlobalObject, function, callData, controllerObject, argList);
 
         return true;
     });
@@ -7365,14 +7362,13 @@ String HTMLMediaElement::getCurrentMediaControlsStatus()
 
         auto* function = functionValue.toObject(&lexicalGlobalObject);
         scope.assertNoException();
-        JSC::CallData callData;
-        auto callType = function->methodTable(vm)->getCallData(function, callData);
+        auto callData = JSC::getCallData(vm, function);
         JSC::MarkedArgumentBuffer argList;
         ASSERT(!argList.hasOverflowed());
-        if (callType == JSC::CallType::None)
+        if (callData.type == JSC::CallData::Type::None)
             return false;
 
-        auto outputValue = JSC::call(&lexicalGlobalObject, function, callType, callData, controllerObject, argList);
+        auto outputValue = JSC::call(&lexicalGlobalObject, function, callData, controllerObject, argList);
 
         RETURN_IF_EXCEPTION(scope, false);
 
index 60cb4fe..7f0354f 100644 (file)
@@ -412,12 +412,11 @@ void HTMLPlugInImageElement::didAddUserAgentShadowRoot(ShadowRoot& root)
         scope.clearException();
         return;
     }
-    JSC::CallData callData;
-    auto callType = overlay->methodTable(vm)->getCallData(overlay, callData);
-    if (callType == JSC::CallType::None)
+    auto callData = JSC::getCallData(vm, overlay);
+    if (callData.type == JSC::CallData::Type::None)
         return;
 
-    call(&lexicalGlobalObject, overlay, callType, callData, &globalObject, argList);
+    call(&lexicalGlobalObject, overlay, callData, &globalObject, argList);
     scope.clearException();
 }
 
index 5d19173..01fcfd5 100644 (file)
 #endif
 
 using JSC::CallData;
-using JSC::CallType;
 using JSC::CodeBlock;
 using JSC::FunctionExecutable;
 using JSC::Identifier;
@@ -4650,16 +4649,15 @@ JSValue Internals::cloneArrayBuffer(JSC::JSGlobalObject& lexicalGlobalObject, JS
     ASSERT(value.isFunction(vm));
 
     JSObject* function = value.getObject();
-    CallData callData;
-    CallType callType = JSC::getCallData(vm, function, callData);
-    ASSERT(callType != JSC::CallType::None);
+    auto callData = JSC::getCallData(vm, function);
+    ASSERT(callData.type != JSC::CallData::Type::None);
     MarkedArgumentBuffer arguments;
     arguments.append(buffer);
     arguments.append(srcByteOffset);
     arguments.append(srcLength);
     ASSERT(!arguments.hasOverflowed());
 
-    return JSC::call(&lexicalGlobalObject, function, callType, callData, JSC::jsUndefined(), arguments);
+    return JSC::call(&lexicalGlobalObject, function, callData, JSC::jsUndefined(), arguments);
 }
 
 #endif
index 6f78138..f01f6d9 100644 (file)
@@ -1,3 +1,19 @@
+2020-04-27  Ross Kirsling  <ross.kirsling@sony.com>
+
+        [JSC] CallData/ConstructData should include CallType/ConstructType
+        https://bugs.webkit.org/show_bug.cgi?id=211059
+
+        Reviewed by Darin Adler.
+
+        * WebProcess/Plugins/Netscape/JSNPObject.cpp:
+        (WebKit::JSNPObject::getCallData):
+        (WebKit::JSNPObject::getConstructData):
+        * WebProcess/Plugins/Netscape/JSNPObject.h:
+        * WebProcess/Plugins/Netscape/NPJSObject.cpp:
+        (WebKit::NPJSObject::hasMethod):
+        (WebKit::NPJSObject::construct):
+        (WebKit::NPJSObject::invoke):
+
 2020-04-27  Diego Pino Garcia  <dpino@igalia.com>
 
         Unreviewed, reverting r260672.
index 05d1292..e3de91a 100644 (file)
@@ -247,15 +247,16 @@ static EncodedJSValue JSC_HOST_CALL callNPJSObject(JSGlobalObject* globalObject,
     return JSValue::encode(jsCast<JSNPObject*>(object)->callObject(globalObject, callFrame));
 }
 
-JSC::CallType JSNPObject::getCallData(JSC::JSCell* cell, JSC::CallData& callData)
+CallData JSNPObject::getCallData(JSCell* cell)
 {
+    CallData callData;
     JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    if (!thisObject->m_npObject || !thisObject->m_npObject->_class->invokeDefault)
-        return CallType::None;
-
-    callData.native.function = callNPJSObject;
-    return CallType::Host;
+    if (thisObject->m_npObject && thisObject->m_npObject->_class->invokeDefault) {
+        callData.type = CallData::Type::Native;
+        callData.native.function = callNPJSObject;
+    }
+    return callData;
 }
 
 static EncodedJSValue JSC_HOST_CALL constructWithConstructor(JSGlobalObject* globalObject, CallFrame* callFrame)
@@ -266,15 +267,18 @@ static EncodedJSValue JSC_HOST_CALL constructWithConstructor(JSGlobalObject* glo
     return JSValue::encode(jsCast<JSNPObject*>(constructor)->callConstructor(globalObject, callFrame));
 }
 
-ConstructType JSNPObject::getConstructData(JSCell* cell, ConstructData& constructData)
+CallData JSNPObject::getConstructData(JSCell* cell)
 {
+    CallData constructData;
+
     JSNPObject* thisObject = JSC::jsCast<JSNPObject*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    if (!thisObject->m_npObject || !thisObject->m_npObject->_class->construct)
-        return ConstructType::None;
+    if (thisObject->m_npObject && thisObject->m_npObject->_class->construct) {
+        constructData.type = CallData::Type::Native;
+        constructData.native.function = constructWithConstructor;
+    }
 
-    constructData.native.function = constructWithConstructor;
-    return ConstructType::Host;
+    return constructData;
 }
 
 bool JSNPObject::getOwnPropertySlot(JSObject* object, JSGlobalObject* lexicalGlobalObject, PropertyName propertyName, PropertySlot& slot)
index fa98432..4cc8f27 100644 (file)
@@ -87,8 +87,8 @@ private:
         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
     }
 
-    static JSC::CallType getCallData(JSC::JSCell*, JSC::CallData&);
-    static JSC::ConstructType getConstructData(JSC::JSCell*, JSC::ConstructData&);
+    static JSC::CallData getCallData(JSC::JSCell*);
+    static JSC::CallData getConstructData(JSC::JSCell*);
 
     static bool getOwnPropertySlot(JSC::JSObject*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::PropertySlot&);
     static bool put(JSC::JSCell*, JSC::JSGlobalObject*, JSC::PropertyName, JSC::JSValue, JSC::PutPropertySlot&);
index a7fb6b5..8f6f7b0 100644 (file)
@@ -109,8 +109,7 @@ bool NPJSObject::hasMethod(NPIdentifier methodName)
     JSValue value = m_jsObject->get(lexicalGlobalObject, identifierFromIdentifierRep(lexicalGlobalObject, identifierRep));    
     scope.clearException();
 
-    CallData callData;
-    return getCallData(vm, value, callData) != CallType::None;
+    return value.isFunction(vm);
 }
 
 bool NPJSObject::invoke(NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
@@ -277,9 +276,8 @@ bool NPJSObject::construct(const NPVariant* arguments, uint32_t argumentCount, N
     JSLockHolder lock(vm);
     auto scope = DECLARE_CATCH_SCOPE(vm);
 
-    ConstructData constructData;
-    ConstructType constructType = getConstructData(vm, m_jsObject.get(), constructData);
-    if (constructType == ConstructType::None)
+    auto constructData = getConstructData(vm, m_jsObject.get());
+    if (constructData.type == CallData::Type::None)
         return false;
 
     // Convert the passed in arguments.
@@ -288,7 +286,7 @@ bool NPJSObject::construct(const NPVariant* arguments, uint32_t argumentCount, N
         argumentList.append(m_objectMap->convertNPVariantToJSValue(m_objectMap->globalObject(), arguments[i]));
     RELEASE_ASSERT(!argumentList.hasOverflowed());
 
-    JSValue value = JSC::construct(lexicalGlobalObject, m_jsObject.get(), constructType, constructData, argumentList);
+    JSValue value = JSC::construct(lexicalGlobalObject, m_jsObject.get(), constructData, argumentList);
     
     // Convert and return the new object.
     m_objectMap->convertJSValueToNPVariant(lexicalGlobalObject, value, *result);
@@ -302,9 +300,8 @@ bool NPJSObject::invoke(JSGlobalObject* lexicalGlobalObject, JSValue function, c
     VM& vm = lexicalGlobalObject->vm();
     auto scope = DECLARE_CATCH_SCOPE(vm);
 
-    CallData callData;
-    CallType callType = getCallData(vm, function, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, function);
+    if (callData.type == CallData::Type::None)
         return false;
 
     // Convert the passed in arguments.
@@ -313,7 +310,7 @@ bool NPJSObject::invoke(JSGlobalObject* lexicalGlobalObject, JSValue function, c
         argumentList.append(m_objectMap->convertNPVariantToJSValue(lexicalGlobalObject, arguments[i]));
     RELEASE_ASSERT(!argumentList.hasOverflowed());
 
-    JSValue value = JSC::call(lexicalGlobalObject, function, callType, callData, m_jsObject.get(), argumentList);
+    JSValue value = JSC::call(lexicalGlobalObject, function, callData, m_jsObject.get(), argumentList);
 
     if (UNLIKELY(scope.exception())) {
         scope.clearException();
index c88bc9f..72e1533 100644 (file)
@@ -1,3 +1,15 @@
+2020-04-27  Ross Kirsling  <ross.kirsling@sony.com>
+
+        [JSC] CallData/ConstructData should include CallType/ConstructType
+        https://bugs.webkit.org/show_bug.cgi?id=211059
+
+        Reviewed by Darin Adler.
+
+        * Plugins/Hosted/NetscapePluginInstanceProxy.mm:
+        (WebKit::NetscapePluginInstanceProxy::invoke):
+        (WebKit::NetscapePluginInstanceProxy::invokeDefault):
+        (WebKit::NetscapePluginInstanceProxy::construct):
+
 2020-04-26  Darin Adler  <darin@apple.com>
 
         [Cocoa] stop using out arguments for document attributes when converting to attributed strings
index a6145e0..d3bd1ec 100644 (file)
@@ -920,16 +920,15 @@ bool NetscapePluginInstanceProxy::invoke(uint32_t objectID, const Identifier& me
 
     JSGlobalObject* lexicalGlobalObject = frame->script().globalObject(pluginWorld());
     JSValue function = object->get(lexicalGlobalObject, methodName);
-    CallData callData;
-    CallType callType = getCallData(vm, function, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, function);
+    if (callData.type == CallData::Type::None)
         return false;
 
     MarkedArgumentBuffer argList;
     demarshalValues(lexicalGlobalObject, argumentsData, argumentsLength, argList);
     RELEASE_ASSERT(!argList.hasOverflowed());
 
-    JSValue value = call(lexicalGlobalObject, function, callType, callData, object, argList);
+    JSValue value = call(lexicalGlobalObject, function, callData, object, argList);
         
     marshalValue(lexicalGlobalObject, value, resultData, resultLength);
     scope.clearException();
@@ -956,16 +955,15 @@ bool NetscapePluginInstanceProxy::invokeDefault(uint32_t objectID, data_t argume
     auto scope = DECLARE_CATCH_SCOPE(vm);
 
     JSGlobalObject* lexicalGlobalObject = frame->script().globalObject(pluginWorld());
-    CallData callData;
-    CallType callType = object->methodTable(vm)->getCallData(object, callData);
-    if (callType == CallType::None)
+    auto callData = getCallData(vm, object);
+    if (callData.type == CallData::Type::None)
         return false;
 
     MarkedArgumentBuffer argList;
     demarshalValues(lexicalGlobalObject, argumentsData, argumentsLength, argList);
     RELEASE_ASSERT(!argList.hasOverflowed());
 
-    JSValue value = call(lexicalGlobalObject, object, callType, callData, object, argList);
+    JSValue value = call(lexicalGlobalObject, object, callData, object, argList);
     
     marshalValue(lexicalGlobalObject, value, resultData, resultLength);
     scope.clearException();
@@ -993,16 +991,15 @@ bool NetscapePluginInstanceProxy::construct(uint32_t objectID, data_t argumentsD
 
     JSGlobalObject* lexicalGlobalObject = frame->script().globalObject(pluginWorld());
 
-    ConstructData constructData;
-    ConstructType constructType = object->methodTable(vm)->getConstructData(object, constructData);
-    if (constructType == ConstructType::None)
+    auto constructData = getConstructData(vm, object);
+    if (constructData.type == CallData::Type::None)
         return false;
 
     MarkedArgumentBuffer argList;
     demarshalValues(lexicalGlobalObject, argumentsData, argumentsLength, argList);
     RELEASE_ASSERT(!argList.hasOverflowed());
 
-    JSValue value = JSC::construct(lexicalGlobalObject, object, constructType, constructData, argList);
+    JSValue value = JSC::construct(lexicalGlobalObject, object, constructData, argList);
     
     marshalValue(lexicalGlobalObject, value, resultData, resultLength);
     scope.clearException();
index 4a74bf0..3b26008 100644 (file)
@@ -1,3 +1,13 @@
+2020-04-27  Ross Kirsling  <ross.kirsling@sony.com>
+
+        [JSC] CallData/ConstructData should include CallType/ConstructType
+        https://bugs.webkit.org/show_bug.cgi?id=211059
+
+        Reviewed by Darin Adler.
+
+        * Plugins/PluginPackage.cpp:
+        (WebCore::NPN_Invoke):
+
 2020-04-21  Darin Adler  <darin@apple.com>
 
         Stop using live ranges in functions that return range of the selection
index 0205889..8c21b06 100644 (file)
@@ -254,15 +254,14 @@ static bool NPN_Invoke(NPP npp, NPObject* o, NPIdentifier methodName, const NPVa
 
         JSC::JSGlobalObject* lexicalGlobalObject = globalObject;
         JSC::JSValue function = obj->imp->get(lexicalGlobalObject, JSC::Bindings::identifierFromNPIdentifier(lexicalGlobalObject, i->string()));
-        JSC::CallData callData;
-        JSC::CallType callType = getCallData(vm, function, callData);
-        if (callType == JSC::CallType::None)
+        auto callData = getCallData(vm, function);
+        if (callData.type == JSC::CallData::Type::None)
             return false;
 
         // Call the function object.
         JSC::MarkedArgumentBuffer argList;
         getListFromVariantArgs(lexicalGlobalObject, args, argCount, rootObject, argList);
-        JSC::JSValue resultV = JSC::call(lexicalGlobalObject, function, callType, callData, obj->imp, argList);
+        JSC::JSValue resultV = JSC::call(lexicalGlobalObject, function, callData, obj->imp, argList);
 
         // Convert and return the result of the function call.
         JSC::Bindings::convertValueToNPVariant(lexicalGlobalObject, resultV, result);