Attachment #298382 for bug #165724

View Details Raw Unified Return to Bug 165724

| Differences between



2017-01-09  Yusuke Suzuki  <utatane.tea@gmail.com>

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

        Reviewed by Saam Barati.

        In this patch, we implement stage3 dynamic-import proposal[1].
        This patch adds a new special operator `import`. And by using it, we can import
        the module dynamically from modules and scripts. Before this feature, the module
        is always imported statically and before executing the modules, importing the modules
        needs to be done. And especially, the module can only be imported from the module.
        So the classic script cannot import and use the modules. This dynamic-import relaxes
        the above restrictions.

        The typical dynamic-import form is the following.

            import("...").then(function (namespace) { ... });

        You can pass any AssignmentExpression for the import operator. So you can determine
        the importing modules dynamically.

            import(value).then(function (namespace) { ... });

        And previously the module import declaration is only allowed in the top level statements.
        But this import operator is just an expression. So you can use it in the function.
        And you can use it conditionally.

            async function go(cond)
            {
                if (cond)
                    return import("...");
                return undefined;
            }
            await go(true);

        Currently, this patch just implements this feature only for the JSC shell.
        JSC module loader requires a new hook, `importModule`. And the JSC shell implements
        this hook. So, for now, this dynamic-import is not available in the browser side.
        If you write this `import` call, it always returns the rejected promise.

        import is implemented like a special operator similar to `super`.
        This is because import is context-sensitive. If you call the `import`, the module
        key resolution is done based on the caller's running context.

        For example, if you are running the script which filename is "./ok/hello.js", the module
        key for the call`import("./resource/syntax.js")` becomes `"./ok/resource/syntax.js"`.
        But if you write the completely same import form in the script "./error/hello.js", the
        key becomes "./error/resource/syntax.js". So exposing this feature as the `import`
        function is misleading: this function becomes caller's context-sensitive. That's why
        dynamic-import is specified as a special operator.

        To resolve the module key, we need the caller's context information like the filename of
        the caller. This is provided by the SourceOrigin implemented in r210149.
        In the JSC shell implementation, this SourceOrigin holds the filename of the caller. So
        based on this implementation, the module loader resolve the module key.
        In the near future, we will extend this SourceOrigin to hold more information needed for
        the browser-side import implementation.

        [1]: https://tc39.github.io/proposal-dynamic-import/

        * builtins/ModuleLoaderPrototype.js:
        (importModule):
        * bytecompiler/BytecodeGenerator.cpp:
        (JSC::BytecodeGenerator::emitGetTemplateObject):
        (JSC::BytecodeGenerator::emitGetGlobalPrivate):
        * bytecompiler/BytecodeGenerator.h:
        * bytecompiler/NodesCodegen.cpp:
        (JSC::ImportNode::emitBytecode):
        * jsc.cpp:
        (absolutePath):
        (GlobalObject::moduleLoaderImportModule):
        (functionRun):
        (functionLoad):
        (functionCheckSyntax):
        (runWithScripts):
        * 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):

2017-01-08  Andreas Kling  <akling@apple.com>

        Inject MarkedSpace size classes for a few more high-volume objects.



2017-01-09  Yusuke Suzuki  <utatane.tea@gmail.com>

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

        Reviewed by Saam Barati.

        We do not set a handler for import for now.
        So dynamic import feature is only enabled in the JSC shell right now.

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

2017-01-09  Youenn Fablet  <youennf@gmail.com>

        Merging ThreadableLoader redundant options on filtering responses



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

static String absolutePath(const String& fileName)
{
    auto directoryName = currentWorkingDirectory();
    if (!directoryName)
        return fileName;
    return resolvePath(directoryName.value(), ModuleName(fileName.impl()));
}

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;
    auto 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();

    NakedPtr<Exception> exception;
    StopWatch stopWatch;
    stopWatch.start();
    evaluate(globalObject->globalExec(), jscSource(script, absolutePath(fileName)), JSValue(), exception);
    stopWatch.stop();

    if (exception) {

    JSGlobalObject* globalObject = exec->lexicalGlobalObject();
    
    NakedPtr<Exception> evaluationException;
    JSValue result = evaluate(globalObject->globalExec(), jscSource(script, absolutePath(fileName)), JSValue(), evaluationException);
    if (evaluationException)
        throwException(exec, scope, evaluationException);
    return JSValue::encode(result);

    stopWatch.start();

    JSValue syntaxException;
    bool validSyntax = checkSyntax(globalObject->globalExec(), jscSource(script, absolutePath(fileName)), &syntaxException);
    stopWatch.stop();

    if (!validSyntax)

        bool isLastFile = i == scripts.size() - 1;
        if (isModule) {
            if (!promise)
                promise = loadAndEvaluateModule(globalObject->globalExec(), jscSource(scriptBuffer, absolutePath(fileName)));
            scope.clearException();

            JSFunction* fulfillHandler = JSNativeStdFunction::create(vm, globalObject, 1, String(), [&, isLastFile](ExecState* exec) {

            vm.drainMicrotasks();
        } else {
            NakedPtr<Exception> evaluationException;
            JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(scriptBuffer, absolutePath(fileName)), JSValue(), evaluationException);
            ASSERT(!scope.exception());
            if (evaluationException)
                returnValue = evaluationException->value();

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&);



    }

    bool baseIsSuper = match(SUPER);
    bool baseIsImport = match(IMPORT);
    semanticFailIfTrue((baseIsSuper || baseIsImport) && newCount, "Cannot use new with ", getToken());

    bool baseIsNewTarget = false;
    if (newCount && match(DOT)) {

                semanticFailIfTrue(functionSuperBinding == SuperBinding::NotNeeded, "super is not valid in this context");
            }
        }
    } else if (baseIsImport) {
        JSTextPosition expressionEnd = lastTokenEndPosition();
        next();
        consumeOrFail(OPENPAREN, "import call expects exactly one argument");
        TreeExpression expr = parseAssignmentExpression(context);
        failIfFalse(expr, "Cannot parse expression");
        consumeOrFail(CLOSEPAREN, "import call expects exactly one argument");
        return context.createImportExpr(location, expr, expressionStart, expressionEnd, lastTokenEndPosition());
    } else if (!baseIsNewTarget) {
        const bool isAsync = match(ASYNC);




    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 +39 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, { });
		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	RELEASE_ASSERT(exec->argumentCount() == 1);
		949	auto* specifier = exec->uncheckedArgument(0).toString(exec);
		950	if (Exception* exception = catchScope.exception()) {
		951	catchScope.clearException();
		952	promise->reject(exec, exception);
		953	return JSValue::encode(promise->promise());
		954	}
		955
		956	auto* internalPromise = globalObject->moduleLoader()->importModule(exec, specifier, sourceOrigin);
		957	if (Exception* exception = catchScope.exception()) {
		958	catchScope.clearException();
		959	promise->reject(exec, exception);
		960	return JSValue::encode(promise->promise());
		961	}
		962	promise->resolve(exec, internalPromise);
		963
		964	return JSValue::encode(promise->promise());
		965	}
		966
928	} // namespace JSC	967	} // 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");

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

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	auto* 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



2017-01-09  Yusuke Suzuki  <utatane.tea@gmail.com>

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

        Reviewed by Saam Barati.

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

2017-01-09  Beth Dakin  <bdakin@apple.com>

        Add a test to ensure that preventDefault on touchmove prevents scrolling

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 '='. import call expects exactly one argument.
2	S7.5.3_A1.16	2	S7.5.3_A1.16
3		3
4	PASS Expected parsing failure	4	PASS Expected parsing failure



2017-01-09  Yusuke Suzuki  <utatane.tea@gmail.com>

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

        Reviewed by Saam Barati.

        * stress/import-basic.js: Added.
        (async.async.load):
        (async):
        (catch):
        * stress/import-from-eval.js: Added.
        (async):
        (catch):
        * stress/import-syntax.js: Added.
        (testSyntaxError):
        * stress/import-tests/cocoa.js: Added.
        (export.Cocoa):
        (export.hello):
        * stress/import-tests/multiple.js: Added.
        (export.result):
        * stress/import-tests/multiple2.js: Added.
        (export.ok):
        * stress/import-tests/should.js: Added.
        (export.shouldBe):
        (export.shouldThrow):
        * stress/modules-syntax-error.js:

2017-01-06  Saam Barati  <sbarati@apple.com>

        Add a slice intrinsic to the DFG/FTL



(async function () {
    const { shouldBe } = await import('./import-tests/should.js');
    {
        let a = await import('./import-tests/cocoa.js');
        let b = await import('./import-tests/cocoa.js');
        shouldBe(a, b);
        shouldBe(a.hello(), 42);
    }

    {
        let a = await import('./import-tests/multiple.js');
        let a2 = await a.result();
        shouldBe(a !== a2, true);
        shouldBe(a2.ok(), 42);
        let a3 = await a.result();
        shouldBe(a2, a3);
    }

    {
        let error = null;
        try {
            let a = await import({ toString() { throw new Error('out'); } });
        } catch (e) {
            error = e;
        }
        shouldBe(error !== null, true);
        shouldBe(String(error), `Error: out`);
    }

    {
        async function load(cond) {
            if (cond)
                return import('./import-tests/cocoa.js');
            return undefined;
        }

        let v = await load(false);
        shouldBe(v, undefined);
        let v2 = await load(true);
        let v3 = await import('./import-tests/cocoa.js');
        shouldBe(v2, v2);
    }

    {
        let value = './import-tests/cocoa.js';
        let v = await import(value);
        let v2 = await import('./import-tests/cocoa.js');
        shouldBe(v, v2);
    }
}()).catch((error) => {
    print(String(error));
    abort();
});



(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);
    }
}()).catch((error) => {
    print(String(error));
    abort();
});



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 ')'. import call expects exactly one argument.`);
testSyntaxError(`new import(`, `SyntaxError: Cannot use new with import.`);
testSyntaxError(`import.hello()`, `SyntaxError: Unexpected token '.'. import call expects exactly one argument.`);
testSyntaxError(`import[`, `SyntaxError: Unexpected token '['. import call expects exactly one argument.`);
testSyntaxError(`import<`, `SyntaxError: Unexpected token '<'. import call expects exactly one argument.`);

testSyntaxError(`import()`, `SyntaxError: Unexpected token ')'`);
testSyntaxError(`import(a, b)`, `SyntaxError: Unexpected token ','. import call expects exactly one argument.`);
testSyntaxError(`import(a, b, c)`, `SyntaxError: Unexpected token ','. import call expects exactly one argument.`);
testSyntaxError(`import(...a)`, `SyntaxError: Unexpected token '...'`);
testSyntaxError(`import(,a)`, `SyntaxError: Unexpected token ','`);
testSyntaxError(`import(,)`, `SyntaxError: Unexpected token ','`);
testSyntaxError(`import("Hello";`, `SyntaxError: Unexpected token ';'. import call expects exactly one argument.`);
testSyntaxError(`import("Hello"];`, `SyntaxError: Unexpected token ']'. import call expects exactly one argument.`);
testSyntaxError(`import("Hello",;`, `SyntaxError: Unexpected token ','. import call expects exactly one argument.`);
testSyntaxError(`import("Hello", "Hello2";`, `SyntaxError: Unexpected token ','. import call expects exactly one argument.`);


testSyntaxError(`import = 42`, `SyntaxError: Unexpected token '='. import call expects exactly one argument.`);
testSyntaxError(`[import] = 42`, `SyntaxError: Unexpected token ']'. import call expects exactly one argument.`);
testSyntaxError(`{import} = 42`, `SyntaxError: Unexpected token '}'. import call expects exactly one argument.`);
testSyntaxError(`let import = 42`, `SyntaxError: Unexpected keyword 'import'`);
testSyntaxError(`var import = 42`, `SyntaxError: Cannot use the keyword 'import' as a variable name.`);
testSyntaxError(`const import = 42`, `SyntaxError: Cannot use the keyword 'import' as a lexical variable name.`);

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	}

Line 0 a/JSTests/stress/import-tests/multiple.js_sec1
- a/JSTests/stress/import-tests/multiple.js +4 lines
	1	export function result()
	2	{
	3	return import('./multiple2.js');
	4	}

Line 0 a/JSTests/stress/import-tests/multiple2.js_sec1
- a/JSTests/stress/import-tests/multiple2.js +4 lines
	1	export function ok()
	2	{
	3	return 42;
	4	}



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)}`);
}



function noTopLevel() {
    import * as from from "Cocoa"
}
`, `SyntaxError: Unexpected token '*'. import call expects exactly one argument.:3`);

checkModuleSyntaxError(String.raw`
if (noTopLevel) {
    import * as from from "Cocoa"
}
`, `SyntaxError: Unexpected token '*'. import call expects exactly one argument.:3`);

checkModuleSyntaxError(String.raw`
{
    import * as from from "Cocoa"
}
`, `SyntaxError: Unexpected token '*'. import call expects exactly one argument.:3`);

checkModuleSyntaxError(String.raw`
for (var i = 0; i < 1000; ++i) {
    import * as from from "Cocoa"
}
`, `SyntaxError: Unexpected token '*'. import call expects exactly one argument.:3`);

checkModuleSyntaxError(String.raw`
import for from "Cocoa";

Return to Bug 165724

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 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 4343-4349 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres a/Source/JavaScriptCore/parser/Parser.cpp_sec1
- a/Source/JavaScriptCore/parser/Parser.cpp -1 / +10 lines
4343	}	4343	}
4344		4344
4345	bool baseIsSuper = match(SUPER);	4345	bool baseIsSuper = match(SUPER);
4346	semanticFailIfTrue(baseIsSuper && newCount, "Cannot use new with super");	4346	bool baseIsImport = match(IMPORT);
		4347	semanticFailIfTrue((baseIsSuper \|\| baseIsImport) && newCount, "Cannot use new with ", getToken());
4347		4348
4348	bool baseIsNewTarget = false;	4349	bool baseIsNewTarget = false;
4349	if (newCount && match(DOT)) {	4350	if (newCount && match(DOT)) {
Lines 4383-4388 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres a/Source/JavaScriptCore/parser/Parser.cpp_sec2
4383	semanticFailIfTrue(functionSuperBinding == SuperBinding::NotNeeded, "super is not valid in this context");	4384	semanticFailIfTrue(functionSuperBinding == SuperBinding::NotNeeded, "super is not valid in this context");
4384	}	4385	}
4385	}	4386	}
		4387	} else if (baseIsImport) {
		4388	JSTextPosition expressionEnd = lastTokenEndPosition();
		4389	next();
		4390	consumeOrFail(OPENPAREN, "import call expects exactly one argument");
		4391	TreeExpression expr = parseAssignmentExpression(context);
		4392	failIfFalse(expr, "Cannot parse expression");
		4393	consumeOrFail(CLOSEPAREN, "import call expects exactly one argument");
		4394	return context.createImportExpr(location, expr, expressionStart, expressionEnd, lastTokenEndPosition());
4386	} else if (!baseIsNewTarget) {	4395	} else if (!baseIsNewTarget) {
4387	const bool isAsync = match(ASYNC);	4396	const bool isAsync = match(ASYNC);
4388		4397

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 733-738 putDirectWithoutTransition(vm, vm.propertyNames-> jsName, lowerName ## Construct a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp_sec2
733	JSFunction* privateFuncTrunc = JSFunction::create(vm, this, 0, String(), mathProtoFuncTrunc, TruncIntrinsic);	734	JSFunction* privateFuncTrunc = JSFunction::create(vm, this, 0, String(), mathProtoFuncTrunc, TruncIntrinsic);
734		735
735	JSFunction* privateFuncGetTemplateObject = JSFunction::create(vm, this, 0, String(), getTemplateObject);	736	JSFunction* privateFuncGetTemplateObject = JSFunction::create(vm, this, 0, String(), getTemplateObject);
		737	JSFunction* privateFuncImportModule = JSFunction::create(vm, this, 0, String(), globalFuncImportModule);
736	JSFunction* privateFuncTypedArrayLength = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncLength);	738	JSFunction* privateFuncTypedArrayLength = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncLength);
737	JSFunction* privateFuncTypedArrayGetOriginalConstructor = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncGetOriginalConstructor);	739	JSFunction* privateFuncTypedArrayGetOriginalConstructor = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncGetOriginalConstructor);
738	JSFunction* privateFuncTypedArraySort = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncSort);	740	JSFunction* privateFuncTypedArraySort = JSFunction::create(vm, this, 0, String(), typedArrayViewPrivateFuncSort);
Lines 786-791 putDirectWithoutTransition(vm, vm.propertyNames-> jsName, lowerName ## Construct a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp_sec3
786	GlobalPropertyInfo(vm.propertyNames->undefinedKeyword, jsUndefined(), DontEnum \| DontDelete \| ReadOnly),	788	GlobalPropertyInfo(vm.propertyNames->undefinedKeyword, jsUndefined(), DontEnum \| DontDelete \| ReadOnly),
787	GlobalPropertyInfo(vm.propertyNames->builtinNames().ownEnumerablePropertyKeysPrivateName(), JSFunction::create(vm, this, 0, String(), ownEnumerablePropertyKeys), DontEnum \| DontDelete \| ReadOnly),	789	GlobalPropertyInfo(vm.propertyNames->builtinNames().ownEnumerablePropertyKeysPrivateName(), JSFunction::create(vm, this, 0, String(), ownEnumerablePropertyKeys), DontEnum \| DontDelete \| ReadOnly),
788	GlobalPropertyInfo(vm.propertyNames->builtinNames().getTemplateObjectPrivateName(), privateFuncGetTemplateObject, DontEnum \| DontDelete \| ReadOnly),	790	GlobalPropertyInfo(vm.propertyNames->builtinNames().getTemplateObjectPrivateName(), privateFuncGetTemplateObject, DontEnum \| DontDelete \| ReadOnly),
		791	GlobalPropertyInfo(vm.propertyNames->builtinNames().importModulePrivateName(), privateFuncImportModule, DontEnum \| DontDelete \| ReadOnly),
789	GlobalPropertyInfo(vm.propertyNames->builtinNames().enqueueJobPrivateName(), JSFunction::create(vm, this, 0, String(), enqueueJob), DontEnum \| DontDelete \| ReadOnly),	792	GlobalPropertyInfo(vm.propertyNames->builtinNames().enqueueJobPrivateName(), JSFunction::create(vm, this, 0, String(), enqueueJob), DontEnum \| DontDelete \| ReadOnly),
790	GlobalPropertyInfo(vm.propertyNames->builtinNames().ErrorPrivateName(), m_errorConstructor.get(), DontEnum \| DontDelete \| ReadOnly),	793	GlobalPropertyInfo(vm.propertyNames->builtinNames().ErrorPrivateName(), m_errorConstructor.get(), DontEnum \| DontDelete \| ReadOnly),
791	GlobalPropertyInfo(vm.propertyNames->builtinNames().RangeErrorPrivateName(), m_rangeErrorConstructor.get(), DontEnum \| DontDelete \| ReadOnly),	794	GlobalPropertyInfo(vm.propertyNames->builtinNames().RangeErrorPrivateName(), m_rangeErrorConstructor.get(), DontEnum \| DontDelete \| ReadOnly),

Lines 107-131 function checkModuleSyntaxError(source, errorMessage) { a/JSTests/stress/modules-syntax-error.js_sec1
- a/JSTests/stress/modules-syntax-error.js -4 / +4 lines
107	function noTopLevel() {	107	function noTopLevel() {
108	import * as from from "Cocoa"	108	import * as from from "Cocoa"
109	}	109	}
110	`, `SyntaxError: Unexpected keyword 'import':3`);	110	`, `SyntaxError: Unexpected token '*'. import call expects exactly one argument.:3`);
111		111
112	checkModuleSyntaxError(String.raw`	112	checkModuleSyntaxError(String.raw`
113	if (noTopLevel) {	113	if (noTopLevel) {
114	import * as from from "Cocoa"	114	import * as from from "Cocoa"
115	}	115	}
116	`, `SyntaxError: Unexpected keyword 'import':3`);	116	`, `SyntaxError: Unexpected token '*'. import call expects exactly one argument.:3`);
117		117
118	checkModuleSyntaxError(String.raw`	118	checkModuleSyntaxError(String.raw`
119	{	119	{
120	import * as from from "Cocoa"	120	import * as from from "Cocoa"
121	}	121	}
122	`, `SyntaxError: Unexpected keyword 'import':3`);	122	`, `SyntaxError: Unexpected token '*'. import call expects exactly one argument.:3`);
123		123
124	checkModuleSyntaxError(String.raw`	124	checkModuleSyntaxError(String.raw`
125	for (var i = 0; i < 1000; ++i) {	125	for (var i = 0; i < 1000; ++i) {
126	import * as from from "Cocoa"	126	import * as from from "Cocoa"
127	}	127	}
128	`, `SyntaxError: Unexpected keyword 'import':3`);	128	`, `SyntaxError: Unexpected token '*'. import call expects exactly one argument.:3`);
129		129
130	checkModuleSyntaxError(String.raw`	130	checkModuleSyntaxError(String.raw`
131	import for from "Cocoa";	131	import for from "Cocoa";

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +99 lines
		1	2017-01-09 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 Saam Barati.
		7
		8	In this patch, we implement stage3 dynamic-import proposal[1].
		9	This patch adds a new special operator `import`. And by using it, we can import
		10	the module dynamically from modules and scripts. Before this feature, the module
		11	is always imported statically and before executing the modules, importing the modules
		12	needs to be done. And especially, the module can only be imported from the module.
		13	So the classic script cannot import and use the modules. This dynamic-import relaxes
		14	the above restrictions.
		15
		16	The typical dynamic-import form is the following.
		17
		18	import("...").then(function (namespace) { ... });
		19
		20	You can pass any AssignmentExpression for the import operator. So you can determine
		21	the importing modules dynamically.
		22
		23	import(value).then(function (namespace) { ... });
		24
		25	And previously the module import declaration is only allowed in the top level statements.
		26	But this import operator is just an expression. So you can use it in the function.
		27	And you can use it conditionally.
		28
		29	async function go(cond)
		30	{
		31	if (cond)
		32	return import("...");
		33	return undefined;
		34	}
		35	await go(true);
		36
		37	Currently, this patch just implements this feature only for the JSC shell.
		38	JSC module loader requires a new hook, `importModule`. And the JSC shell implements
		39	this hook. So, for now, this dynamic-import is not available in the browser side.
		40	If you write this `import` call, it always returns the rejected promise.
		41
		42	import is implemented like a special operator similar to `super`.
		43	This is because import is context-sensitive. If you call the `import`, the module
		44	key resolution is done based on the caller's running context.
		45
		46	For example, if you are running the script which filename is "./ok/hello.js", the module
		47	key for the call`import("./resource/syntax.js")` becomes `"./ok/resource/syntax.js"`.
		48	But if you write the completely same import form in the script "./error/hello.js", the
		49	key becomes "./error/resource/syntax.js". So exposing this feature as the `import`
		50	function is misleading: this function becomes caller's context-sensitive. That's why
		51	dynamic-import is specified as a special operator.
		52
		53	To resolve the module key, we need the caller's context information like the filename of
		54	the caller. This is provided by the SourceOrigin implemented in r210149.
		55	In the JSC shell implementation, this SourceOrigin holds the filename of the caller. So
		56	based on this implementation, the module loader resolve the module key.
		57	In the near future, we will extend this SourceOrigin to hold more information needed for
		58	the browser-side import implementation.
		59
		60	[1]: https://tc39.github.io/proposal-dynamic-import/
		61
		62	* builtins/ModuleLoaderPrototype.js:
		63	(importModule):
		64	* bytecompiler/BytecodeGenerator.cpp:
65	(JSC::BytecodeGenerator::emitGetTemplateObject):
66	(JSC::BytecodeGenerator::emitGetGlobalPrivate):
67	* bytecompiler/BytecodeGenerator.h:
68	* bytecompiler/NodesCodegen.cpp:
69	(JSC::ImportNode::emitBytecode):
70	* jsc.cpp:
71	(absolutePath):
72	(GlobalObject::moduleLoaderImportModule):
73	(functionRun):
74	(functionLoad):
75	(functionCheckSyntax):
76	(runWithScripts):
77	* parser/ASTBuilder.h:
78	(JSC::ASTBuilder::createImportExpr):
79	* parser/NodeConstructors.h:
80	(JSC::ImportNode::ImportNode):
81	* parser/Nodes.h:
82	(JSC::ExpressionNode::isImportNode):
83	* parser/Parser.cpp:
84	(JSC::Parser<LexerType>::parseMemberExpression):
85	* parser/SyntaxChecker.h:
86	(JSC::SyntaxChecker::createImportExpr):
87	* runtime/JSGlobalObject.cpp:
88	(JSC::JSGlobalObject::init):
89	* runtime/JSGlobalObject.h:
90	* runtime/JSGlobalObjectFunctions.cpp:
91	(JSC::globalFuncImportModule):
92	* runtime/JSGlobalObjectFunctions.h:
93	* runtime/JSModuleLoader.cpp:
94	(JSC::JSModuleLoader::importModule):
95	(JSC::JSModuleLoader::getModuleNamespaceObject):
96	* runtime/JSModuleLoader.h:
97	* runtime/ModuleLoaderPrototype.cpp:
98	(JSC::moduleLoaderPrototypeGetModuleNamespaceObject):
99
1	2017-01-08 Andreas Kling <akling@apple.com>	100	2017-01-08 Andreas Kling <akling@apple.com>
2		101
3	Inject MarkedSpace size classes for a few more high-volume objects.	102	Inject MarkedSpace size classes for a few more high-volume objects.

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +13 lines
		1	2017-01-09 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 Saam Barati.
		7
		8	We do not set a handler for import for now.
		9	So dynamic import feature is only enabled in the JSC shell right now.
		10
		11	* bindings/js/JSDOMWindowBase.cpp:
		12	* bindings/js/JSWorkerGlobalScopeBase.cpp:
		13
1	2017-01-09 Youenn Fablet <youennf@gmail.com>	14	2017-01-09 Youenn Fablet <youennf@gmail.com>
2		15
3	Merging ThreadableLoader redundant options on filtering responses	16	Merging ThreadableLoader redundant options on filtering responses

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 -5 / +32 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	static String absolutePath(const String& fileName)
		1428	{
		1429	auto directoryName = currentWorkingDirectory();
		1430	if (!directoryName)
		1431	return fileName;
		1432	return resolvePath(directoryName.value(), ModuleName(fileName.impl()));
		1433	}
		1434
		1435	JSInternalPromise* GlobalObject::moduleLoaderImportModule(JSGlobalObject, ExecState exec, JSModuleLoader* moduleLoader, JSString* moduleName, const SourceOrigin& sourceOrigin)
		1436	{
		1437	auto* function = jsCast<JSObject*>(moduleLoader->get(exec, exec->propertyNames().builtinNames().importModulePublicName()));
		1438	CallData callData;
		1439	auto callType = JSC::getCallData(function, callData);
		1440	ASSERT(callType != CallType::None);
		1441
		1442	MarkedArgumentBuffer arguments;
		1443	arguments.append(moduleName);
		1444	arguments.append(jsString(exec, sourceOrigin.string()));
		1445	arguments.append(jsUndefined());
		1446
		1447	return jsCast<JSInternalPromise*>(call(exec, function, callType, callData, moduleLoader, arguments));
		1448	}
		1449
1423	JSInternalPromise* GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue)	1450	JSInternalPromise* GlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue)
1424	{	1451	{
1425	VM& vm = globalObject->vm();	1452	VM& vm = globalObject->vm();
Lines 1924-1930 EncodedJSValue JSC_HOST_CALL functionRun(ExecState* exec) a/Source/JavaScriptCore/jsc.cpp_sec6
1924	NakedPtr<Exception> exception;	1951	NakedPtr<Exception> exception;
1925	StopWatch stopWatch;	1952	StopWatch stopWatch;
1926	stopWatch.start();	1953	stopWatch.start();
1927	evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), exception);	1954	evaluate(globalObject->globalExec(), jscSource(script, absolutePath(fileName)), JSValue(), exception);
1928	stopWatch.stop();	1955	stopWatch.stop();
1929		1956
1930	if (exception) {	1957	if (exception) {
Lines 1976-1982 EncodedJSValue JSC_HOST_CALL functionLoad(ExecState* exec) a/Source/JavaScriptCore/jsc.cpp_sec7
1976	JSGlobalObject* globalObject = exec->lexicalGlobalObject();	2003	JSGlobalObject* globalObject = exec->lexicalGlobalObject();
1977		2004
1978	NakedPtr<Exception> evaluationException;	2005	NakedPtr<Exception> evaluationException;
1979	JSValue result = evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), evaluationException);	2006	JSValue result = evaluate(globalObject->globalExec(), jscSource(script, absolutePath(fileName)), JSValue(), evaluationException);
1980	if (evaluationException)	2007	if (evaluationException)
1981	throwException(exec, scope, evaluationException);	2008	throwException(exec, scope, evaluationException);
1982	return JSValue::encode(result);	2009	return JSValue::encode(result);
Lines 2047-2053 EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec) a/Source/JavaScriptCore/jsc.cpp_sec8
2047	stopWatch.start();	2074	stopWatch.start();
2048		2075
2049	JSValue syntaxException;	2076	JSValue syntaxException;
2050	bool validSyntax = checkSyntax(globalObject->globalExec(), jscSource(script, fileName), &syntaxException);	2077	bool validSyntax = checkSyntax(globalObject->globalExec(), jscSource(script, absolutePath(fileName)), &syntaxException);
2051	stopWatch.stop();	2078	stopWatch.stop();
2052		2079
2053	if (!validSyntax)	2080	if (!validSyntax)
Lines 2909-2915 static bool runWithScripts(GlobalObject* globalObject, const Vector<Script>& scr a/Source/JavaScriptCore/jsc.cpp_sec9
2909	bool isLastFile = i == scripts.size() - 1;	2936	bool isLastFile = i == scripts.size() - 1;
2910	if (isModule) {	2937	if (isModule) {
2911	if (!promise)	2938	if (!promise)
2912	promise = loadAndEvaluateModule(globalObject->globalExec(), jscSource(scriptBuffer, fileName));	2939	promise = loadAndEvaluateModule(globalObject->globalExec(), jscSource(scriptBuffer, absolutePath(fileName)));
2913	scope.clearException();	2940	scope.clearException();
2914		2941
2915	JSFunction* fulfillHandler = JSNativeStdFunction::create(vm, globalObject, 1, String(), [&, isLastFile](ExecState* exec) {	2942	JSFunction* fulfillHandler = JSNativeStdFunction::create(vm, globalObject, 1, String(), [&, isLastFile](ExecState* exec) {
Lines 2926-2932 static bool runWithScripts(GlobalObject* globalObject, const Vector<Script>& scr a/Source/JavaScriptCore/jsc.cpp_sec10
2926	vm.drainMicrotasks();	2953	vm.drainMicrotasks();
2927	} else {	2954	} else {
2928	NakedPtr<Exception> evaluationException;	2955	NakedPtr<Exception> evaluationException;
2929	JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(scriptBuffer, fileName), JSValue(), evaluationException);	2956	JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(scriptBuffer, absolutePath(fileName)), JSValue(), evaluationException);
2930	ASSERT(!scope.exception());	2957	ASSERT(!scope.exception());
2931	if (evaluationException)	2958	if (evaluationException)
2932	returnValue = evaluationException->value();	2959	returnValue = evaluationException->value();

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	auto* 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	auto* 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	2017-01-09 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 Saam Barati.
		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	2017-01-09 Beth Dakin <bdakin@apple.com>	10	2017-01-09 Beth Dakin <bdakin@apple.com>
2		11
3	Add a test to ensure that preventDefault on touchmove prevents scrolling	12	Add a test to ensure that preventDefault on touchmove prevents scrolling

Lines 1-3 a/JSTests/ChangeLog_sec1
- a/JSTests/ChangeLog +28 lines
		1	2017-01-09 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 Saam Barati.
		7
		8	* stress/import-basic.js: Added.
		9	(async.async.load):
		10	(async):
		11	(catch):
		12	* stress/import-from-eval.js: Added.
		13	(async):
		14	(catch):
		15	* stress/import-syntax.js: Added.
		16	(testSyntaxError):
		17	* stress/import-tests/cocoa.js: Added.
		18	(export.Cocoa):
		19	(export.hello):
		20	* stress/import-tests/multiple.js: Added.
		21	(export.result):
		22	* stress/import-tests/multiple2.js: Added.
		23	(export.ok):
		24	* stress/import-tests/should.js: Added.
		25	(export.shouldBe):
		26	(export.shouldThrow):
		27	* stress/modules-syntax-error.js:
		28
1	2017-01-06 Saam Barati <sbarati@apple.com>	29	2017-01-06 Saam Barati <sbarati@apple.com>
2		30
3	Add a slice intrinsic to the DFG/FTL	31	Add a slice intrinsic to the DFG/FTL

Line 0 a/JSTests/stress/import-basic.js_sec1
- a/JSTests/stress/import-basic.js +53 lines
	1	(async function () {
	2	const { shouldBe } = await import('./import-tests/should.js');
	3	{
	4	let a = await import('./import-tests/cocoa.js');
	5	let b = await import('./import-tests/cocoa.js');
	6	shouldBe(a, b);
	7	shouldBe(a.hello(), 42);
	8	}
	9
	10	{
	11	let a = await import('./import-tests/multiple.js');
	12	let a2 = await a.result();
	13	shouldBe(a !== a2, true);
	14	shouldBe(a2.ok(), 42);
	15	let a3 = await a.result();
	16	shouldBe(a2, a3);
	17	}
	18
	19	{
	20	let error = null;
	21	try {
	22	let a = await import({ toString() { throw new Error('out'); } });
	23	} catch (e) {
	24	error = e;
	25	}
	26	shouldBe(error !== null, true);
	27	shouldBe(String(error), `Error: out`);
	28	}
	29
	30	{
	31	async function load(cond) {
	32	if (cond)
	33	return import('./import-tests/cocoa.js');
	34	return undefined;
	35	}
	36
	37	let v = await load(false);
	38	shouldBe(v, undefined);
	39	let v2 = await load(true);
	40	let v3 = await import('./import-tests/cocoa.js');
	41	shouldBe(v2, v2);
	42	}
	43
	44	{
	45	let value = './import-tests/cocoa.js';
	46	let v = await import(value);
	47	let v2 = await import('./import-tests/cocoa.js');
	48	shouldBe(v, v2);
	49	}
	50	}()).catch((error) => {
	51	print(String(error));
	52	abort();
	53	});

Line 0 a/JSTests/stress/import-from-eval.js_sec1
- a/JSTests/stress/import-from-eval.js +36 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	}()).catch((error) => {
	34	print(String(error));
	35	abort();
	36	});

Line 0 a/JSTests/stress/import-syntax.js_sec1
- a/JSTests/stress/import-syntax.js +38 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 ')'. import call expects exactly one argument.`);
	16	testSyntaxError(`new import(`, `SyntaxError: Cannot use new with import.`);
	17	testSyntaxError(`import.hello()`, `SyntaxError: Unexpected token '.'. import call expects exactly one argument.`);
	18	testSyntaxError(`import[`, `SyntaxError: Unexpected token '['. import call expects exactly one argument.`);
	19	testSyntaxError(`import<`, `SyntaxError: Unexpected token '<'. import call expects exactly one argument.`);
	20
	21	testSyntaxError(`import()`, `SyntaxError: Unexpected token ')'`);
	22	testSyntaxError(`import(a, b)`, `SyntaxError: Unexpected token ','. import call expects exactly one argument.`);
	23	testSyntaxError(`import(a, b, c)`, `SyntaxError: Unexpected token ','. import call expects exactly one argument.`);
	24	testSyntaxError(`import(...a)`, `SyntaxError: Unexpected token '...'`);
	25	testSyntaxError(`import(,a)`, `SyntaxError: Unexpected token ','`);
	26	testSyntaxError(`import(,)`, `SyntaxError: Unexpected token ','`);
	27	testSyntaxError(`import("Hello";`, `SyntaxError: Unexpected token ';'. import call expects exactly one argument.`);
	28	testSyntaxError(`import("Hello"];`, `SyntaxError: Unexpected token ']'. import call expects exactly one argument.`);
	29	testSyntaxError(`import("Hello",;`, `SyntaxError: Unexpected token ','. import call expects exactly one argument.`);
	30	testSyntaxError(`import("Hello", "Hello2";`, `SyntaxError: Unexpected token ','. import call expects exactly one argument.`);
	31
	32
	33	testSyntaxError(`import = 42`, `SyntaxError: Unexpected token '='. import call expects exactly one argument.`);
	34	testSyntaxError(`[import] = 42`, `SyntaxError: Unexpected token ']'. import call expects exactly one argument.`);
	35	testSyntaxError(`{import} = 42`, `SyntaxError: Unexpected token '}'. import call expects exactly one argument.`);
	36	testSyntaxError(`let import = 42`, `SyntaxError: Unexpected keyword 'import'`);
	37	testSyntaxError(`var import = 42`, `SyntaxError: Cannot use the keyword 'import' as a variable name.`);
	38	testSyntaxError(`const import = 42`, `SyntaxError: Cannot use the keyword 'import' as a lexical variable name.`);

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	}