ModuleLoaderPrototype.cpp [plain text]
#include "config.h"
#include "ModuleLoaderPrototype.h"
#include "BuiltinNames.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 "JSModuleLoader.h"
#include "JSModuleNamespaceObject.h"
#include "JSModuleRecord.h"
#include "JSSourceCode.h"
#include "ModuleAnalyzer.h"
#include "Nodes.h"
#include "Parser.h"
#include "ParserError.h"
namespace JSC {
static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeParseModule(ExecState*);
static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeRequestedModules(ExecState*);
static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeEvaluate(ExecState*);
static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeModuleDeclarationInstantiation(ExecState*);
static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeResolve(ExecState*);
static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeFetch(ExecState*);
static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeInstantiate(ExecState*);
static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeGetModuleNamespaceObject(ExecState*);
}
#include "ModuleLoaderPrototype.lut.h"
namespace JSC {
STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(ModuleLoaderPrototype);
const ClassInfo ModuleLoaderPrototype::s_info = { "ModuleLoader", &Base::s_info, &moduleLoaderPrototypeTable, nullptr, CREATE_METHOD_TABLE(ModuleLoaderPrototype) };
ModuleLoaderPrototype::ModuleLoaderPrototype(VM& vm, Structure* structure)
: JSNonFinalObject(vm, structure)
{
}
EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeParseModule(ExecState* exec)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
const Identifier moduleKey = exec->argument(0).toPropertyKey(exec);
RETURN_IF_EXCEPTION(scope, encodedJSValue());
auto* jsSourceCode = jsDynamicCast<JSSourceCode*>(vm, exec->argument(1));
if (!jsSourceCode)
return throwVMTypeError(exec, scope);
SourceCode sourceCode = jsSourceCode->sourceCode();
CodeProfiling profile(sourceCode);
ParserError error;
std::unique_ptr<ModuleProgramNode> moduleProgramNode = parse<ModuleProgramNode>(
&vm, sourceCode, Identifier(), JSParserBuiltinMode::NotBuiltin,
JSParserStrictMode::Strict, JSParserScriptMode::Module, SourceParseMode::ModuleAnalyzeMode, SuperBinding::NotNeeded, error);
if (error.isValid()) {
throwVMError(exec, scope, error.toErrorObject(exec->lexicalGlobalObject(), sourceCode));
return JSValue::encode(jsUndefined());
}
ASSERT(moduleProgramNode);
ModuleAnalyzer moduleAnalyzer(exec, moduleKey, sourceCode, moduleProgramNode->varDeclarations(), moduleProgramNode->lexicalVariables());
RETURN_IF_EXCEPTION(scope, encodedJSValue());
JSModuleRecord* moduleRecord = moduleAnalyzer.analyze(*moduleProgramNode);
return JSValue::encode(moduleRecord);
}
EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeRequestedModules(ExecState* exec)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSModuleRecord* moduleRecord = jsDynamicCast<JSModuleRecord*>(vm, exec->argument(0));
if (!moduleRecord) {
scope.release();
return JSValue::encode(constructEmptyArray(exec, nullptr));
}
JSArray* result = constructEmptyArray(exec, nullptr, moduleRecord->requestedModules().size());
RETURN_IF_EXCEPTION(scope, encodedJSValue());
size_t i = 0;
for (auto& key : moduleRecord->requestedModules()) {
result->putDirectIndex(exec, i++, jsString(exec, key.get()));
RETURN_IF_EXCEPTION(scope, encodedJSValue());
}
return JSValue::encode(result);
}
EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeModuleDeclarationInstantiation(ExecState* exec)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSModuleRecord* moduleRecord = jsDynamicCast<JSModuleRecord*>(vm, exec->argument(0));
if (!moduleRecord)
return JSValue::encode(jsUndefined());
if (Options::dumpModuleLoadingState())
dataLog("Loader [link] ", moduleRecord->moduleKey(), "\n");
moduleRecord->link(exec);
RETURN_IF_EXCEPTION(scope, encodedJSValue());
return JSValue::encode(jsUndefined());
}
EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeResolve(ExecState* exec)
{
VM& vm = exec->vm();
JSModuleLoader* loader = jsDynamicCast<JSModuleLoader*>(vm, exec->thisValue());
if (!loader)
return JSValue::encode(jsUndefined());
return JSValue::encode(loader->resolve(exec, exec->argument(0), exec->argument(1), exec->argument(2)));
}
EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeFetch(ExecState* exec)
{
VM& vm = exec->vm();
JSModuleLoader* loader = jsDynamicCast<JSModuleLoader*>(vm, exec->thisValue());
if (!loader)
return JSValue::encode(jsUndefined());
return JSValue::encode(loader->fetch(exec, exec->argument(0), exec->argument(1)));
}
EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeInstantiate(ExecState* exec)
{
VM& vm = exec->vm();
JSModuleLoader* loader = jsDynamicCast<JSModuleLoader*>(vm, exec->thisValue());
if (!loader)
return JSValue::encode(jsUndefined());
return JSValue::encode(loader->instantiate(exec, exec->argument(0), exec->argument(1), exec->argument(2)));
}
EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeGetModuleNamespaceObject(ExecState* exec)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
auto* loader = jsDynamicCast<JSModuleLoader*>(vm, exec->thisValue());
if (!loader)
return JSValue::encode(jsUndefined());
auto* moduleNamespaceObject = loader->getModuleNamespaceObject(exec, exec->argument(0));
RETURN_IF_EXCEPTION(scope, encodedJSValue());
return JSValue::encode(moduleNamespaceObject);
}
EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeEvaluate(ExecState* exec)
{
VM& vm = exec->vm();
JSModuleLoader* loader = jsDynamicCast<JSModuleLoader*>(vm, exec->thisValue());
if (!loader)
return JSValue::encode(jsUndefined());
return JSValue::encode(loader->evaluate(exec, exec->argument(0), exec->argument(1), exec->argument(2)));
}
}