Attachment #297771 for bug #165724

View Details Raw Unified Return to Bug 165724

| Differences between



2016-12-26  Yusuke Suzuki  <utatane.tea@gmail.com>

        [JSC] Prototype dynamic-import
        https://bugs.webkit.org/show_bug.cgi?id=165724

        Reviewed by NOBODY (OOPS!).

        * builtins/ModuleLoaderPrototype.js:
        (importModule):
        * bytecompiler/BytecodeGenerator.cpp:
        (JSC::BytecodeGenerator::emitGetTemplateObject):
        (JSC::BytecodeGenerator::emitGetGlobalPrivate):
        * bytecompiler/BytecodeGenerator.h:
        * bytecompiler/NodesCodegen.cpp:
        (JSC::ImportNode::emitBytecode):
        * jsc.cpp:
        (GlobalObject::moduleLoaderImportModule):
        * parser/ASTBuilder.h:
        (JSC::ASTBuilder::createImportExpr):
        * parser/NodeConstructors.h:
        (JSC::ImportNode::ImportNode):
        * parser/Nodes.h:
        (JSC::ExpressionNode::isImportNode):
        * parser/Parser.cpp:
        (JSC::Parser<LexerType>::parseMemberExpression):
        * parser/SyntaxChecker.h:
        (JSC::SyntaxChecker::createImportExpr):
        * runtime/JSGlobalObject.cpp:
        (JSC::JSGlobalObject::init):
        * runtime/JSGlobalObject.h:
        * runtime/JSGlobalObjectFunctions.cpp:
        (JSC::globalFuncImportModule):
        * runtime/JSGlobalObjectFunctions.h:
        * runtime/JSModuleLoader.cpp:
        (JSC::JSModuleLoader::importModule):
        (JSC::JSModuleLoader::getModuleNamespaceObject):
        * runtime/JSModuleLoader.h:
        * runtime/ModuleLoaderPrototype.cpp:
        (JSC::moduleLoaderPrototypeGetModuleNamespaceObject):

2016-12-25  Yusuke Suzuki  <utatane.tea@gmail.com>

        Propagate the source origin as much as possible



2016-12-26  Yusuke Suzuki  <utatane.tea@gmail.com>

        [JSC] Prototype dynamic-import
        https://bugs.webkit.org/show_bug.cgi?id=165724

        Reviewed by NOBODY (OOPS!).

        * bindings/js/JSDOMWindowBase.cpp:
        * bindings/js/JSWorkerGlobalScopeBase.cpp:

2016-12-25  Chris Fleizach  <cfleizach@apple.com>

        AX: Headers of table not read by VoiceOver



    this.link(entry, initiator);
    return this.moduleEvaluation(entry.module, initiator);
}

function importModule(moduleName, referrer, initiator)
{
    "use strict";

    // Loader.resolve hook point.
    // resolve: moduleName => Promise(moduleKey)
    // Take the name and resolve it to the unique identifier for the resource location.
    // For example, take the "jquery" and return the URL for the resource.
    return this.resolve(moduleName, referrer, initiator).then((key) => {
        return this.requestInstantiateAll(key, initiator);
    }).then((entry) => {
        this.linkAndEvaluateModule(entry.key, initiator);
        return this.getModuleNamespaceObject(entry.module);
    });
}



        cookedStrings.append(templateString->value()->cooked().impl());
    }

    RefPtr<RegisterID> getTemplateObject = emitGetGlobalPrivate(newTemporary(), propertyNames().builtinNames().getTemplateObjectPrivateName());
    Variable var = variable(propertyNames().builtinNames().getTemplateObjectPrivateName());
    if (RegisterID* local = var.local())
        getTemplateObject = emitMove(newTemporary(), local);
    else {
        getTemplateObject = newTemporary();
        RefPtr<RegisterID> scope = newTemporary();
        moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), var));
        emitGetFromScope(getTemplateObject.get(), scope.get(), var, ThrowIfNotFound);
    }

    CallArguments arguments(*this, nullptr);
    emitLoad(arguments.thisRegister(), JSValue(addTemplateRegistryKeyConstant(m_vm->templateRegistryKeyTable().createKey(rawStrings, cookedStrings))));
    return emitCall(dst, getTemplateObject.get(), NoExpectedFunction, arguments, taggedTemplate->divot(), taggedTemplate->divotStart(), taggedTemplate->divotEnd(), DebuggableCall::No);
}

RegisterID* BytecodeGenerator::emitGetGlobalPrivate(RegisterID* dst, const Identifier& property)
{
    dst = tempDestination(dst);
    Variable var = variable(property);
    if (RegisterID* local = var.local())
        return emitMove(dst, local);

    RefPtr<RegisterID> scope = newTemporary();
    moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), var));
    return emitGetFromScope(dst, scope.get(), var, ThrowIfNotFound);
}

RegisterID* BytecodeGenerator::emitGetEnumerableLength(RegisterID* dst, RegisterID* base)
{
    emitOpcode(op_get_enumerable_length);

Lines 678-683 namespace JSC { a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h_sec1
- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h +1 lines
678	void emitEnumeration(ThrowableExpressionData* enumerationNode, ExpressionNode* subjectNode, const std::function<void(BytecodeGenerator&, RegisterID)>& callBack, ForOfNode = nullptr, RegisterID* forLoopSymbolTable = nullptr);	678	void emitEnumeration(ThrowableExpressionData* enumerationNode, ExpressionNode* subjectNode, const std::function<void(BytecodeGenerator&, RegisterID)>& callBack, ForOfNode = nullptr, RegisterID* forLoopSymbolTable = nullptr);
679		679
680	RegisterID* emitGetTemplateObject(RegisterID* dst, TaggedTemplateNode*);	680	RegisterID* emitGetTemplateObject(RegisterID* dst, TaggedTemplateNode*);
		681	RegisterID* emitGetGlobalPrivate(RegisterID* dst, const Identifier& property);
681		682
682	enum class ReturnFrom { Normal, Finally };	683	enum class ReturnFrom { Normal, Finally };
683	RegisterID* emitReturn(RegisterID* src, ReturnFrom = ReturnFrom::Normal);	684	RegisterID* emitReturn(RegisterID* src, ReturnFrom = ReturnFrom::Normal);



    return generator.moveToDestinationIfNeeded(generator.finalDestination(dst), result);
}

// ------------------------------ ImportNode -------------------------------------

RegisterID* ImportNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
    RefPtr<RegisterID> importModule = generator.emitGetGlobalPrivate(generator.newTemporary(), generator.propertyNames().builtinNames().importModulePrivateName());
    CallArguments arguments(generator, nullptr, 1);
    generator.emitLoad(arguments.thisRegister(), jsUndefined());
    generator.emitNode(arguments.argumentRegister(0), m_expr);
    return generator.emitCall(generator.finalDestination(dst, importModule.get()), importModule.get(), NoExpectedFunction, arguments, divot(), divotStart(), divotEnd(), DebuggableCall::No);
}

// ------------------------------ NewTargetNode ----------------------------------

RegisterID* NewTargetNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)



#include "ArrayBuffer.h"
#include "ArrayPrototype.h"
#include "BuiltinExecutableCreator.h"
#include "BuiltinNames.h"
#include "ButterflyInlines.h"
#include "CodeBlock.h"
#include "Completion.h"

#include "JSInternalPromise.h"
#include "JSInternalPromiseDeferred.h"
#include "JSLock.h"
#include "JSModuleLoader.h"
#include "JSNativeStdFunction.h"
#include "JSONObject.h"
#include "JSProxy.h"

        putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function, NoIntrinsic, function));
    }

    static JSInternalPromise* moduleLoaderImportModule(JSGlobalObject*, ExecState*, JSModuleLoader*, JSString*, const SourceOrigin&);
    static JSInternalPromise* moduleLoaderResolve(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
    static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue);
};

    &javaScriptRuntimeFlags,
    nullptr,
    &shouldInterruptScriptBeforeTimeout,
    &moduleLoaderImportModule,
    &moduleLoaderResolve,
    &moduleLoaderFetch,
    nullptr,

    return builder.toString();
}

JSInternalPromise* GlobalObject::moduleLoaderImportModule(JSGlobalObject*, ExecState* exec, JSModuleLoader* moduleLoader, JSString* moduleName, const SourceOrigin& sourceOrigin)
{
    auto* function = jsCast<JSObject*>(moduleLoader->get(exec, exec->propertyNames().builtinNames().importModulePublicName()));
    CallData callData;
    CallType callType = JSC::getCallData(function, callData);
    ASSERT(callType != CallType::None);

    MarkedArgumentBuffer arguments;
    arguments.append(moduleName);
    arguments.append(jsString(exec, sourceOrigin.string()));
    arguments.append(jsUndefined());

    return jsCast<JSInternalPromise*>(call(exec, function, callType, callData, moduleLoader, arguments));
}

JSInternalPromise* GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue)
{
    VM& vm = globalObject->vm();

Lines 178-183 class ASTBuilder { a/Source/JavaScriptCore/parser/ASTBuilder.h_sec1
- a/Source/JavaScriptCore/parser/ASTBuilder.h +6 lines
178	{	178	{
179	return new (m_parserArena) SuperNode(location);	179	return new (m_parserArena) SuperNode(location);
180	}	180	}
		181	ExpressionNode* createImportExpr(const JSTokenLocation& location, ExpressionNode* expr, const JSTextPosition& start, const JSTextPosition& divot, const JSTextPosition& end)
		182	{
		183	auto* node = new (m_parserArena) ImportNode(location, expr);
		184	setExceptionLocation(node, start, divot, end);
		185	return node;
		186	}
181	ExpressionNode* createNewTargetExpr(const JSTokenLocation location)	187	ExpressionNode* createNewTargetExpr(const JSTokenLocation location)
182	{	188	{
183	usesNewTarget();	189	usesNewTarget();

Lines 167-172 namespace JSC { a/Source/JavaScriptCore/parser/NodeConstructors.h_sec1
- a/Source/JavaScriptCore/parser/NodeConstructors.h +6 lines
167	{	167	{
168	}	168	}
169		169
		170	inline ImportNode::ImportNode(const JSTokenLocation& location, ExpressionNode* expr)
		171	: ExpressionNode(location)
		172	, m_expr(expr)
		173	{
		174	}
		175
170	inline NewTargetNode::NewTargetNode(const JSTokenLocation& location)	176	inline NewTargetNode::NewTargetNode(const JSTokenLocation& location)
171	: ExpressionNode(location)	177	: ExpressionNode(location)
172	{	178	{



        virtual bool isBoolean() const { return false; }
        virtual bool isSpreadExpression() const { return false; }
        virtual bool isSuperNode() const { return false; }
        virtual bool isImportNode() const { return false; }
        virtual bool isNewTarget() const { return false; }
        virtual bool isBytecodeIntrinsicNode() const { return false; }


        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
    };

    class ImportNode : public ExpressionNode, public ThrowableExpressionData {
    public:
        ImportNode(const JSTokenLocation&, ExpressionNode*);

    private:
        bool isImportNode() const override { return true; }
        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

        ExpressionNode* m_expr;
    };

    class NewTargetNode final : public ExpressionNode {
    public:
        NewTargetNode(const JSTokenLocation&);

Lines 4427-4433 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres a/Source/JavaScriptCore/parser/Parser.cpp_sec1
- a/Source/JavaScriptCore/parser/Parser.cpp -1 / +9 lines
4427	}	4427	}
4428		4428
4429	bool baseIsSuper = match(SUPER);	4429	bool baseIsSuper = match(SUPER);
4430	semanticFailIfTrue(baseIsSuper && newCount, "Cannot use new with super");	4430	bool baseIsImport = match(IMPORT);
		4431	semanticFailIfTrue((baseIsSuper \|\| baseIsImport) && newCount, "Cannot use new with ", getToken());
4431		4432
4432	bool baseIsNewTarget = false;	4433	bool baseIsNewTarget = false;
4433	if (newCount && match(DOT)) {	4434	if (newCount && match(DOT)) {
Lines 4467-4472 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres a/Source/JavaScriptCore/parser/Parser.cpp_sec2
4467	semanticFailIfTrue(functionSuperBinding == SuperBinding::NotNeeded, "super is not valid in this context");	4468	semanticFailIfTrue(functionSuperBinding == SuperBinding::NotNeeded, "super is not valid in this context");
4468	}	4469	}
4469	}	4470	}
		4471	} else if (baseIsImport) {
		4472	JSTextPosition expressionEnd = lastTokenEndPosition();
		4473	next();
		4474	handleProductionOrFail2(OPENPAREN, "(", "start", "'import' call");
		4475	TreeExpression expr = parseAssignmentExpression(context);
		4476	handleProductionOrFail2(CLOSEPAREN, ")", "end", "'import' call");
		4477	return context.createImportExpr(location, expr, expressionStart, expressionEnd, lastTokenEndPosition());
4470	} else if (!baseIsNewTarget) {	4478	} else if (!baseIsNewTarget) {
4471	const bool isAsync = match(ASYNC);	4479	const bool isAsync = match(ASYNC);
4472		4480



    enum { NoneExpr = 0,
        ResolveEvalExpr, ResolveExpr, IntegerExpr, DoubleExpr, StringExpr,
        ThisExpr, NullExpr, BoolExpr, RegExpExpr, ObjectLiteralExpr,
        FunctionExpr, ClassExpr, SuperExpr, ImportExpr, BracketExpr, DotExpr, CallExpr,
        NewExpr, PreExpr, PostExpr, UnaryExpr, BinaryExpr,
        ConditionalExpr, AssignmentExpr, TypeofExpr, NewTargetExpr,
        DeleteExpr, ArrayLiteralExpr, BindingDestructuring, RestParameter,

    ExpressionType createLogicalNot(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    ExpressionType createUnaryPlus(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    ExpressionType createVoid(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    ExpressionType createImportExpr(const JSTokenLocation&, ExpressionType, int, int, int) { return ImportExpr; }
    ExpressionType createThisExpr(const JSTokenLocation&) { return ThisExpr; }
    ExpressionType createSuperExpr(const JSTokenLocation&) { return SuperExpr; }
    ExpressionType createNewTargetExpr(const JSTokenLocation&) { return NewTargetExpr; }



    nullptr,
    nullptr,
    nullptr,
    nullptr,
    nullptr
};


    JSFunction* privateFuncTrunc = JSFunction::create(vm, this, 0, String(), mathProtoFuncTrunc, TruncIntrinsic);

    JSFunction* privateFuncGetTemplateObject = JSFunction::create(vm, this, 0, String(), getTemplateObject);
    JSFunction* privateFuncImportModule = JSFunction::create(vm, this, 0, String(), globalFuncImportModule);
    JSFunction* privateFuncTypedArrayLength = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncLength);
    JSFunction* privateFuncTypedArrayGetOriginalConstructor = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncGetOriginalConstructor);
    JSFunction* privateFuncTypedArraySort = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncSort);

        GlobalPropertyInfo(vm.propertyNames->undefinedKeyword, jsUndefined(), DontEnum | DontDelete | ReadOnly),
        GlobalPropertyInfo(vm.propertyNames->builtinNames().ownEnumerablePropertyKeysPrivateName(), JSFunction::create(vm, this, 0, String(), ownEnumerablePropertyKeys), DontEnum | DontDelete | ReadOnly),
        GlobalPropertyInfo(vm.propertyNames->builtinNames().getTemplateObjectPrivateName(), privateFuncGetTemplateObject, DontEnum | DontDelete | ReadOnly),
        GlobalPropertyInfo(vm.propertyNames->builtinNames().importModulePrivateName(), privateFuncImportModule, DontEnum | DontDelete | ReadOnly),
        GlobalPropertyInfo(vm.propertyNames->builtinNames().enqueueJobPrivateName(), JSFunction::create(vm, this, 0, String(), enqueueJob), DontEnum | DontDelete | ReadOnly),
        GlobalPropertyInfo(vm.propertyNames->builtinNames().ErrorPrivateName(), m_errorConstructor.get(), DontEnum | DontDelete | ReadOnly),
        GlobalPropertyInfo(vm.propertyNames->builtinNames().RangeErrorPrivateName(), m_rangeErrorConstructor.get(), DontEnum | DontDelete | ReadOnly),

Lines 184-189 struct GlobalObjectMethodTable { a/Source/JavaScriptCore/runtime/JSGlobalObject.h_sec1
- a/Source/JavaScriptCore/runtime/JSGlobalObject.h +3 lines
184	typedef bool (ShouldInterruptScriptBeforeTimeoutPtr)(const JSGlobalObject);	184	typedef bool (ShouldInterruptScriptBeforeTimeoutPtr)(const JSGlobalObject);
185	ShouldInterruptScriptBeforeTimeoutPtr shouldInterruptScriptBeforeTimeout;	185	ShouldInterruptScriptBeforeTimeoutPtr shouldInterruptScriptBeforeTimeout;
186		186
		187	typedef JSInternalPromise* (ModuleLoaderImportModulePtr)(JSGlobalObject, ExecState, JSModuleLoader, JSString*, const SourceOrigin&);
		188	ModuleLoaderImportModulePtr moduleLoaderImportModule;
		189
187	typedef JSInternalPromise* (ModuleLoaderResolvePtr)(JSGlobalObject, ExecState, JSModuleLoader, JSValue, JSValue, JSValue);	190	typedef JSInternalPromise* (ModuleLoaderResolvePtr)(JSGlobalObject, ExecState, JSModuleLoader, JSValue, JSValue, JSValue);
188	ModuleLoaderResolvePtr moduleLoaderResolve;	191	ModuleLoaderResolvePtr moduleLoaderResolve;
189		192

Lines 27-36 a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp +38 lines
27		27
28	#include "CallFrame.h"	28	#include "CallFrame.h"
29	#include "EvalExecutable.h"	29	#include "EvalExecutable.h"
		30	#include "Exception.h"
30	#include "IndirectEvalExecutable.h"	31	#include "IndirectEvalExecutable.h"
31	#include "Interpreter.h"	32	#include "Interpreter.h"
32	#include "JSFunction.h"	33	#include "JSFunction.h"
33	#include "JSGlobalObject.h"	34	#include "JSGlobalObject.h"
		35	#include "JSInternalPromise.h"
		36	#include "JSModuleLoader.h"
		37	#include "JSPromiseDeferred.h"
34	#include "JSString.h"	38	#include "JSString.h"
35	#include "JSStringBuilder.h"	39	#include "JSStringBuilder.h"
36	#include "Lexer.h"	40	#include "Lexer.h"
Lines 925-928 EncodedJSValue JSC_HOST_CALL globalFuncBuiltinLog(ExecState* exec) a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp_sec2
925	return JSValue::encode(jsUndefined());	929	return JSValue::encode(jsUndefined());
926	}	930	}
927		931
		932	EncodedJSValue JSC_HOST_CALL globalFuncImportModule(ExecState* exec)
		933	{
		934	VM& vm = exec->vm();
		935	auto catchScope = DECLARE_CATCH_SCOPE(vm);
		936
		937	auto* globalObject = exec->lexicalGlobalObject();
		938
		939	auto* promise = JSPromiseDeferred::create(exec, globalObject);
		940	RETURN_IF_EXCEPTION(catchScope, encodedJSValue());
		941
		942	auto sourceOrigin = exec->callerSourceOrigin();
		943	if (sourceOrigin.isNull()) {
		944	promise->reject(exec, createError(exec, ASCIILiteral("Could not resolve the module specifier.")));
		945	return JSValue::encode(promise->promise());
		946	}
		947
		948	auto* specifier = exec->argument(0).toString(exec);
		949	if (Exception* exception = catchScope.exception()) {
		950	catchScope.clearException();
		951	promise->reject(exec, exception);
		952	return JSValue::encode(promise->promise());
		953	}
		954
		955	auto* internalPromise = globalObject->moduleLoader()->importModule(exec, specifier, sourceOrigin);
		956	if (Exception* exception = catchScope.exception()) {
		957	catchScope.clearException();
		958	promise->reject(exec, exception);
		959	return JSValue::encode(promise->promise());
		960	}
		961	promise->resolve(exec, internalPromise);
		962
		963	return JSValue::encode(promise->promise());
		964	}
		965
928	} // namespace JSC	966	} // namespace JSC

Lines 50-55 EncodedJSValue JSC_HOST_CALL globalFuncThrowTypeErrorArgumentsCalleeAndCaller(Ex a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.h_sec1
- a/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.h +1 lines
50	EncodedJSValue JSC_HOST_CALL globalFuncProtoGetter(ExecState*);	50	EncodedJSValue JSC_HOST_CALL globalFuncProtoGetter(ExecState*);
51	EncodedJSValue JSC_HOST_CALL globalFuncProtoSetter(ExecState*);	51	EncodedJSValue JSC_HOST_CALL globalFuncProtoSetter(ExecState*);
52	EncodedJSValue JSC_HOST_CALL globalFuncBuiltinLog(ExecState*);	52	EncodedJSValue JSC_HOST_CALL globalFuncBuiltinLog(ExecState*);
		53	EncodedJSValue JSC_HOST_CALL globalFuncImportModule(ExecState*);
53		54
54	static const double mantissaOverflowLowerBound = 9007199254740992.0;	55	static const double mantissaOverflowLowerBound = 9007199254740992.0;
55	double parseIntOverflow(const LChar*, unsigned length, int radix);	56	double parseIntOverflow(const LChar*, unsigned length, int radix);



    return call(exec, function, callType, callData, this, arguments);
}

JSInternalPromise* JSModuleLoader::importModule(ExecState* exec, JSString* moduleName, const SourceOrigin& referrer)
{
    if (Options::dumpModuleLoadingState())
        dataLog("Loader [import] ", printableModuleKey(exec, moduleName), "\n");

    JSGlobalObject* 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, referrer);

    JSInternalPromiseDeferred* 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();
}

JSInternalPromise* JSModuleLoader::resolve(ExecState* exec, JSValue name, JSValue referrer, JSValue initiator)
{
    if (Options::dumpModuleLoadingState())

    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*>(moduleRecordValue);
    if (!moduleRecord) {
        throwTypeError(exec, scope);
        return nullptr;
    }

    scope.release();
    return moduleRecord->getModuleNamespace(exec);
}

} // namespace JSC

Lines 31-36 a/Source/JavaScriptCore/runtime/JSModuleLoader.h_sec1
- a/Source/JavaScriptCore/runtime/JSModuleLoader.h +5 lines
31	namespace JSC {	31	namespace JSC {
32		32
33	class JSInternalPromise;	33	class JSInternalPromise;
		34	class JSModuleNamespaceObject;
34		35
35	class JSModuleLoader : public JSNonFinalObject {	36	class JSModuleLoader : public JSNonFinalObject {
36	private:	37	private:
Lines 67-72 class JSModuleLoader : public JSNonFinalObject { a/Source/JavaScriptCore/runtime/JSModuleLoader.h_sec2
67	JSValue linkAndEvaluateModule(ExecState*, JSValue moduleKey, JSValue initiator);	68	JSValue linkAndEvaluateModule(ExecState*, JSValue moduleKey, JSValue initiator);
68		69
69	// Platform dependent hooked APIs.	70	// Platform dependent hooked APIs.
		71	JSInternalPromise* importModule(ExecState, JSString moduleName, const SourceOrigin& referrer);
70	JSInternalPromise* resolve(ExecState*, JSValue name, JSValue referrer, JSValue initiator);	72	JSInternalPromise* resolve(ExecState*, JSValue name, JSValue referrer, JSValue initiator);
71	JSInternalPromise* fetch(ExecState*, JSValue key, JSValue initiator);	73	JSInternalPromise* fetch(ExecState*, JSValue key, JSValue initiator);
72	JSInternalPromise* instantiate(ExecState*, JSValue key, JSValue source, JSValue initiator);	74	JSInternalPromise* instantiate(ExecState*, JSValue key, JSValue source, JSValue initiator);
Lines 74-79 class JSModuleLoader : public JSNonFinalObject { a/Source/JavaScriptCore/runtime/JSModuleLoader.h_sec3
74	// Additional platform dependent hooked APIs.	76	// Additional platform dependent hooked APIs.
75	JSValue evaluate(ExecState*, JSValue key, JSValue moduleRecord, JSValue initiator);	77	JSValue evaluate(ExecState*, JSValue key, JSValue moduleRecord, JSValue initiator);
76		78
		79	// Utility functions.
		80	JSModuleNamespaceObject* getModuleNamespaceObject(ExecState*, JSValue moduleRecord);
		81
77	protected:	82	protected:
78	void finishCreation(ExecState, VM&, JSGlobalObject);	83	void finishCreation(ExecState, VM&, JSGlobalObject);
79	};	84	};

Lines 37-42 a/Source/JavaScriptCore/runtime/ModuleLoaderPrototype.cpp_sec1
- a/Source/JavaScriptCore/runtime/ModuleLoaderPrototype.cpp +17 lines
37	#include "JSMap.h"	37	#include "JSMap.h"
38	#include "JSModuleEnvironment.h"	38	#include "JSModuleEnvironment.h"
39	#include "JSModuleLoader.h"	39	#include "JSModuleLoader.h"
		40	#include "JSModuleNamespaceObject.h"
40	#include "JSModuleRecord.h"	41	#include "JSModuleRecord.h"
41	#include "ModuleAnalyzer.h"	42	#include "ModuleAnalyzer.h"
42	#include "Nodes.h"	43	#include "Nodes.h"
Lines 52-57 static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeModuleDeclarationInstan a/Source/JavaScriptCore/runtime/ModuleLoaderPrototype.cpp_sec2
52	static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeResolve(ExecState*);	53	static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeResolve(ExecState*);
53	static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeFetch(ExecState*);	54	static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeFetch(ExecState*);
54	static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeInstantiate(ExecState*);	55	static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeInstantiate(ExecState*);
		56	static EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeGetModuleNamespaceObject(ExecState*);
55		57
56	}	58	}
57		59
Lines 85-90 const ClassInfo ModuleLoaderPrototype::s_info = { "ModuleLoader", &Base::s_info, a/Source/JavaScriptCore/runtime/ModuleLoaderPrototype.cpp_sec3
85	loadAndEvaluateModule JSBuiltin DontEnum\|Function 3	87	loadAndEvaluateModule JSBuiltin DontEnum\|Function 3
86	loadModule JSBuiltin DontEnum\|Function 3	88	loadModule JSBuiltin DontEnum\|Function 3
87	linkAndEvaluateModule JSBuiltin DontEnum\|Function 2	89	linkAndEvaluateModule JSBuiltin DontEnum\|Function 2
		90	importModule JSBuiltin DontEnum\|Function 3
		91	getModuleNamespaceObject moduleLoaderPrototypeGetModuleNamespaceObject DontEnum\|Function 1
88	parseModule moduleLoaderPrototypeParseModule DontEnum\|Function 2	92	parseModule moduleLoaderPrototypeParseModule DontEnum\|Function 2
89	requestedModules moduleLoaderPrototypeRequestedModules DontEnum\|Function 1	93	requestedModules moduleLoaderPrototypeRequestedModules DontEnum\|Function 1
90	resolve moduleLoaderPrototypeResolve DontEnum\|Function 2	94	resolve moduleLoaderPrototypeResolve DontEnum\|Function 2
Lines 211-216 EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeInstantiate(ExecState* exec) a/Source/JavaScriptCore/runtime/ModuleLoaderPrototype.cpp_sec4
211	return JSValue::encode(loader->instantiate(exec, exec->argument(0), exec->argument(1), exec->argument(2)));	215	return JSValue::encode(loader->instantiate(exec, exec->argument(0), exec->argument(1), exec->argument(2)));
212	}	216	}
213		217
		218	EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeGetModuleNamespaceObject(ExecState* exec)
		219	{
		220	VM& vm = exec->vm();
		221	auto scope = DECLARE_THROW_SCOPE(vm);
		222
		223	JSModuleLoader* loader = jsDynamicCast<JSModuleLoader*>(exec->thisValue());
		224	if (!loader)
		225	return JSValue::encode(jsUndefined());
		226	auto* moduleNamespaceObject = loader->getModuleNamespaceObject(exec, exec->argument(0));
		227	RETURN_IF_EXCEPTION(scope, encodedJSValue());
		228	return JSValue::encode(moduleNamespaceObject);
		229	}
		230
214	// ------------------- Additional Hook Functions ---------------------------	231	// ------------------- Additional Hook Functions ---------------------------
215		232
216	EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeEvaluate(ExecState* exec)	233	EncodedJSValue JSC_HOST_CALL moduleLoaderPrototypeEvaluate(ExecState* exec)

Lines 64-69 const GlobalObjectMethodTable JSDOMWindowBase::s_globalObjectMethodTable = { a/Source/WebCore/bindings/js/JSDOMWindowBase.cpp_sec1
- a/Source/WebCore/bindings/js/JSDOMWindowBase.cpp +1 lines
64	&javaScriptRuntimeFlags,	64	&javaScriptRuntimeFlags,
65	&queueTaskToEventLoop,	65	&queueTaskToEventLoop,
66	&shouldInterruptScriptBeforeTimeout,	66	&shouldInterruptScriptBeforeTimeout,
		67	nullptr,
67	&moduleLoaderResolve,	68	&moduleLoaderResolve,
68	&moduleLoaderFetch,	69	&moduleLoaderFetch,
69	nullptr,	70	nullptr,

Lines 57-62 const GlobalObjectMethodTable JSWorkerGlobalScopeBase::s_globalObjectMethodTable a/Source/WebCore/bindings/js/JSWorkerGlobalScopeBase.cpp_sec1
- a/Source/WebCore/bindings/js/JSWorkerGlobalScopeBase.cpp +1 lines
57	nullptr,	57	nullptr,
58	nullptr,	58	nullptr,
59	nullptr,	59	nullptr,
		60	nullptr,
60	&defaultLanguage	61	&defaultLanguage
61	};	62	};
62		63



2016-12-26  Yusuke Suzuki  <utatane.tea@gmail.com>

        [JSC] Prototype dynamic-import
        https://bugs.webkit.org/show_bug.cgi?id=165724

        Reviewed by NOBODY (OOPS!).

        * sputnik/Conformance/07_Lexical_Conventions/7.5_Tokens/7.5.3_Future_Reserved_Words/S7.5.3_A1.16-expected.txt:

2016-12-25  Chris Fleizach  <cfleizach@apple.com>

        AX: Headers of table not read by VoiceOver

Lines 1-4 a/LayoutTests/sputnik/Conformance/07_Lexical_Conventions/7.5_Tokens/7.5.3_Future_Reserved_Words/S7.5.3_A1.16-expected.txt_sec1
- a/LayoutTests/sputnik/Conformance/07_Lexical_Conventions/7.5_Tokens/7.5.3_Future_Reserved_Words/S7.5.3_A1.16-expected.txt -1 / +1 lines
1	CONSOLE MESSAGE: line 76: SyntaxError: Unexpected keyword 'import'	1	CONSOLE MESSAGE: line 76: SyntaxError: Unexpected token '='. Expected '(' to start an 'import' call.
2	S7.5.3_A1.16	2	S7.5.3_A1.16
3		3
4	PASS Expected parsing failure	4	PASS Expected parsing failure



2016-12-26  Yusuke Suzuki  <utatane.tea@gmail.com>

        [JSC] Prototype dynamic-import
        https://bugs.webkit.org/show_bug.cgi?id=165724

        Reviewed by NOBODY (OOPS!).

        * stress/import-from-eval.js: Added.
        (async):
        * stress/import-syntax.js: Added.
        (testSyntaxError):
        * stress/import-tests/cocoa.js: Added.
        (export.Cocoa):
        (export.hello):
        * stress/import-tests/should.js: Added.
        (export.shouldBe):
        (export.shouldThrow):

2016-12-25  Yusuke Suzuki  <utatane.tea@gmail.com>

        Propagate the source origin as much as possible



(async function () {
    const { shouldBe, shouldThrow } = await import("./import-tests/should.js");

    {
        let cocoa = await eval(`import("./import-tests/cocoa.js")`);
        shouldBe(cocoa.hello(), 42);
    }

    {
        let cocoa = await (0, eval)(`import("./import-tests/cocoa.js")`);
        shouldBe(cocoa.hello(), 42);
    }

    {
        let cocoa = await eval(`eval('import("./import-tests/cocoa.js")')`);
        shouldBe(cocoa.hello(), 42);
    }

    {
        let cocoa = await ((new Function(`return eval('import("./import-tests/cocoa.js")')`))());
        shouldBe(cocoa.hello(), 42);
    }

    {
        let cocoa = await eval(`(new Function('return import("./import-tests/cocoa.js")'))()`);
        shouldBe(cocoa.hello(), 42);
    }

    {
        let cocoa = await [`import("./import-tests/cocoa.js")`].map(eval)[0];
        shouldBe(cocoa.hello(), 42);
    }
}());



function testSyntaxError(script, message) {
    var error = null;
    try {
        eval(script);
    } catch (e) {
        error = e;
    }
    if (!error)
        throw new Error("Expected syntax error not thrown");

    if (String(error) !== message)
        throw new Error(`Bad error: ${String(error)}`);
}

testSyntaxError(`import)`, `SyntaxError: Unexpected token ')'. Expected '(' to start an 'import' call.`);
testSyntaxError(`new import(`, `SyntaxError: Cannot use new with import.`);
testSyntaxError(`import.hello()`, `SyntaxError: Unexpected token '.'. Expected '(' to start an 'import' call.`);
testSyntaxError(`import[`, `SyntaxError: Unexpected token '['. Expected '(' to start an 'import' call.`);
testSyntaxError(`import<`, `SyntaxError: Unexpected token '<'. Expected '(' to start an 'import' call.`);

testSyntaxError(`import()`, `SyntaxError: Unexpected token ')'`);
testSyntaxError(`import("Hello";`, `SyntaxError: Unexpected token ';'. Expected ')' to end an 'import' call.`);
testSyntaxError(`import("Hello"];`, `SyntaxError: Unexpected token ']'. Expected ')' to end an 'import' call.`);
testSyntaxError(`import("Hello",;`, `SyntaxError: Unexpected token ','. Expected ')' to end an 'import' call.`);
testSyntaxError(`import("Hello", "Hello2";`, `SyntaxError: Unexpected token ','. Expected ')' to end an 'import' call.`);

Line 0 a/JSTests/stress/import-tests/cocoa.js_sec1
- a/JSTests/stress/import-tests/cocoa.js +7 lines
	1	export class Cocoa {
	2	}
	3
	4	export function hello()
	5	{
	6	return 42;
	7	}



export function shouldBe(actual, expected) {
    if (actual !== expected)
        throw new Error(`bad value: ${String(actual)}`);
}

export function shouldThrow(func, errorMessage) {
    var errorThrown = false;
    var error = null;
    try {
        func();
    } catch (e) {
        errorThrown = true;
        error = e;
    }
    if (!errorThrown)
        throw new Error('not thrown');
    if (String(error) !== errorMessage)
        throw new Error(`bad error: ${String(error)}`);
}

Return to Bug 165724

Lines 4261-4282 RegisterID* BytecodeGenerator::emitGetTemplateObject(RegisterID* dst, TaggedTemp a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp_sec1
- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp -11 / +13 lines
4261	cookedStrings.append(templateString->value()->cooked().impl());	4261	cookedStrings.append(templateString->value()->cooked().impl());
4262	}	4262	}
4263		4263
4264	RefPtr<RegisterID> getTemplateObject = nullptr;	4264	RefPtr<RegisterID> getTemplateObject = emitGetGlobalPrivate(newTemporary(), propertyNames().builtinNames().getTemplateObjectPrivateName());
4265	Variable var = variable(propertyNames().builtinNames().getTemplateObjectPrivateName());
4266	if (RegisterID* local = var.local())
4267	getTemplateObject = emitMove(newTemporary(), local);
4268	else {
4269	getTemplateObject = newTemporary();
4270	RefPtr<RegisterID> scope = newTemporary();
4271	moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), var));
4272	emitGetFromScope(getTemplateObject.get(), scope.get(), var, ThrowIfNotFound);
4273	}
4274
4275	CallArguments arguments(*this, nullptr);	4265	CallArguments arguments(*this, nullptr);
4276	emitLoad(arguments.thisRegister(), JSValue(addTemplateRegistryKeyConstant(m_vm->templateRegistryKeyTable().createKey(rawStrings, cookedStrings))));	4266	emitLoad(arguments.thisRegister(), JSValue(addTemplateRegistryKeyConstant(m_vm->templateRegistryKeyTable().createKey(rawStrings, cookedStrings))));
4277	return emitCall(dst, getTemplateObject.get(), NoExpectedFunction, arguments, taggedTemplate->divot(), taggedTemplate->divotStart(), taggedTemplate->divotEnd(), DebuggableCall::No);	4267	return emitCall(dst, getTemplateObject.get(), NoExpectedFunction, arguments, taggedTemplate->divot(), taggedTemplate->divotStart(), taggedTemplate->divotEnd(), DebuggableCall::No);
4278	}	4268	}
4279		4269
		4270	RegisterID* BytecodeGenerator::emitGetGlobalPrivate(RegisterID* dst, const Identifier& property)
		4271	{
		4272	dst = tempDestination(dst);
		4273	Variable var = variable(property);
		4274	if (RegisterID* local = var.local())
		4275	return emitMove(dst, local);
		4276
		4277	RefPtr<RegisterID> scope = newTemporary();
		4278	moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), var));
		4279	return emitGetFromScope(dst, scope.get(), var, ThrowIfNotFound);
		4280	}
		4281
4280	RegisterID* BytecodeGenerator::emitGetEnumerableLength(RegisterID* dst, RegisterID* base)	4282	RegisterID* BytecodeGenerator::emitGetEnumerableLength(RegisterID* dst, RegisterID* base)
4281	{	4283	{
4282	emitOpcode(op_get_enumerable_length);	4284	emitOpcode(op_get_enumerable_length);

Lines 256-261 const GlobalObjectMethodTable JSGlobalObject::s_globalObjectMethodTable = { a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp +3 lines
256	nullptr,	256	nullptr,
257	nullptr,	257	nullptr,
258	nullptr,	258	nullptr,
		259	nullptr,
259	nullptr	260	nullptr
260	};	261	};
261		262
Lines 732-737 putDirectWithoutTransition(vm, vm.propertyNames-> jsName, lowerName ## Construct a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp_sec2
732	JSFunction* privateFuncTrunc = JSFunction::create(vm, this, 0, String(), mathProtoFuncTrunc, TruncIntrinsic);	733	JSFunction* privateFuncTrunc = JSFunction::create(vm, this, 0, String(), mathProtoFuncTrunc, TruncIntrinsic);
733		734
734	JSFunction* privateFuncGetTemplateObject = JSFunction::create(vm, this, 0, String(), getTemplateObject);	735	JSFunction* privateFuncGetTemplateObject = JSFunction::create(vm, this, 0, String(), getTemplateObject);
		736	JSFunction* privateFuncImportModule = JSFunction::create(vm, this, 0, String(), globalFuncImportModule);
735	JSFunction* privateFuncTypedArrayLength = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncLength);	737	JSFunction* privateFuncTypedArrayLength = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncLength);
736	JSFunction* privateFuncTypedArrayGetOriginalConstructor = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncGetOriginalConstructor);	738	JSFunction* privateFuncTypedArrayGetOriginalConstructor = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncGetOriginalConstructor);
737	JSFunction* privateFuncTypedArraySort = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncSort);	739	JSFunction* privateFuncTypedArraySort = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncSort);
Lines 785-790 putDirectWithoutTransition(vm, vm.propertyNames-> jsName, lowerName ## Construct a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp_sec3
785	GlobalPropertyInfo(vm.propertyNames->undefinedKeyword, jsUndefined(), DontEnum \| DontDelete \| ReadOnly),	787	GlobalPropertyInfo(vm.propertyNames->undefinedKeyword, jsUndefined(), DontEnum \| DontDelete \| ReadOnly),
786	GlobalPropertyInfo(vm.propertyNames->builtinNames().ownEnumerablePropertyKeysPrivateName(), JSFunction::create(vm, this, 0, String(), ownEnumerablePropertyKeys), DontEnum \| DontDelete \| ReadOnly),	788	GlobalPropertyInfo(vm.propertyNames->builtinNames().ownEnumerablePropertyKeysPrivateName(), JSFunction::create(vm, this, 0, String(), ownEnumerablePropertyKeys), DontEnum \| DontDelete \| ReadOnly),
787	GlobalPropertyInfo(vm.propertyNames->builtinNames().getTemplateObjectPrivateName(), privateFuncGetTemplateObject, DontEnum \| DontDelete \| ReadOnly),	789	GlobalPropertyInfo(vm.propertyNames->builtinNames().getTemplateObjectPrivateName(), privateFuncGetTemplateObject, DontEnum \| DontDelete \| ReadOnly),
		790	GlobalPropertyInfo(vm.propertyNames->builtinNames().importModulePrivateName(), privateFuncImportModule, DontEnum \| DontDelete \| ReadOnly),
788	GlobalPropertyInfo(vm.propertyNames->builtinNames().enqueueJobPrivateName(), JSFunction::create(vm, this, 0, String(), enqueueJob), DontEnum \| DontDelete \| ReadOnly),	791	GlobalPropertyInfo(vm.propertyNames->builtinNames().enqueueJobPrivateName(), JSFunction::create(vm, this, 0, String(), enqueueJob), DontEnum \| DontDelete \| ReadOnly),
789	GlobalPropertyInfo(vm.propertyNames->builtinNames().ErrorPrivateName(), m_errorConstructor.get(), DontEnum \| DontDelete \| ReadOnly),	792	GlobalPropertyInfo(vm.propertyNames->builtinNames().ErrorPrivateName(), m_errorConstructor.get(), DontEnum \| DontDelete \| ReadOnly),
790	GlobalPropertyInfo(vm.propertyNames->builtinNames().RangeErrorPrivateName(), m_rangeErrorConstructor.get(), DontEnum \| DontDelete \| ReadOnly),	793	GlobalPropertyInfo(vm.propertyNames->builtinNames().RangeErrorPrivateName(), m_rangeErrorConstructor.get(), DontEnum \| DontDelete \| ReadOnly),

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +40 lines
		1	2016-12-26 Yusuke Suzuki <utatane.tea@gmail.com>
		2
		3	[JSC] Prototype dynamic-import
		4	https://bugs.webkit.org/show_bug.cgi?id=165724
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* builtins/ModuleLoaderPrototype.js:
		9	(importModule):
		10	* bytecompiler/BytecodeGenerator.cpp:
		11	(JSC::BytecodeGenerator::emitGetTemplateObject):
		12	(JSC::BytecodeGenerator::emitGetGlobalPrivate):
		13	* bytecompiler/BytecodeGenerator.h:
		14	* bytecompiler/NodesCodegen.cpp:
		15	(JSC::ImportNode::emitBytecode):
		16	* jsc.cpp:
		17	(GlobalObject::moduleLoaderImportModule):
		18	* parser/ASTBuilder.h:
		19	(JSC::ASTBuilder::createImportExpr):
		20	* parser/NodeConstructors.h:
		21	(JSC::ImportNode::ImportNode):
		22	* parser/Nodes.h:
		23	(JSC::ExpressionNode::isImportNode):
		24	* parser/Parser.cpp:
		25	(JSC::Parser<LexerType>::parseMemberExpression):
		26	* parser/SyntaxChecker.h:
		27	(JSC::SyntaxChecker::createImportExpr):
		28	* runtime/JSGlobalObject.cpp:
		29	(JSC::JSGlobalObject::init):
		30	* runtime/JSGlobalObject.h:
		31	* runtime/JSGlobalObjectFunctions.cpp:
		32	(JSC::globalFuncImportModule):
		33	* runtime/JSGlobalObjectFunctions.h:
		34	* runtime/JSModuleLoader.cpp:
		35	(JSC::JSModuleLoader::importModule):
		36	(JSC::JSModuleLoader::getModuleNamespaceObject):
		37	* runtime/JSModuleLoader.h:
		38	* runtime/ModuleLoaderPrototype.cpp:
		39	(JSC::moduleLoaderPrototypeGetModuleNamespaceObject):
		40
1	2016-12-25 Yusuke Suzuki <utatane.tea@gmail.com>	41	2016-12-25 Yusuke Suzuki <utatane.tea@gmail.com>
2		42
3	Propagate the source origin as much as possible	43	Propagate the source origin as much as possible

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +10 lines
		1	2016-12-26 Yusuke Suzuki <utatane.tea@gmail.com>
		2
		3	[JSC] Prototype dynamic-import
		4	https://bugs.webkit.org/show_bug.cgi?id=165724
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* bindings/js/JSDOMWindowBase.cpp:
		9	* bindings/js/JSWorkerGlobalScopeBase.cpp:
		10
1	2016-12-25 Chris Fleizach <cfleizach@apple.com>	11	2016-12-25 Chris Fleizach <cfleizach@apple.com>
2		12
3	AX: Headers of table not read by VoiceOver	13	AX: Headers of table not read by VoiceOver

Lines 470-472 function linkAndEvaluateModule(key, initiator) a/Source/JavaScriptCore/builtins/ModuleLoaderPrototype.js_sec1
- a/Source/JavaScriptCore/builtins/ModuleLoaderPrototype.js +16 lines
470	this.link(entry, initiator);	470	this.link(entry, initiator);
471	return this.moduleEvaluation(entry.module, initiator);	471	return this.moduleEvaluation(entry.module, initiator);
472	}	472	}
		473
		474	function importModule(moduleName, referrer, initiator)
		475	{
		476	"use strict";
		477
		478	// Loader.resolve hook point.
		479	// resolve: moduleName => Promise(moduleKey)
		480	// Take the name and resolve it to the unique identifier for the resource location.
		481	// For example, take the "jquery" and return the URL for the resource.
		482	return this.resolve(moduleName, referrer, initiator).then((key) => {
		483	return this.requestInstantiateAll(key, initiator);
		484	}).then((entry) => {
		485	this.linkAndEvaluateModule(entry.key, initiator);
		486	return this.getModuleNamespaceObject(entry.module);
		487	});
		488	}

Lines 190-195 RegisterID* SuperNode::emitBytecode(BytecodeGenerator& generator, RegisterID* ds a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp_sec1
- a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp +11 lines
190	return generator.moveToDestinationIfNeeded(generator.finalDestination(dst), result);	190	return generator.moveToDestinationIfNeeded(generator.finalDestination(dst), result);
191	}	191	}
192		192
		193	// ------------------------------ ImportNode -------------------------------------
		194
		195	RegisterID* ImportNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
		196	{
		197	RefPtr<RegisterID> importModule = generator.emitGetGlobalPrivate(generator.newTemporary(), generator.propertyNames().builtinNames().importModulePrivateName());
		198	CallArguments arguments(generator, nullptr, 1);
		199	generator.emitLoad(arguments.thisRegister(), jsUndefined());
		200	generator.emitNode(arguments.argumentRegister(0), m_expr);
		201	return generator.emitCall(generator.finalDestination(dst, importModule.get()), importModule.get(), NoExpectedFunction, arguments, divot(), divotStart(), divotEnd(), DebuggableCall::No);
		202	}
		203
193	// ------------------------------ NewTargetNode ----------------------------------	204	// ------------------------------ NewTargetNode ----------------------------------
194		205
195	RegisterID* NewTargetNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)	206	RegisterID* NewTargetNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

Lines 25-30 a/Source/JavaScriptCore/jsc.cpp_sec1
- a/Source/JavaScriptCore/jsc.cpp +19 lines
25	#include "ArrayBuffer.h"	25	#include "ArrayBuffer.h"
26	#include "ArrayPrototype.h"	26	#include "ArrayPrototype.h"
27	#include "BuiltinExecutableCreator.h"	27	#include "BuiltinExecutableCreator.h"
		28	#include "BuiltinNames.h"
28	#include "ButterflyInlines.h"	29	#include "ButterflyInlines.h"
29	#include "CodeBlock.h"	30	#include "CodeBlock.h"
30	#include "Completion.h"	31	#include "Completion.h"
Lines 48-53 a/Source/JavaScriptCore/jsc.cpp_sec2
48	#include "JSInternalPromise.h"	49	#include "JSInternalPromise.h"
49	#include "JSInternalPromiseDeferred.h"	50	#include "JSInternalPromiseDeferred.h"
50	#include "JSLock.h"	51	#include "JSLock.h"
		52	#include "JSModuleLoader.h"
51	#include "JSNativeStdFunction.h"	53	#include "JSNativeStdFunction.h"
52	#include "JSONObject.h"	54	#include "JSONObject.h"
53	#include "JSProxy.h"	55	#include "JSProxy.h"
Lines 1277-1282 class GlobalObject : public JSGlobalObject { a/Source/JavaScriptCore/jsc.cpp_sec3
1277	putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function, NoIntrinsic, function));	1279	putDirect(vm, identifier, JSFunction::create(vm, this, arguments, identifier.string(), function, NoIntrinsic, function));
1278	}	1280	}
1279		1281
		1282	static JSInternalPromise* moduleLoaderImportModule(JSGlobalObject, ExecState, JSModuleLoader, JSString, const SourceOrigin&);
1280	static JSInternalPromise* moduleLoaderResolve(JSGlobalObject, ExecState, JSModuleLoader*, JSValue, JSValue, JSValue);	1283	static JSInternalPromise* moduleLoaderResolve(JSGlobalObject, ExecState, JSModuleLoader*, JSValue, JSValue, JSValue);
1281	static JSInternalPromise* moduleLoaderFetch(JSGlobalObject, ExecState, JSModuleLoader*, JSValue, JSValue);	1284	static JSInternalPromise* moduleLoaderFetch(JSGlobalObject, ExecState, JSModuleLoader*, JSValue, JSValue);
1282	};	1285	};
Lines 1288-1293 const GlobalObjectMethodTable GlobalObject::s_globalObjectMethodTable = { a/Source/JavaScriptCore/jsc.cpp_sec4
1288	&javaScriptRuntimeFlags,	1291	&javaScriptRuntimeFlags,
1289	nullptr,	1292	nullptr,
1290	&shouldInterruptScriptBeforeTimeout,	1293	&shouldInterruptScriptBeforeTimeout,
		1294	&moduleLoaderImportModule,
1291	&moduleLoaderResolve,	1295	&moduleLoaderResolve,
1292	&moduleLoaderFetch,	1296	&moduleLoaderFetch,
1293	nullptr,	1297	nullptr,
Lines 1420-1425 static String resolvePath(const DirectoryName& directoryName, const ModuleName& a/Source/JavaScriptCore/jsc.cpp_sec5
1420	return builder.toString();	1424	return builder.toString();
1421	}	1425	}
1422		1426
		1427	JSInternalPromise* GlobalObject::moduleLoaderImportModule(JSGlobalObject, ExecState exec, JSModuleLoader* moduleLoader, JSString* moduleName, const SourceOrigin& sourceOrigin)
		1428	{
		1429	auto* function = jsCast<JSObject*>(moduleLoader->get(exec, exec->propertyNames().builtinNames().importModulePublicName()));
		1430	CallData callData;
		1431	CallType callType = JSC::getCallData(function, callData);
		1432	ASSERT(callType != CallType::None);
		1433
		1434	MarkedArgumentBuffer arguments;
		1435	arguments.append(moduleName);
		1436	arguments.append(jsString(exec, sourceOrigin.string()));
		1437	arguments.append(jsUndefined());
		1438
		1439	return jsCast<JSInternalPromise*>(call(exec, function, callType, callData, moduleLoader, arguments));
		1440	}
		1441
1423	JSInternalPromise* GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue)	1442	JSInternalPromise* GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue)
1424	{	1443	{
1425	VM& vm = globalObject->vm();	1444	VM& vm = globalObject->vm();

Lines 186-191 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec1
- a/Source/JavaScriptCore/parser/Nodes.h +12 lines
186	virtual bool isBoolean() const { return false; }	186	virtual bool isBoolean() const { return false; }
187	virtual bool isSpreadExpression() const { return false; }	187	virtual bool isSpreadExpression() const { return false; }
188	virtual bool isSuperNode() const { return false; }	188	virtual bool isSuperNode() const { return false; }
		189	virtual bool isImportNode() const { return false; }
189	virtual bool isNewTarget() const { return false; }	190	virtual bool isNewTarget() const { return false; }
190	virtual bool isBytecodeIntrinsicNode() const { return false; }	191	virtual bool isBytecodeIntrinsicNode() const { return false; }
191		192
Lines 570-575 namespace JSC { a/Source/JavaScriptCore/parser/Nodes.h_sec2
570	RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;	571	RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
571	};	572	};
572		573
		574	class ImportNode : public ExpressionNode, public ThrowableExpressionData {
		575	public:
		576	ImportNode(const JSTokenLocation&, ExpressionNode*);
		577
		578	private:
		579	bool isImportNode() const override { return true; }
		580	RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
		581
		582	ExpressionNode* m_expr;
		583	};
		584
573	class NewTargetNode final : public ExpressionNode {	585	class NewTargetNode final : public ExpressionNode {
574	public:	586	public:
575	NewTargetNode(const JSTokenLocation&);	587	NewTargetNode(const JSTokenLocation&);

Lines 71-77 class SyntaxChecker { a/Source/JavaScriptCore/parser/SyntaxChecker.h_sec1
- a/Source/JavaScriptCore/parser/SyntaxChecker.h -1 / +2 lines
71	enum { NoneExpr = 0,	71	enum { NoneExpr = 0,
72	ResolveEvalExpr, ResolveExpr, IntegerExpr, DoubleExpr, StringExpr,	72	ResolveEvalExpr, ResolveExpr, IntegerExpr, DoubleExpr, StringExpr,
73	ThisExpr, NullExpr, BoolExpr, RegExpExpr, ObjectLiteralExpr,	73	ThisExpr, NullExpr, BoolExpr, RegExpExpr, ObjectLiteralExpr,
74	FunctionExpr, ClassExpr, SuperExpr, BracketExpr, DotExpr, CallExpr,	74	FunctionExpr, ClassExpr, SuperExpr, ImportExpr, BracketExpr, DotExpr, CallExpr,
75	NewExpr, PreExpr, PostExpr, UnaryExpr, BinaryExpr,	75	NewExpr, PreExpr, PostExpr, UnaryExpr, BinaryExpr,
76	ConditionalExpr, AssignmentExpr, TypeofExpr, NewTargetExpr,	76	ConditionalExpr, AssignmentExpr, TypeofExpr, NewTargetExpr,
77	DeleteExpr, ArrayLiteralExpr, BindingDestructuring, RestParameter,	77	DeleteExpr, ArrayLiteralExpr, BindingDestructuring, RestParameter,
Lines 156-161 class SyntaxChecker { a/Source/JavaScriptCore/parser/SyntaxChecker.h_sec2
156	ExpressionType createLogicalNot(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }	156	ExpressionType createLogicalNot(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
157	ExpressionType createUnaryPlus(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }	157	ExpressionType createUnaryPlus(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
158	ExpressionType createVoid(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }	158	ExpressionType createVoid(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
		159	ExpressionType createImportExpr(const JSTokenLocation&, ExpressionType, int, int, int) { return ImportExpr; }
159	ExpressionType createThisExpr(const JSTokenLocation&) { return ThisExpr; }	160	ExpressionType createThisExpr(const JSTokenLocation&) { return ThisExpr; }
160	ExpressionType createSuperExpr(const JSTokenLocation&) { return SuperExpr; }	161	ExpressionType createSuperExpr(const JSTokenLocation&) { return SuperExpr; }
161	ExpressionType createNewTargetExpr(const JSTokenLocation&) { return NewTargetExpr; }	162	ExpressionType createNewTargetExpr(const JSTokenLocation&) { return NewTargetExpr; }

Lines 134-139 JSValue JSModuleLoader::linkAndEvaluateModule(ExecState* exec, JSValue moduleKey a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp +39 lines
134	return call(exec, function, callType, callData, this, arguments);	134	return call(exec, function, callType, callData, this, arguments);
135	}	135	}
136		136
		137	JSInternalPromise* JSModuleLoader::importModule(ExecState* exec, JSString* moduleName, const SourceOrigin& referrer)
		138	{
		139	if (Options::dumpModuleLoadingState())
		140	dataLog("Loader [import] ", printableModuleKey(exec, moduleName), "\n");
		141
		142	JSGlobalObject* globalObject = exec->lexicalGlobalObject();
		143	VM& vm = globalObject->vm();
		144	auto scope = DECLARE_CATCH_SCOPE(vm);
		145
		146	if (globalObject->globalObjectMethodTable()->moduleLoaderImportModule)
		147	return globalObject->globalObjectMethodTable()->moduleLoaderImportModule(globalObject, exec, this, moduleName, referrer);
		148
		149	JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
		150	auto moduleNameString = moduleName->value(exec);
		151	if (UNLIKELY(scope.exception())) {
		152	JSValue exception = scope.exception()->value();
		153	scope.clearException();
		154	deferred->reject(exec, exception);
		155	return deferred->promise();
		156	}
		157	deferred->reject(exec, createError(exec, makeString("Could not import the module '", moduleNameString, "'.")));
		158	return deferred->promise();
		159	}
		160
137	JSInternalPromise* JSModuleLoader::resolve(ExecState* exec, JSValue name, JSValue referrer, JSValue initiator)	161	JSInternalPromise* JSModuleLoader::resolve(ExecState* exec, JSValue name, JSValue referrer, JSValue initiator)
138	{	162	{
139	if (Options::dumpModuleLoadingState())	163	if (Options::dumpModuleLoadingState())
Lines 197-200 JSValue JSModuleLoader::evaluate(ExecState* exec, JSValue key, JSValue moduleRec a/Source/JavaScriptCore/runtime/JSModuleLoader.cpp_sec2
197	return moduleRecord->evaluate(exec);	221	return moduleRecord->evaluate(exec);
198	}	222	}
199		223
		224	JSModuleNamespaceObject* JSModuleLoader::getModuleNamespaceObject(ExecState* exec, JSValue moduleRecordValue)
		225	{
		226	VM& vm = exec->vm();
		227	auto scope = DECLARE_THROW_SCOPE(vm);
		228
		229	auto* moduleRecord = jsDynamicCast<AbstractModuleRecord*>(moduleRecordValue);
		230	if (!moduleRecord) {
		231	throwTypeError(exec, scope);
		232	return nullptr;
		233	}
		234
		235	scope.release();
		236	return moduleRecord->getModuleNamespace(exec);
		237	}
		238
200	} // namespace JSC	239	} // namespace JSC

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +9 lines
		1	2016-12-26 Yusuke Suzuki <utatane.tea@gmail.com>
		2
		3	[JSC] Prototype dynamic-import
		4	https://bugs.webkit.org/show_bug.cgi?id=165724
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* sputnik/Conformance/07_Lexical_Conventions/7.5_Tokens/7.5.3_Future_Reserved_Words/S7.5.3_A1.16-expected.txt:
		9
1	2016-12-25 Chris Fleizach <cfleizach@apple.com>	10	2016-12-25 Chris Fleizach <cfleizach@apple.com>
2		11
3	AX: Headers of table not read by VoiceOver	12	AX: Headers of table not read by VoiceOver

Lines 1-3 a/JSTests/ChangeLog_sec1
- a/JSTests/ChangeLog +18 lines
		1	2016-12-26 Yusuke Suzuki <utatane.tea@gmail.com>
		2
		3	[JSC] Prototype dynamic-import
		4	https://bugs.webkit.org/show_bug.cgi?id=165724
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* stress/import-from-eval.js: Added.
		9	(async):
		10	* stress/import-syntax.js: Added.
		11	(testSyntaxError):
		12	* stress/import-tests/cocoa.js: Added.
		13	(export.Cocoa):
		14	(export.hello):
		15	* stress/import-tests/should.js: Added.
		16	(export.shouldBe):
		17	(export.shouldThrow):
		18
1	2016-12-25 Yusuke Suzuki <utatane.tea@gmail.com>	19	2016-12-25 Yusuke Suzuki <utatane.tea@gmail.com>
2		20
3	Propagate the source origin as much as possible	21	Propagate the source origin as much as possible

Line 0 a/JSTests/stress/import-from-eval.js_sec1
- a/JSTests/stress/import-from-eval.js +33 lines
	1	(async function () {
	2	const { shouldBe, shouldThrow } = await import("./import-tests/should.js");
	3
	4	{
	5	let cocoa = await eval(`import("./import-tests/cocoa.js")`);
	6	shouldBe(cocoa.hello(), 42);
	7	}
	8
	9	{
	10	let cocoa = await (0, eval)(`import("./import-tests/cocoa.js")`);
	11	shouldBe(cocoa.hello(), 42);
	12	}
	13
	14	{
	15	let cocoa = await eval(`eval('import("./import-tests/cocoa.js")')`);
	16	shouldBe(cocoa.hello(), 42);
	17	}
	18
	19	{
	20	let cocoa = await ((new Function(`return eval('import("./import-tests/cocoa.js")')`))());
	21	shouldBe(cocoa.hello(), 42);
	22	}
	23
	24	{
	25	let cocoa = await eval(`(new Function('return import("./import-tests/cocoa.js")'))()`);
	26	shouldBe(cocoa.hello(), 42);
	27	}
	28
	29	{
	30	let cocoa = await [`import("./import-tests/cocoa.js")`].map(eval)[0];
	31	shouldBe(cocoa.hello(), 42);
	32	}
	33	}());

Line 0 a/JSTests/stress/import-syntax.js_sec1
- a/JSTests/stress/import-syntax.js +25 lines
	1	function testSyntaxError(script, message) {
	2	var error = null;
	3	try {
	4	eval(script);
	5	} catch (e) {
	6	error = e;
	7	}
	8	if (!error)
	9	throw new Error("Expected syntax error not thrown");
	10
	11	if (String(error) !== message)
	12	throw new Error(`Bad error: ${String(error)}`);
	13	}
	14
	15	testSyntaxError(`import)`, `SyntaxError: Unexpected token ')'. Expected '(' to start an 'import' call.`);
	16	testSyntaxError(`new import(`, `SyntaxError: Cannot use new with import.`);
	17	testSyntaxError(`import.hello()`, `SyntaxError: Unexpected token '.'. Expected '(' to start an 'import' call.`);
	18	testSyntaxError(`import[`, `SyntaxError: Unexpected token '['. Expected '(' to start an 'import' call.`);
	19	testSyntaxError(`import<`, `SyntaxError: Unexpected token '<'. Expected '(' to start an 'import' call.`);
	20
	21	testSyntaxError(`import()`, `SyntaxError: Unexpected token ')'`);
	22	testSyntaxError(`import("Hello";`, `SyntaxError: Unexpected token ';'. Expected ')' to end an 'import' call.`);
	23	testSyntaxError(`import("Hello"];`, `SyntaxError: Unexpected token ']'. Expected ')' to end an 'import' call.`);
	24	testSyntaxError(`import("Hello",;`, `SyntaxError: Unexpected token ','. Expected ')' to end an 'import' call.`);
	25	testSyntaxError(`import("Hello", "Hello2";`, `SyntaxError: Unexpected token ','. Expected ')' to end an 'import' call.`);

Line 0 a/JSTests/stress/import-tests/should.js_sec1
- a/JSTests/stress/import-tests/should.js +19 lines
	1	export function shouldBe(actual, expected) {
	2	if (actual !== expected)
	3	throw new Error(`bad value: ${String(actual)}`);
	4	}
	5
	6	export function shouldThrow(func, errorMessage) {
	7	var errorThrown = false;
	8	var error = null;
	9	try {
	10	func();
	11	} catch (e) {
	12	errorThrown = true;
	13	error = e;
	14	}
	15	if (!errorThrown)
	16	throw new Error('not thrown');
	17	if (String(error) !== errorMessage)
	18	throw new Error(`bad error: ${String(error)}`);
	19	}