JSModuleLoader.cpp [plain text]
#include "config.h"
#include "JSModuleLoader.h"
#include "BuiltinNames.h"
#include "CatchScope.h"
#include "CodeProfiling.h"
#include "Error.h"
#include "Exception.h"
#include "JSCInlines.h"
#include "JSGlobalObjectFunctions.h"
#include "JSInternalPromise.h"
#include "JSInternalPromiseDeferred.h"
#include "JSMap.h"
#include "JSModuleEnvironment.h"
#include "JSModuleRecord.h"
#include "JSSourceCode.h"
#include "ModuleAnalyzer.h"
#include "ModuleLoaderPrototype.h"
#include "Nodes.h"
#include "ObjectConstructor.h"
#include "Parser.h"
#include "ParserError.h"
namespace JSC {
STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSModuleLoader);
const ClassInfo JSModuleLoader::s_info = { "ModuleLoader", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSModuleLoader) };
JSModuleLoader::JSModuleLoader(VM& vm, Structure* structure)
: JSNonFinalObject(vm, structure)
{
}
void JSModuleLoader::finishCreation(ExecState* exec, VM& vm, JSGlobalObject* globalObject)
{
auto scope = DECLARE_CATCH_SCOPE(vm);
Base::finishCreation(vm);
ASSERT(inherits(vm, info()));
JSMap* map = JSMap::create(exec, vm, globalObject->mapStructure());
scope.releaseAssertNoException();
putDirect(vm, Identifier::fromString(&vm, "registry"), map);
}
static String printableModuleKey(ExecState* exec, JSValue key)
{
VM& vm = exec->vm();
if (key.isString() || key.isSymbol())
return key.toPropertyKey(exec).impl();
return vm.propertyNames->emptyIdentifier.impl();
}
JSValue JSModuleLoader::provideFetch(ExecState* exec, JSValue key, const SourceCode& sourceCode)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSObject* function = jsCast<JSObject*>(get(exec, vm.propertyNames->builtinNames().provideFetchPublicName()));
RETURN_IF_EXCEPTION(scope, { });
CallData callData;
CallType callType = JSC::getCallData(function, callData);
ASSERT(callType != CallType::None);
SourceCode source { sourceCode };
MarkedArgumentBuffer arguments;
arguments.append(key);
arguments.append(JSSourceCode::create(vm, WTFMove(source)));
ASSERT(!arguments.hasOverflowed());
scope.release();
return call(exec, function, callType, callData, this, arguments);
}
JSInternalPromise* JSModuleLoader::loadAndEvaluateModule(ExecState* exec, JSValue moduleName, JSValue parameters, JSValue scriptFetcher)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSObject* function = jsCast<JSObject*>(get(exec, vm.propertyNames->builtinNames().loadAndEvaluateModulePublicName()));
RETURN_IF_EXCEPTION(scope, nullptr);
CallData callData;
CallType callType = JSC::getCallData(function, callData);
ASSERT(callType != CallType::None);
MarkedArgumentBuffer arguments;
arguments.append(moduleName);
arguments.append(parameters);
arguments.append(scriptFetcher);
ASSERT(!arguments.hasOverflowed());
scope.release();
return jsCast<JSInternalPromise*>(call(exec, function, callType, callData, this, arguments));
}
JSInternalPromise* JSModuleLoader::loadModule(ExecState* exec, JSValue moduleName, JSValue parameters, JSValue scriptFetcher)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSObject* function = jsCast<JSObject*>(get(exec, vm.propertyNames->builtinNames().loadModulePublicName()));
RETURN_IF_EXCEPTION(scope, nullptr);
CallData callData;
CallType callType = JSC::getCallData(function, callData);
ASSERT(callType != CallType::None);
MarkedArgumentBuffer arguments;
arguments.append(moduleName);
arguments.append(parameters);
arguments.append(scriptFetcher);
ASSERT(!arguments.hasOverflowed());
scope.release();
return jsCast<JSInternalPromise*>(call(exec, function, callType, callData, this, arguments));
}
JSValue JSModuleLoader::linkAndEvaluateModule(ExecState* exec, JSValue moduleKey, JSValue scriptFetcher)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSObject* function = jsCast<JSObject*>(get(exec, vm.propertyNames->builtinNames().linkAndEvaluateModulePublicName()));
RETURN_IF_EXCEPTION(scope, { });
CallData callData;
CallType callType = JSC::getCallData(function, callData);
ASSERT(callType != CallType::None);
MarkedArgumentBuffer arguments;
arguments.append(moduleKey);
arguments.append(scriptFetcher);
ASSERT(!arguments.hasOverflowed());
scope.release();
return call(exec, function, callType, callData, this, arguments);
}
JSInternalPromise* JSModuleLoader::requestImportModule(ExecState* exec, const Identifier& moduleKey, JSValue parameters, JSValue scriptFetcher)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
auto* function = jsCast<JSObject*>(get(exec, vm.propertyNames->builtinNames().requestImportModulePublicName()));
RETURN_IF_EXCEPTION(scope, nullptr);
CallData callData;
auto callType = JSC::getCallData(function, callData);
ASSERT(callType != CallType::None);
MarkedArgumentBuffer arguments;
arguments.append(jsString(exec, moduleKey.impl()));
arguments.append(parameters);
arguments.append(scriptFetcher);
ASSERT(!arguments.hasOverflowed());
scope.release();
return jsCast<JSInternalPromise*>(call(exec, function, callType, callData, this, arguments));
}
JSInternalPromise* JSModuleLoader::importModule(ExecState* exec, JSString* moduleName, JSValue parameters, const SourceOrigin& referrer)
{
if (Options::dumpModuleLoadingState())
dataLog("Loader [import] ", printableModuleKey(exec, moduleName), "\n");
auto* globalObject = exec->lexicalGlobalObject();
VM& vm = globalObject->vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
if (globalObject->globalObjectMethodTable()->moduleLoaderImportModule)
return globalObject->globalObjectMethodTable()->moduleLoaderImportModule(globalObject, exec, this, moduleName, parameters, referrer);
auto* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
auto moduleNameString = moduleName->value(exec);
if (UNLIKELY(scope.exception())) {
JSValue exception = scope.exception()->value();
scope.clearException();
deferred->reject(exec, exception);
return deferred->promise();
}
deferred->reject(exec, createError(exec, makeString("Could not import the module '", moduleNameString, "'.")));
return deferred->promise();
}
Identifier JSModuleLoader::resolveSync(ExecState* exec, JSValue name, JSValue referrer, JSValue scriptFetcher)
{
if (Options::dumpModuleLoadingState())
dataLog("Loader [resolve] ", printableModuleKey(exec, name), "\n");
JSGlobalObject* globalObject = exec->lexicalGlobalObject();
if (globalObject->globalObjectMethodTable()->moduleLoaderResolve)
return globalObject->globalObjectMethodTable()->moduleLoaderResolve(globalObject, exec, this, name, referrer, scriptFetcher);
return name.toPropertyKey(exec);
}
JSInternalPromise* JSModuleLoader::resolve(ExecState* exec, JSValue name, JSValue referrer, JSValue scriptFetcher)
{
VM& vm = exec->vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, exec->lexicalGlobalObject());
scope.releaseAssertNoException();
const Identifier moduleKey = resolveSync(exec, name, referrer, scriptFetcher);
if (UNLIKELY(scope.exception())) {
JSValue exception = scope.exception();
scope.clearException();
return deferred->reject(exec, exception);
}
auto result = deferred->resolve(exec, identifierToJSValue(vm, moduleKey));
scope.releaseAssertNoException();
return result;
}
JSInternalPromise* JSModuleLoader::fetch(ExecState* exec, JSValue key, JSValue parameters, JSValue scriptFetcher)
{
if (Options::dumpModuleLoadingState())
dataLog("Loader [fetch] ", printableModuleKey(exec, key), "\n");
JSGlobalObject* globalObject = exec->lexicalGlobalObject();
VM& vm = globalObject->vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
if (globalObject->globalObjectMethodTable()->moduleLoaderFetch)
return globalObject->globalObjectMethodTable()->moduleLoaderFetch(globalObject, exec, this, key, parameters, scriptFetcher);
JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
String moduleKey = key.toWTFString(exec);
if (UNLIKELY(scope.exception())) {
JSValue exception = scope.exception()->value();
scope.clearException();
deferred->reject(exec, exception);
return deferred->promise();
}
deferred->reject(exec, createError(exec, makeString("Could not open the module '", moduleKey, "'.")));
return deferred->promise();
}
JSObject* JSModuleLoader::createImportMetaProperties(ExecState* exec, JSValue key, JSModuleRecord* moduleRecord, JSValue scriptFetcher)
{
JSGlobalObject* globalObject = exec->lexicalGlobalObject();
if (globalObject->globalObjectMethodTable()->moduleLoaderCreateImportMetaProperties)
return globalObject->globalObjectMethodTable()->moduleLoaderCreateImportMetaProperties(globalObject, exec, this, key, moduleRecord, scriptFetcher);
return constructEmptyObject(exec, exec->lexicalGlobalObject()->nullPrototypeObjectStructure());
}
JSValue JSModuleLoader::evaluate(ExecState* exec, JSValue key, JSValue moduleRecordValue, JSValue scriptFetcher)
{
if (Options::dumpModuleLoadingState())
dataLog("Loader [evaluate] ", printableModuleKey(exec, key), "\n");
JSGlobalObject* globalObject = exec->lexicalGlobalObject();
if (globalObject->globalObjectMethodTable()->moduleLoaderEvaluate)
return globalObject->globalObjectMethodTable()->moduleLoaderEvaluate(globalObject, exec, this, key, moduleRecordValue, scriptFetcher);
JSModuleRecord* moduleRecord = jsDynamicCast<JSModuleRecord*>(exec->vm(), moduleRecordValue);
if (!moduleRecord)
return jsUndefined();
return moduleRecord->evaluate(exec);
}
JSModuleNamespaceObject* JSModuleLoader::getModuleNamespaceObject(ExecState* exec, JSValue moduleRecordValue)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
auto* moduleRecord = jsDynamicCast<AbstractModuleRecord*>(vm, moduleRecordValue);
if (!moduleRecord) {
throwTypeError(exec, scope);
return nullptr;
}
scope.release();
return moduleRecord->getModuleNamespace(exec);
}
}