Attachment 276089 Details for Bug 156147 – Patch

[patch] Patch

bug-156147-20160409152300.patch (text/plain), 238.90 KB, created by Caitlin Potter (:caitp) on 2016-04-09 12:22:52 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Caitlin Potter (:caitp)

Created: 2016-04-09 12:22:52 PDT

Size: 238.90 KB

patch

obsolete

>Subversion Revision: 199269
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 2f27f32960c941a4f5ad0ae9876cc5d9a8f4af7c..325a67c0687b3b1015dfc70f7a9dc9fbe301d889 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,200 @@
>+2016-04-08  Caitlin Potter  <caitp@igalia.com>
>+
>+        [JSC] implement async functions proposal
>+        https://bugs.webkit.org/show_bug.cgi?id=156147
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Adds support for `async` functions, proposed in https://tc39.github.io/ecmascript-asyncawait/.
>+
>+        On the front-end side, "await" becomes a contextual keyword when used within an async function,
>+        which triggers parsing an AwaitExpression. "await" becomes an illegal identifier name within
>+        these contexts. The bytecode generated from an "await" expression is identical to that generated
>+        in a "yield" expression in a Generator, as AsyncFunction reuses generator's state machine mechanism.
>+
>+        There are numerous syntactic forms for language features, including a variation on ArrowFunctions,
>+        requiring the keyword `async` to precede ArrowFormalParameters, and similarly, MethodDefinitions,
>+        which are ordinary MethodDefinitions preceded by the keyword `async`.
>+
>+        An async function desugars to the following:
>+
>+        ```
>+        async function asyncFn() {
>+        }
>+
>+        becomes:
>+
>+        function asyncFn() {
>+            let generator = {
>+                @generatorNext: function(@generator, @generatorState, @generatorValue, @generatorResumeMode) {
>+                  // generator state machine stuff here
>+                },
>+                @generatorState: 0,
>+                @generatorThis: this,
>+                @generatorFrame: null
>+            };
>+            return @asyncFunctionResume(generator, undefined, GeneratorResumeMode::NormalMode);
>+        }
>+        ```
>+
>+        `@asyncFunctionResume()` is similar to `@generatorResume`, with the exception that it will wrap the
>+        result of invoking `@generatorNext()` in a Promise, and will avoid allocating an iterator result
>+        object.
>+
>+        If the generator has yielded (an AwaitExpression has occurred), resumption will occur automatically
>+        once the await-expression operand is finished, via Promise chaining.
>+
>+        * CMakeLists.txt:
>+        * DerivedSources.make:
>+        * JavaScriptCore.xcodeproj/project.pbxproj:
>+        * builtins/AsyncFunctionPrototype.js: Added.
>+        (asyncFunctionResume):
>+        * bytecode/BytecodeList.json:
>+        * bytecode/BytecodeUseDef.h:
>+        (JSC::computeUsesForBytecodeOffset):
>+        (JSC::computeDefsForBytecodeOffset):
>+        * bytecode/CodeBlock.cpp:
>+        (JSC::CodeBlock::dumpBytecode):
>+        (JSC::CodeBlock::finishCreation):
>+        * bytecode/UnlinkedCodeBlock.h:
>+        (JSC::UnlinkedCodeBlock::isAsyncArrowFunction):
>+        * bytecompiler/BytecodeGenerator.cpp:
>+        (JSC::BytecodeGenerator::BytecodeGenerator):
>+        (JSC::BytecodeGenerator::emitNewFunctionExpressionCommon):
>+        (JSC::BytecodeGenerator::emitNewArrowFunctionExpression):
>+        (JSC::BytecodeGenerator::emitNewMethodDefinition):
>+        (JSC::BytecodeGenerator::emitNewFunction):
>+        (JSC::BytecodeGenerator::emitLoadArrowFunctionLexicalEnvironment):
>+        * bytecompiler/BytecodeGenerator.h:
>+        (JSC::BytecodeGenerator::makeFunction):
>+        * bytecompiler/NodesCodegen.cpp:
>+        (JSC::FunctionNode::emitBytecode):
>+        * jit/JIT.cpp:
>+        (JSC::JIT::privateCompileMainPass):
>+        * jit/JIT.h:
>+        * jit/JITOpcodes.cpp:
>+        (JSC::JIT::emit_op_new_async_func):
>+        (JSC::JIT::emitNewFuncExprCommon):
>+        (JSC::JIT::emit_op_new_async_func_exp):
>+        * jit/JITOperations.cpp:
>+        * jit/JITOperations.h:
>+        * llint/LLIntSlowPaths.cpp:
>+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
>+        * llint/LLIntSlowPaths.h:
>+        * llint/LowLevelInterpreter.asm:
>+        * parser/Keywords.table:
>+        * parser/Lexer.cpp:
>+        (JSC::Lexer<T>::setCode):
>+        (JSC::Lexer<T>::lex):
>+        * parser/Lexer.h:
>+        (JSC::Lexer::prevToken):
>+        * parser/Parser.cpp:
>+        (JSC::Parser<LexerType>::Parser):
>+        (JSC::Parser<LexerType>::parseInner):
>+        (JSC::Parser<LexerType>::isArrowFunctionParameters):
>+        (JSC::Parser<LexerType>::parseAsyncFunctionSourceElements):
>+        (JSC::Parser<LexerType>::parseStatementListItem):
>+        (JSC::Parser<LexerType>::parseVariableDeclarationList):
>+        (JSC::Parser<LexerType>::parseDestructuringPattern):
>+        (JSC::Parser<LexerType>::parseStatement):
>+        (JSC::Parser<LexerType>::parseFormalParameters):
>+        (JSC::stringForFunctionMode):
>+        (JSC::Parser<LexerType>::parseFunctionParameters):
>+        (JSC::Parser<LexerType>::parseFunctionInfo):
>+        (JSC::Parser<LexerType>::parseAsyncFunctionDeclaration):
>+        (JSC::Parser<LexerType>::parseClass):
>+        (JSC::Parser<LexerType>::parseExpressionOrLabelStatement):
>+        (JSC::Parser<LexerType>::parseExportDeclaration):
>+        (JSC::Parser<LexerType>::parseAssignmentExpression):
>+        (JSC::Parser<LexerType>::parseAwaitExpression):
>+        (JSC::Parser<LexerType>::parseProperty):
>+        (JSC::Parser<LexerType>::parsePropertyMethod):
>+        (JSC::Parser<LexerType>::parseAsyncFunctionExpression):
>+        (JSC::Parser<LexerType>::parsePrimaryExpression):
>+        (JSC::Parser<LexerType>::parseMemberExpression):
>+        (JSC::Parser<LexerType>::parseArrowFunctionExpression):
>+        (JSC::Parser<LexerType>::parseUnaryExpression):
>+        (JSC::Parser<LexerType>::printUnexpectedTokenText):
>+        * parser/Parser.h:
>+        (JSC::isIdentifierOrKeyword):
>+        (JSC::Scope::Scope):
>+        (JSC::Scope::setSourceParseMode):
>+        (JSC::Scope::isAsyncFunction):
>+        (JSC::Scope::isAsyncFunctionBoundary):
>+        (JSC::Scope::isModule):
>+        (JSC::Scope::setIsFunction):
>+        (JSC::Scope::setIsAsyncArrowFunction):
>+        (JSC::Scope::setIsAsyncFunction):
>+        (JSC::Scope::setIsAsyncFunctionBody):
>+        (JSC::Scope::setIsAsyncArrowFunctionBody):
>+        (JSC::Parser::AllowAwaitOverride::AllowAwaitOverride):
>+        (JSC::Parser::AllowAwaitOverride::~AllowAwaitOverride):
>+        (JSC::Parser::ExpressionErrorClassifier::forceClassifyExpressionError):
>+        (JSC::Parser::ExpressionErrorClassifier::propagateExpressionErrorClass):
>+        (JSC::Parser::ExpressionErrorClassifier::indicatesPossibleArrowFunction):
>+        (JSC::Parser::ExpressionErrorClassifier::indicatesPossibleAsyncArrowFunction):
>+        (JSC::Parser::forceClassifyExpressionError):
>+        (JSC::Parser::declarationTypeToVariableKind):
>+        (JSC::Parser::closestParentOrdinaryFunctionNonLexicalScope):
>+        (JSC::Parser::pushScope):
>+        (JSC::Parser::popScopeInternal):
>+        (JSC::Parser::matchSpecIdentifier):
>+        (JSC::Parser::isDisallowedIdentifierAwait):
>+        (JSC::Parser::disallowedIdentifierAwaitReason):
>+        * parser/ParserModes.h:
>+        (JSC::isFunctionParseMode):
>+        (JSC::isAsyncFunctionParseMode):
>+        (JSC::isAsyncArrowFunctionParseMode):
>+        (JSC::isAsyncFunctionWrapperParseMode):
>+        (JSC::isAsyncFunctionBodyParseMode):
>+        (JSC::isModuleParseMode):
>+        (JSC::isProgramParseMode):
>+        * parser/ParserTokens.h:
>+        * runtime/AsyncFunctionConstructor.cpp: Added.
>+        (JSC::AsyncFunctionConstructor::AsyncFunctionConstructor):
>+        (JSC::AsyncFunctionConstructor::finishCreation):
>+        (JSC::callAsyncFunctionConstructor):
>+        (JSC::constructAsyncFunctionConstructor):
>+        (JSC::AsyncFunctionConstructor::getCallData):
>+        (JSC::AsyncFunctionConstructor::getConstructData):
>+        * runtime/AsyncFunctionConstructor.h: Added.
>+        (JSC::AsyncFunctionConstructor::create):
>+        (JSC::AsyncFunctionConstructor::createStructure):
>+        * runtime/AsyncFunctionPrototype.cpp: Added.
>+        (JSC::AsyncFunctionPrototype::AsyncFunctionPrototype):
>+        (JSC::AsyncFunctionPrototype::finishCreation):
>+        * runtime/AsyncFunctionPrototype.h: Added.
>+        (JSC::AsyncFunctionPrototype::create):
>+        (JSC::AsyncFunctionPrototype::createStructure):
>+        * runtime/CodeCache.cpp:
>+        (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
>+        * runtime/CommonIdentifiers.h:
>+        * runtime/FunctionConstructor.cpp:
>+        (JSC::constructFunctionSkippingEvalEnabledCheck):
>+        * runtime/FunctionConstructor.h:
>+        * runtime/JSAsyncFunction.cpp: Added.
>+        (JSC::JSAsyncFunction::JSAsyncFunction):
>+        (JSC::JSAsyncFunction::createImpl):
>+        (JSC::JSAsyncFunction::create):
>+        (JSC::JSAsyncFunction::createWithInvalidatedReallocationWatchpoint):
>+        * runtime/JSAsyncFunction.h: Added.
>+        (JSC::JSAsyncFunction::allocationSize):
>+        (JSC::JSAsyncFunction::createStructure):
>+        * runtime/JSGlobalObject.cpp:
>+        (JSC::JSGlobalObject::init):
>+        * runtime/JSGlobalObject.h:
>+        (JSC::JSGlobalObject::asyncFunctionPrototype):
>+        (JSC::JSGlobalObject::asyncFunctionStructure):
>+        * runtime/Options.h:
>+        * tests/es6.yaml:
>+        * tests/es6/async-await-basic.js: Added.
>+        * tests/es6/async-await-mozilla.js: Added.
>+        * tests/es6/async-await-reserved-word.js: Added.
>+        * tests/es6/async_arrow_functions_lexical_arguments_binding.js: Added.
>+        * tests/es6/async_arrow_functions_lexical_new.target_binding.js: Added.
>+        * tests/es6/async_arrow_functions_lexical_super_binding.js: Added.
>+        * tests/es6/async_arrow_functions_lexical_this_binding.js: Added.
>+
> 2016-04-08  Joseph Pecoraro  <pecoraro@apple.com>
> 
>         Web Inspector: XHRs and Web Worker scripts are not searchable
>diff --git a/Source/JavaScriptCore/API/JSScriptRef.cpp b/Source/JavaScriptCore/API/JSScriptRef.cpp
>index 60bde604e358516f1ef6caa23d8124892ccfa955..fca31f07c31aa63cbcbf8f1d5118cca87fb36cda 100644
>--- a/Source/JavaScriptCore/API/JSScriptRef.cpp
>+++ b/Source/JavaScriptCore/API/JSScriptRef.cpp
>@@ -75,7 +75,7 @@ private:
> static bool parseScript(VM* vm, const SourceCode& source, ParserError& error)
> {
>     return !!JSC::parse<JSC::ProgramNode>(
>-        vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
>+        vm, RuntimeFlags(), source, Identifier(), JSParserBuiltinMode::NotBuiltin,
>         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded,
>         error);
> }
>diff --git a/Source/JavaScriptCore/CMakeLists.txt b/Source/JavaScriptCore/CMakeLists.txt
>index 21f6a190b14924608ae1d97bf137f7f8041b9255..6a28986ade32daa5546ac1bff2de3166ee28efba 100644
>--- a/Source/JavaScriptCore/CMakeLists.txt
>+++ b/Source/JavaScriptCore/CMakeLists.txt
>@@ -610,6 +610,8 @@ set(JavaScriptCore_SOURCES
>     runtime/ArrayConstructor.cpp
>     runtime/ArrayIteratorPrototype.cpp
>     runtime/ArrayPrototype.cpp
>+    runtime/AsyncFunctionConstructor.cpp
>+    runtime/AsyncFunctionPrototype.cpp
>     runtime/BasicBlockLocation.cpp
>     runtime/BooleanConstructor.cpp
>     runtime/BooleanObject.cpp
>@@ -683,6 +685,7 @@ set(JavaScriptCore_SOURCES
>     runtime/JSArrayBufferPrototype.cpp
>     runtime/JSArrayBufferView.cpp
>     runtime/JSArrayIterator.cpp
>+    runtime/JSAsyncFunction.cpp
>     runtime/JSBoundFunction.cpp
>     runtime/JSBoundSlotBaseFunction.cpp
>     runtime/JSCJSValue.cpp
>@@ -1206,6 +1209,7 @@ set(JavaScriptCore_BUILTINS_SOURCES
>     ${JAVASCRIPTCORE_DIR}/builtins/ArrayConstructor.js
>     ${JAVASCRIPTCORE_DIR}/builtins/ArrayIteratorPrototype.js
>     ${JAVASCRIPTCORE_DIR}/builtins/ArrayPrototype.js
>+    ${JAVASCRIPTCORE_DIR}/builtins/AsyncFunctionPrototype.js
>     ${JAVASCRIPTCORE_DIR}/builtins/DatePrototype.js
>     ${JAVASCRIPTCORE_DIR}/builtins/FunctionPrototype.js
>     ${JAVASCRIPTCORE_DIR}/builtins/GeneratorPrototype.js
>diff --git a/Source/JavaScriptCore/DerivedSources.make b/Source/JavaScriptCore/DerivedSources.make
>index 3dd4a507201f6a76b685fee239d04bdb4a926bc2..f5100806d9cd833890f6829ec13790d2062aaf81 100644
>--- a/Source/JavaScriptCore/DerivedSources.make
>+++ b/Source/JavaScriptCore/DerivedSources.make
>@@ -84,6 +84,7 @@ JavaScriptCore_BUILTINS_SOURCES = \
>     $(JavaScriptCore)/builtins/ArrayConstructor.js \
>     $(JavaScriptCore)/builtins/ArrayIteratorPrototype.js \
>     $(JavaScriptCore)/builtins/ArrayPrototype.js \
>+    $(JavaScriptCore)/builtins/AsyncFunctionPrototype.js \
>     $(JavaScriptCore)/builtins/DatePrototype.js \
>     $(JavaScriptCore)/builtins/FunctionPrototype.js \
>     $(JavaScriptCore)/builtins/GeneratorPrototype.js \
>diff --git a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>index ff97a01dee8da87cb1bd5fd35ada99568ff8bcd0..0e8ba41ce13732c6ffc65177890e8e971fcdcb66 100644
>--- a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>+++ b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
>@@ -1184,6 +1184,12 @@
> 		5370B4F61BF26205005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 5370B4F41BF25EA2005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.h */; };
> 		53917E7B1B7906FA000EBD33 /* JSGenericTypedArrayViewPrototypeFunctions.h in Headers */ = {isa = PBXBuildFile; fileRef = 53917E7A1B7906E4000EBD33 /* JSGenericTypedArrayViewPrototypeFunctions.h */; };
> 		53F6BF6D1C3F060A00F41E5D /* InternalFunctionAllocationProfile.h in Headers */ = {isa = PBXBuildFile; fileRef = 53F6BF6C1C3F060A00F41E5D /* InternalFunctionAllocationProfile.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		5BD3A0671CAE325700F84BA3 /* AsyncFunctionConstructor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5BD3A0611CAE325700F84BA3 /* AsyncFunctionConstructor.cpp */; };
>+		5BD3A0681CAE325700F84BA3 /* AsyncFunctionConstructor.h in Headers */ = {isa = PBXBuildFile; fileRef = 5BD3A0621CAE325700F84BA3 /* AsyncFunctionConstructor.h */; };
>+		5BD3A0691CAE325700F84BA3 /* AsyncFunctionPrototype.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5BD3A0631CAE325700F84BA3 /* AsyncFunctionPrototype.cpp */; };
>+		5BD3A06A1CAE325700F84BA3 /* AsyncFunctionPrototype.h in Headers */ = {isa = PBXBuildFile; fileRef = 5BD3A0641CAE325700F84BA3 /* AsyncFunctionPrototype.h */; };
>+		5BD3A06B1CAE325700F84BA3 /* JSAsyncFunction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5BD3A0651CAE325700F84BA3 /* JSAsyncFunction.cpp */; };
>+		5BD3A06E1CAE35BF00F84BA3 /* JSAsyncFunction.h in Headers */ = {isa = PBXBuildFile; fileRef = 5BD3A06D1CAE35BF00F84BA3 /* JSAsyncFunction.h */; };
> 		5D53726F0E1C54880021E549 /* Tracing.h in Headers */ = {isa = PBXBuildFile; fileRef = 5D53726E0E1C54880021E549 /* Tracing.h */; };
> 		5D5D8AD10E0D0EBE00F9C692 /* libedit.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 5D5D8AD00E0D0EBE00F9C692 /* libedit.dylib */; };
> 		5DBB151B131D0B310056AD36 /* testapi.js in Copy Support Script */ = {isa = PBXBuildFile; fileRef = 14D857740A4696C80032146C /* testapi.js */; };
>@@ -3321,6 +3327,13 @@
> 		53F256E11B87E28000B4B768 /* JSTypedArrayViewPrototype.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSTypedArrayViewPrototype.cpp; sourceTree = "<group>"; };
> 		53F6BF6C1C3F060A00F41E5D /* InternalFunctionAllocationProfile.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InternalFunctionAllocationProfile.h; sourceTree = "<group>"; };
> 		593D43CCA0BBE06D89C59707 /* MapDataInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MapDataInlines.h; sourceTree = "<group>"; };
>+		5BD3A0611CAE325700F84BA3 /* AsyncFunctionConstructor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AsyncFunctionConstructor.cpp; sourceTree = "<group>"; };
>+		5BD3A0621CAE325700F84BA3 /* AsyncFunctionConstructor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AsyncFunctionConstructor.h; sourceTree = "<group>"; };
>+		5BD3A0631CAE325700F84BA3 /* AsyncFunctionPrototype.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AsyncFunctionPrototype.cpp; sourceTree = "<group>"; };
>+		5BD3A0641CAE325700F84BA3 /* AsyncFunctionPrototype.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AsyncFunctionPrototype.h; sourceTree = "<group>"; };
>+		5BD3A0651CAE325700F84BA3 /* JSAsyncFunction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSAsyncFunction.cpp; sourceTree = "<group>"; };
>+		5BD3A06D1CAE35BF00F84BA3 /* JSAsyncFunction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSAsyncFunction.h; sourceTree = "<group>"; };
>+		5BF474881CB1C5DB0002BAD7 /* AsyncFunctionPrototype.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; path = AsyncFunctionPrototype.js; sourceTree = "<group>"; };
> 		5D53726D0E1C546B0021E549 /* Tracing.d */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Tracing.d; sourceTree = "<group>"; };
> 		5D53726E0E1C54880021E549 /* Tracing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Tracing.h; sourceTree = "<group>"; };
> 		5D53727D0E1C55EC0021E549 /* TracingDtrace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TracingDtrace.h; sourceTree = "<group>"; };
>@@ -5496,6 +5509,12 @@
> 		7EF6E0BB0EB7A1EC0079AFAF /* runtime */ = {
> 			isa = PBXGroup;
> 			children = (
>+				5BD3A0611CAE325700F84BA3 /* AsyncFunctionConstructor.cpp */,
>+				5BD3A0621CAE325700F84BA3 /* AsyncFunctionConstructor.h */,
>+				5BD3A0631CAE325700F84BA3 /* AsyncFunctionPrototype.cpp */,
>+				5BD3A0641CAE325700F84BA3 /* AsyncFunctionPrototype.h */,
>+				5BD3A0651CAE325700F84BA3 /* JSAsyncFunction.cpp */,
>+				5BD3A06D1CAE35BF00F84BA3 /* JSAsyncFunction.h */,
> 				BCF605110E203EF800B9A64D /* ArgList.cpp */,
> 				BCF605120E203EF800B9A64D /* ArgList.h */,
> 				0FE0500C1AA9091100D33B33 /* ArgumentsMode.h */,
>@@ -6839,6 +6858,7 @@
> 		A7D8019F1880D66E0026C39B /* builtins */ = {
> 			isa = PBXGroup;
> 			children = (
>+				5BF474881CB1C5DB0002BAD7 /* AsyncFunctionPrototype.js */,
> 				A7D801A01880D66E0026C39B /* ArrayPrototype.js */,
> 				7CF9BC581B65D9A3009DB1EF /* ArrayConstructor.js */,
> 				7CF9BC591B65D9A3009DB1EF /* ArrayIteratorPrototype.js */,
>@@ -7152,6 +7172,7 @@
> 				0F426A4B1460CD6E00131F8F /* DataFormat.h in Headers */,
> 				0F2B66DF17B6B5AB00A7AE3F /* DataView.h in Headers */,
> 				BCD2034A0E17135E002C7E82 /* DateConstructor.h in Headers */,
>+				5BD3A0681CAE325700F84BA3 /* AsyncFunctionConstructor.h in Headers */,
> 				996B731A1BDA08D100331B84 /* DateConstructor.lut.h in Headers */,
> 				41359CF30FDD89AD00206180 /* DateConversion.h in Headers */,
> 				BC1166020E1997B4008066DD /* DateInstance.h in Headers */,
>@@ -7509,6 +7530,7 @@
> 				FE187A0D1C030D5C0038BBCA /* JITDivGenerator.h in Headers */,
> 				2AD8932B17E3868F00668276 /* HeapIterationScope.h in Headers */,
> 				A5339EC91BB4B4600054F005 /* HeapObserver.h in Headers */,
>+				5BD3A06A1CAE325700F84BA3 /* AsyncFunctionPrototype.h in Headers */,
> 				2A6F462617E959CE00C45C98 /* HeapOperation.h in Headers */,
> 				14F97447138C853E00DA1C67 /* HeapRootVisitor.h in Headers */,
> 				C24D31E3161CD695002AA4DB /* HeapStatistics.h in Headers */,
>@@ -8050,6 +8072,7 @@
> 				A7B601821639FD2A00372BA3 /* UnlinkedCodeBlock.h in Headers */,
> 				14142E511B796ECE00F4BF4B /* UnlinkedFunctionExecutable.h in Headers */,
> 				0F2E892C16D028AD009E4FD2 /* UnusedPointer.h in Headers */,
>+				5BD3A06E1CAE35BF00F84BA3 /* JSAsyncFunction.h in Headers */,
> 				99DA00B11BD5994E00F4575C /* UpdateContents.py in Headers */,
> 				0F963B3813FC6FE90002D9B2 /* ValueProfile.h in Headers */,
> 				0F426A481460CBB300131F8F /* ValueRecovery.h in Headers */,
>@@ -8633,6 +8656,7 @@
> 				0FEC858B1BDACDC70080FF74 /* AirStackSlot.cpp in Sources */,
> 				0FEC858D1BDACDC70080FF74 /* AirTmp.cpp in Sources */,
> 				0FEC85901BDACDC70080FF74 /* AirValidate.cpp in Sources */,
>+				5BD3A06B1CAE325700F84BA3 /* JSAsyncFunction.cpp in Sources */,
> 				147F39BD107EC37600427A48 /* ArgList.cpp in Sources */,
> 				0F743BAA16B88249009F9277 /* ARM64Disassembler.cpp in Sources */,
> 				86D3B2C310156BDE002865E7 /* ARMAssembler.cpp in Sources */,
>@@ -9247,6 +9271,7 @@
> 				0FF729AE166AD35C000F5BA3 /* ProfilerBytecodes.cpp in Sources */,
> 				0F13912916771C33009CCB07 /* ProfilerBytecodeSequence.cpp in Sources */,
> 				0FF729AF166AD35C000F5BA3 /* ProfilerCompilation.cpp in Sources */,
>+				5BD3A0671CAE325700F84BA3 /* AsyncFunctionConstructor.cpp in Sources */,
> 				0FF729B0166AD35C000F5BA3 /* ProfilerCompilationKind.cpp in Sources */,
> 				0FF729B1166AD35C000F5BA3 /* ProfilerCompiledBytecode.cpp in Sources */,
> 				0FF729B2166AD35C000F5BA3 /* ProfilerDatabase.cpp in Sources */,
>@@ -9380,6 +9405,7 @@
> 				0F919D2515853CE0004A4E7D /* Watchpoint.cpp in Sources */,
> 				1ACF7377171CA6FB00C9BB1E /* Weak.cpp in Sources */,
> 				14E84F9E14EE1ACC00D6D5D4 /* WeakBlock.cpp in Sources */,
>+				5BD3A0691CAE325700F84BA3 /* AsyncFunctionPrototype.cpp in Sources */,
> 				14F7256514EE265E00B1652B /* WeakHandleOwner.cpp in Sources */,
> 				A7CA3AE317DA41AE006538AF /* WeakMapConstructor.cpp in Sources */,
> 				0F338DF91BE96AA80013C88F /* B3CCallValue.cpp in Sources */,
>diff --git a/Source/JavaScriptCore/builtins/AsyncFunctionPrototype.js b/Source/JavaScriptCore/builtins/AsyncFunctionPrototype.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..b82f2698888e21fb07492e50888dec0ef1cf3e16
>--- /dev/null
>+++ b/Source/JavaScriptCore/builtins/AsyncFunctionPrototype.js
>@@ -0,0 +1,56 @@
>+/*
>+ * Copyright (C) 2015 Caitlin Potter <caitp@igalia.com>.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+function asyncFunctionResume(generator, sentValue, resumeMode)
>+{
>+    "use strict";
>+    const Completed = -1;
>+    const Executing = -2;
>+
>+    const NormalMode = 0;
>+    const ThrowMode = 2;
>+
>+    let state = generator.@generatorState;
>+    let value = @undefined;
>+
>+    if (state === Completed || (resumeMode !== NormalMode && resumeMode !== ThrowMode))
>+        throw new @TypeError("Async function illegally resumed");
>+
>+    try {
>+        generator.@generatorState = Executing;
>+        value = generator.@generatorNext.@call(generator.@generatorThis, generator, state, sentValue, resumeMode);
>+        if (generator.@generatorState === Executing) {
>+            generator.@generatorState = Completed;
>+            return @Promise.@resolve(value);
>+        }
>+    } catch (error) {
>+        generator.@generatorState = Completed;
>+        return @Promise.@reject(error);
>+    }
>+
>+    return @Promise.@resolve(value).@then(
>+        function(value) { return @asyncFunctionResume(generator, value, /* NormalMode */ 0); },
>+        function(error) { return @asyncFunctionResume(generator, error, /* ThrowMode */ 2); });
>+}
>diff --git a/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp b/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp
>index 4c43b04629bac98d7b1bd4915f0342c7fbf26036..048930313706b87aa0f98d5a377fd69e1310b679 100644
>--- a/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp
>+++ b/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp
>@@ -79,7 +79,7 @@ UnlinkedFunctionExecutable* BuiltinExecutables::createExecutable(VM& vm, const S
>     UnlinkedFunctionKind kind = isParsingDefaultConstructor ? UnlinkedNormalFunction : UnlinkedBuiltinFunction;
>     RefPtr<SourceProvider> sourceOverride = isParsingDefaultConstructor ? source.provider() : nullptr;
>     std::unique_ptr<ProgramNode> program = parse<ProgramNode>(
>-        &vm, source, Identifier(), builtinMode,
>+        &vm, RuntimeFlags(), source, Identifier(), builtinMode,
>         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded, error,
>         &positionBeforeLastNewline, constructorKind);
> 
>diff --git a/Source/JavaScriptCore/bytecode/BytecodeList.json b/Source/JavaScriptCore/bytecode/BytecodeList.json
>index e8eb9b6bde484c1701590c1aaf92cc0d46ab755e..f17c2e68970046ab380e1ff4f1df640e1814be8e 100644
>--- a/Source/JavaScriptCore/bytecode/BytecodeList.json
>+++ b/Source/JavaScriptCore/bytecode/BytecodeList.json
>@@ -94,6 +94,8 @@
>             { "name" : "op_new_func_exp", "length" : 4 },
>             { "name" : "op_new_generator_func", "length" : 4 },
>             { "name" : "op_new_generator_func_exp", "length" : 4 },
>+            { "name" : "op_new_async_func", "length" : 4 },
>+            { "name" : "op_new_async_func_exp", "length" : 4 },
>             { "name" : "op_new_arrow_func_exp", "length" : 4 },
>             { "name" : "op_set_function_name", "length" : 3 },
>             { "name" : "op_call", "length" : 9 },
>diff --git a/Source/JavaScriptCore/bytecode/BytecodeUseDef.h b/Source/JavaScriptCore/bytecode/BytecodeUseDef.h
>index 33c04a879fc783b359c78aa1126af56259d616f4..60b36aacc1210b825ebd39560a2254aa0807a0b8 100644
>--- a/Source/JavaScriptCore/bytecode/BytecodeUseDef.h
>+++ b/Source/JavaScriptCore/bytecode/BytecodeUseDef.h
>@@ -136,6 +136,7 @@ void computeUsesForBytecodeOffset(
>     case op_get_property_enumerator:
>     case op_get_enumerable_length:
>     case op_new_func_exp:
>+    case op_new_async_func_exp:
>     case op_new_generator_func_exp:
>     case op_new_arrow_func_exp:
>     case op_to_index_string:
>@@ -166,6 +167,7 @@ void computeUsesForBytecodeOffset(
>     case op_del_by_id:
>     case op_unsigned:
>     case op_new_func:
>+    case op_new_async_func:
>     case op_new_generator_func:
>     case op_get_parent_scope:
>     case op_create_scoped_arguments:
>@@ -357,6 +359,8 @@ void computeDefsForBytecodeOffset(CodeBlock* codeBlock, BytecodeBasicBlock* bloc
>     case op_new_regexp:
>     case op_new_func:
>     case op_new_func_exp:
>+    case op_new_async_func:
>+    case op_new_async_func_exp:
>     case op_new_generator_func:
>     case op_new_generator_func_exp:
>     case op_new_arrow_func_exp:
>diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.cpp b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
>index 73b87bdb3bd18bcd656a06e2fdf3086cc30b5164..75d220530a8de04202a525a13ce6058d436c3d08 100644
>--- a/Source/JavaScriptCore/bytecode/CodeBlock.cpp
>+++ b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
>@@ -1363,6 +1363,22 @@ void CodeBlock::dumpBytecode(
>             out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
>             break;
>         }
>+        case op_new_async_func: {
>+            int r0 = (++it)->u.operand;
>+            int r1 = (++it)->u.operand;
>+            int f0 = (++it)->u.operand;
>+            printLocationAndOp(out, exec, location, it, "new_async_func");
>+            out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
>+            break;
>+        }
>+        case op_new_async_func_exp: {
>+            int r0 = (++it)->u.operand;
>+            int r1 = (++it)->u.operand;
>+            int f0 = (++it)->u.operand;
>+            printLocationAndOp(out, exec, location, it, "new_async_func_exp");
>+            out.printf("%s, %s, f%d", registerName(r0).data(), registerName(r1).data(), f0);
>+            break;
>+        }
>         case op_new_arrow_func_exp: {
>             int r0 = (++it)->u.operand;
>             int r1 = (++it)->u.operand;
>@@ -2321,7 +2337,7 @@ void CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, Unlink
>     m_instructions = WTFMove(instructions);
> 
>     // Perform bytecode liveness analysis to determine which locals are live and should be resumed when executing op_resume.
>-    if (unlinkedCodeBlock->parseMode() == SourceParseMode::GeneratorBodyMode) {
>+    if (unlinkedCodeBlock->parseMode() == SourceParseMode::GeneratorBodyMode || isAsyncFunctionBodyParseMode(unlinkedCodeBlock->parseMode())) {
>         if (size_t count = mergePointBytecodeOffsets.size()) {
>             createRareDataIfNecessary();
>             BytecodeLivenessAnalysis liveness(this);
>diff --git a/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h b/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h
>index c69872a8095f2ad8af61e2313c9995e36e87ff96..329aae6b1ee0227ac82a34dde438f49086396d4a 100644
>--- a/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h
>+++ b/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h
>@@ -119,6 +119,7 @@ public:
>     bool usesEval() const { return m_usesEval; }
>     SourceParseMode parseMode() const { return m_parseMode; }
>     bool isArrowFunction() const { return m_parseMode == SourceParseMode::ArrowFunctionMode; }
>+    bool isAsyncArrowFunction() const { return m_parseMode == SourceParseMode::AsyncArrowFunctionMode; }
>     DerivedContextType derivedContextType() const { return static_cast<DerivedContextType>(m_derivedContextType); }
>     EvalContextType evalContextType() const { return static_cast<EvalContextType>(m_evalContextType); }
>     bool isArrowFunctionContext() const { return m_isArrowFunctionContext; }
>diff --git a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp
>index 834c467769ac8157997abcc326d43a0b8c4a60b5..2b6ec3f279874b055f47f36f83a1f04be46e6e92 100644
>--- a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp
>+++ b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp
>@@ -48,7 +48,7 @@ static_assert(sizeof(UnlinkedFunctionExecutable) <= 256, "UnlinkedFunctionExecut
> const ClassInfo UnlinkedFunctionExecutable::s_info = { "UnlinkedFunctionExecutable", 0, 0, CREATE_METHOD_TABLE(UnlinkedFunctionExecutable) };
> 
> static UnlinkedFunctionCodeBlock* generateUnlinkedFunctionCodeBlock(
>-    VM& vm, UnlinkedFunctionExecutable* executable, const SourceCode& source,
>+    VM& vm, const RuntimeFlags& runtimeFlags, UnlinkedFunctionExecutable* executable, const SourceCode& source,
>     CodeSpecializationKind kind, DebuggerMode debuggerMode, ProfilerMode profilerMode,
>     UnlinkedFunctionKind functionKind, ParserError& error, SourceParseMode parseMode)
> {
>@@ -56,7 +56,7 @@ static UnlinkedFunctionCodeBlock* generateUnlinkedFunctionCodeBlock(
>     JSParserStrictMode strictMode = executable->isInStrictContext() ? JSParserStrictMode::Strict : JSParserStrictMode::NotStrict;
>     ASSERT(isFunctionParseMode(executable->parseMode()));
>     std::unique_ptr<FunctionNode> function = parse<FunctionNode>(
>-        &vm, source, executable->name(), builtinMode, strictMode, executable->parseMode(), executable->superBinding(), error, nullptr);
>+        &vm, runtimeFlags, source, executable->name(), builtinMode, strictMode, executable->parseMode(), executable->superBinding(), error, nullptr);
> 
>     if (!function) {
>         ASSERT(error.isValid());
>@@ -175,7 +175,7 @@ UnlinkedFunctionExecutable* UnlinkedFunctionExecutable::fromGlobalCode(
>     ParserError error;
>     VM& vm = exec.vm();
>     CodeCache* codeCache = vm.codeCache();
>-    UnlinkedFunctionExecutable* executable = codeCache->getFunctionExecutableFromGlobalCode(vm, name, source, error);
>+    UnlinkedFunctionExecutable* executable = codeCache->getFunctionExecutableFromGlobalCode(vm, exec.lexicalGlobalObject()->runtimeFlags(), name, source, error);
> 
>     auto& globalObject = *exec.lexicalGlobalObject();
>     if (globalObject.hasDebugger())
>@@ -190,7 +190,7 @@ UnlinkedFunctionExecutable* UnlinkedFunctionExecutable::fromGlobalCode(
> }
> 
> UnlinkedFunctionCodeBlock* UnlinkedFunctionExecutable::unlinkedCodeBlockFor(
>-    VM& vm, const SourceCode& source, CodeSpecializationKind specializationKind, 
>+    VM& vm, const RuntimeFlags& runtimeFlags, const SourceCode& source, CodeSpecializationKind specializationKind, 
>     DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error, SourceParseMode parseMode)
> {
>     switch (specializationKind) {
>@@ -205,7 +205,7 @@ UnlinkedFunctionCodeBlock* UnlinkedFunctionExecutable::unlinkedCodeBlockFor(
>     }
> 
>     UnlinkedFunctionCodeBlock* result = generateUnlinkedFunctionCodeBlock(
>-        vm, this, source, specializationKind, debuggerMode, profilerMode, 
>+        vm, runtimeFlags, this, source, specializationKind, debuggerMode, profilerMode, 
>         isBuiltinFunction() ? UnlinkedBuiltinFunction : UnlinkedNormalFunction, 
>         error, parseMode);
>     
>diff --git a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
>index 697f12c2ea41b66a9af63995ee0de41be103c53c..b3a9aa798ea3c8410537497b39ff95a1789450c0 100644
>--- a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
>+++ b/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h
>@@ -50,6 +50,7 @@ namespace JSC {
> class FunctionMetadataNode;
> class FunctionExecutable;
> class ParserError;
>+class RuntimeFlags;
> class SourceCode;
> class SourceProvider;
> class UnlinkedFunctionCodeBlock;
>@@ -101,7 +102,7 @@ public:
>     void setInvalidTypeProfilingOffsets();
> 
>     UnlinkedFunctionCodeBlock* unlinkedCodeBlockFor(
>-        VM&, const SourceCode&, CodeSpecializationKind, DebuggerMode, ProfilerMode, 
>+        VM&, const RuntimeFlags&, const SourceCode&, CodeSpecializationKind, DebuggerMode, ProfilerMode, 
>         ParserError&, SourceParseMode);
> 
>     static UnlinkedFunctionExecutable* fromGlobalCode(
>diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
>index 11cf73ca233bab918648358883a63699c9c76286..bf11a040ec4328f6e714407ac526eaf74b1b242a 100644
>--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
>+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
>@@ -32,6 +32,7 @@
> #include "BytecodeGenerator.h"
> 
> #include "BuiltinExecutables.h"
>+#include "BuiltinNames.h"
> #include "BytecodeLivenessAnalysis.h"
> #include "Interpreter.h"
> #include "JSFunction.h"
>@@ -241,17 +242,17 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
> 
>     SourceParseMode parseMode = codeBlock->parseMode();
> 
>-    bool containsArrowOrEvalButNotInArrowBlock = ((functionNode->usesArrowFunction() && functionNode->doAnyInnerArrowFunctionsUseAnyFeature()) || functionNode->usesEval()) && !m_codeBlock->isArrowFunction();
>+    bool containsArrowOrEvalButNotInArrowBlock = ((functionNode->usesArrowFunction() && functionNode->doAnyInnerArrowFunctionsUseAnyFeature()) || functionNode->usesEval()) && (!m_codeBlock->isArrowFunction() && !m_codeBlock->isAsyncArrowFunction());
>     bool shouldCaptureSomeOfTheThings = m_shouldEmitDebugHooks || functionNode->needsActivation() || containsArrowOrEvalButNotInArrowBlock;
> 
>     bool shouldCaptureAllOfTheThings = m_shouldEmitDebugHooks || codeBlock->usesEval();
>-    bool needsArguments = (functionNode->usesArguments() || codeBlock->usesEval() || (functionNode->usesArrowFunction() && !codeBlock->isArrowFunction() && isArgumentsUsedInInnerArrowFunction()));
>+    bool needsArguments = (functionNode->usesArguments() || codeBlock->usesEval() || (functionNode->usesArrowFunction() && !codeBlock->isArrowFunction() && !codeBlock->isAsyncArrowFunction() && isArgumentsUsedInInnerArrowFunction()));
> 
>-    // Generator never provides "arguments". "arguments" reference will be resolved in an upper generator function scope.
>-    if (parseMode == SourceParseMode::GeneratorBodyMode)
>+    // Generator and AsyncFunction never provides "arguments". "arguments" reference will be resolved in an upper generator function scope.
>+    if (parseMode == SourceParseMode::GeneratorBodyMode || isAsyncFunctionBodyParseMode(parseMode))
>         needsArguments = false;
> 
>-    if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode && needsArguments) {
>+    if ((parseMode == SourceParseMode::GeneratorWrapperFunctionMode || isAsyncFunctionWrapperParseMode(parseMode)) && needsArguments) {
>         // Generator does not provide "arguments". Instead, wrapping GeneratorFunction provides "arguments".
>         // This is because arguments of a generator should be evaluated before starting it.
>         // To workaround it, we evaluate these arguments as arguments of a wrapping generator function, and reference it from a generator.
>@@ -298,7 +299,7 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
>     ASSERT(!(isSimpleParameterList && m_restParameter));
> 
>     // Before emitting a scope creation, emit a generator prologue that contains jump based on a generator's state.
>-    if (parseMode == SourceParseMode::GeneratorBodyMode) {
>+    if (parseMode == SourceParseMode::GeneratorBodyMode || isAsyncFunctionBodyParseMode(parseMode)) {
>         m_generatorRegister = &m_parameters[1];
> 
>         // Jump with switch_imm based on @generatorState. We don't take the coroutine styled generator implementation.
>@@ -313,6 +314,8 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
> 
>     if (functionNameIsInScope(functionNode->ident(), functionNode->functionMode())) {
>         ASSERT(parseMode != SourceParseMode::GeneratorBodyMode);
>+        ASSERT(parseMode != SourceParseMode::AsyncFunctionBodyMode);
>+        ASSERT(parseMode != SourceParseMode::AsyncArrowFunctionBodyMode);
>         bool isDynamicScope = functionNameScopeIsDynamic(codeBlock->usesEval(), codeBlock->isStrictMode());
>         bool isFunctionNameCaptured = captures(functionNode->ident().impl());
>         bool markAsCaptured = isDynamicScope || isFunctionNameCaptured;
>@@ -501,7 +504,7 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
>         }
> 
>         // Do not create arguments variable in case of Arrow function. Value will be loaded from parent scope
>-        if (!haveParameterNamedArguments && !m_codeBlock->isArrowFunction()) {
>+        if (!haveParameterNamedArguments && !m_codeBlock->isArrowFunction() && !m_codeBlock->isAsyncArrowFunction()) {
>             createVariable(
>                 propertyNames().arguments, varKind(propertyNames().arguments.impl()), functionSymbolTable);
> 
>@@ -527,6 +530,31 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
>         break;
>     }
> 
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncFunctionMode: {
>+        ASSERT(!isConstructor());
>+        ASSERT(constructorKind() == ConstructorKind::None);
>+        m_generatorRegister = addVar();
>+
>+        if (parseMode != SourceParseMode::AsyncArrowFunctionMode) {
>+            if (functionNode->usesThis() || codeBlock->usesEval()) {
>+                m_codeBlock->addPropertyAccessInstruction(instructions().size());
>+                emitOpcode(op_to_this);
>+                instructions().append(kill(&m_thisRegister));
>+                instructions().append(0);
>+                instructions().append(0);
>+            }
>+
>+            emitMove(m_generatorRegister, &m_calleeRegister);
>+            emitCreateThis(m_generatorRegister);
>+        } else
>+            emitMove(m_generatorRegister, &m_calleeRegister);
>+        break;
>+    }
>+
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>     case SourceParseMode::GeneratorBodyMode: {
>         // |this| is already filled correctly before here.
>         emitLoad(m_newTargetRegister, jsUndefined());
>@@ -558,20 +586,54 @@ BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, Unlinke
>     // All "addVar()"s needs to happen before "initializeDefaultParameterValuesAndSetupFunctionScopeStack()" is called
>     // because a function's default parameter ExpressionNodes will use temporary registers.
>     pushTDZVariables(*parentScopeTDZVariables, TDZCheckOptimization::DoNotOptimize);
>+
>+    TryData* tryFormalParametersData = nullptr;
>+    if (isAsyncFunctionWrapperParseMode(parseMode)) {
>+        RefPtr<Label> tryFormalParametersStart = emitLabel(newLabel().get());
>+        tryFormalParametersData = pushTry(tryFormalParametersStart.get());
>+    }
>+
>     initializeDefaultParameterValuesAndSetupFunctionScopeStack(parameters, isSimpleParameterList, functionNode, functionSymbolTable, symbolTableConstantIndex, captures);
>-    
>+
>+    if (isAsyncFunctionWrapperParseMode(parseMode)) {
>+        RefPtr<Label> didNotThrow = newLabel();
>+        emitJump(didNotThrow.get());
>+        RefPtr<RegisterID> exception = newTemporary();
>+        RefPtr<RegisterID> thrownValue = newTemporary();
>+        RefPtr<Label> catchHere = emitLabel(newLabel().get());
>+        popTryAndEmitCatch(tryFormalParametersData, exception.get(), thrownValue.get(), catchHere.get(), HandlerType::Catch);
>+
>+        // return @Promise.@reject(thrownValue);
>+        Variable promiseVar = variable(m_vm->propertyNames->PromisePrivateName);
>+        RefPtr<RegisterID> scope = emitResolveScope(newTemporary(), promiseVar);
>+        RefPtr<RegisterID> promiseConstructor = emitGetFromScope(newTemporary(), scope.get(), promiseVar, ResolveMode::ThrowIfNotFound);
>+        RefPtr<RegisterID> promiseReject = emitGetById(newTemporary(), promiseConstructor.get(), m_vm->propertyNames->builtinNames().rejectPrivateName());
>+
>+        CallArguments args(*this, nullptr, 1);
>+
>+        emitMove(args.thisRegister(), promiseConstructor.get());
>+        emitMove(args.argumentRegister(0), thrownValue.get());
>+
>+        JSTextPosition divot(functionNode->firstLine(), functionNode->startOffset(), functionNode->lineStartOffset());
>+
>+        RefPtr<RegisterID> result = emitCall(newTemporary(), promiseReject.get(), NoExpectedFunction, args, divot, divot, divot);
>+        emitReturn(result.get());
>+
>+        emitLabel(didNotThrow.get());
>+    }
>+
>     // Loading |this| inside an arrow function must be done after initializeDefaultParameterValuesAndSetupFunctionScopeStack()
>     // because that function sets up the SymbolTable stack and emitLoadThisFromArrowFunctionLexicalEnvironment()
>     // consults the SymbolTable stack
>-    if (SourceParseMode::ArrowFunctionMode == parseMode) {
>-        if (functionNode->usesThis() || functionNode->usesSuperProperty())
>+    if (SourceParseMode::ArrowFunctionMode == parseMode || SourceParseMode::AsyncArrowFunctionBodyMode == parseMode || SourceParseMode::AsyncArrowFunctionMode == parseMode || SourceParseMode::AsyncArrowFunctionMode == parseMode) {
>+        if (functionNode->usesThis() || functionNode->usesSuperProperty() || isSuperUsedInInnerArrowFunction())
>             emitLoadThisFromArrowFunctionLexicalEnvironment();
>     
>         if (m_scopeNode->usesNewTarget() || m_scopeNode->usesSuperCall())
>             emitLoadNewTargetFromArrowFunctionLexicalEnvironment();
>     }
>     
>-    if (needsToUpdateArrowFunctionContext() && !codeBlock->isArrowFunction()) {
>+    if (needsToUpdateArrowFunctionContext() && !codeBlock->isArrowFunction() && !codeBlock->isAsyncArrowFunction()) {
>         initializeArrowFunctionContextScopeIfNeeded(functionSymbolTable);
>         emitPutThisToArrowFunctionContextScope();
>         emitPutNewTargetToArrowFunctionContextScope();
>@@ -2811,6 +2873,11 @@ void BytecodeGenerator::emitNewFunctionExpressionCommon(RegisterID* dst, Functio
>     default: {
>         break;
>     }
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+        opcodeID = op_new_async_func_exp;
>+        break;
>     }
>     
>     emitOpcode(opcodeID);
>@@ -2827,7 +2894,7 @@ RegisterID* BytecodeGenerator::emitNewFunctionExpression(RegisterID* dst, FuncEx
> 
> RegisterID* BytecodeGenerator::emitNewArrowFunctionExpression(RegisterID* dst, ArrowFuncExprNode* func)
> {
>-    ASSERT(func->metadata()->parseMode() == SourceParseMode::ArrowFunctionMode);
>+    ASSERT(func->metadata()->parseMode() == SourceParseMode::ArrowFunctionMode || func->metadata()->parseMode() == SourceParseMode::AsyncArrowFunctionMode);
>     emitNewFunctionExpressionCommon(dst, func->metadata());
>     return dst;
> }
>@@ -2837,7 +2904,8 @@ RegisterID* BytecodeGenerator::emitNewMethodDefinition(RegisterID* dst, MethodDe
>     ASSERT(func->metadata()->parseMode() == SourceParseMode::GeneratorWrapperFunctionMode
>         || func->metadata()->parseMode() == SourceParseMode::GetterMode
>         || func->metadata()->parseMode() == SourceParseMode::SetterMode
>-        || func->metadata()->parseMode() == SourceParseMode::MethodMode);
>+        || func->metadata()->parseMode() == SourceParseMode::MethodMode
>+        || func->metadata()->parseMode() == SourceParseMode::AsyncMethodMode);
>     emitNewFunctionExpressionCommon(dst, func->metadata());
>     return dst;
> }
>@@ -2864,6 +2932,8 @@ RegisterID* BytecodeGenerator::emitNewFunction(RegisterID* dst, FunctionMetadata
>     unsigned index = m_codeBlock->addFunctionDecl(makeFunction(function));
>     if (function->parseMode() == SourceParseMode::GeneratorWrapperFunctionMode)
>         emitOpcode(op_new_generator_func);
>+    else if (function->parseMode() == SourceParseMode::AsyncFunctionMode)
>+        emitOpcode(op_new_async_func);
>     else
>         emitOpcode(op_new_func);
>     instructions().append(dst->index());
>@@ -4174,7 +4244,7 @@ void BytecodeGenerator::popIndexedForInScope(RegisterID* localRegister)
> 
> RegisterID* BytecodeGenerator::emitLoadArrowFunctionLexicalEnvironment(const Identifier& identifier)
> {
>-    ASSERT(m_codeBlock->isArrowFunction() || m_codeBlock->isArrowFunctionContext() || constructorKind() == ConstructorKind::Derived || m_codeType == EvalCode);
>+    ASSERT(m_codeBlock->isArrowFunction() || parseMode() == SourceParseMode::AsyncArrowFunctionBodyMode || parseMode() == SourceParseMode::AsyncArrowFunctionMode || m_codeBlock->isArrowFunctionContext() || constructorKind() == ConstructorKind::Derived || m_codeType == EvalCode);
> 
>     return emitResolveScope(nullptr, variable(identifier, ThisResolutionType::Scoped));
> }
>diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
>index 81cc5264d58eaf66d94e49b56d880463511f72e2..3275c5f87a5b6d9f174f5addd2e29815edf7ab62 100644
>--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
>+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
>@@ -812,7 +812,7 @@ namespace JSC {
>         {
>             DerivedContextType newDerivedContextType = DerivedContextType::None;
> 
>-            if (metadata->parseMode() == SourceParseMode::ArrowFunctionMode) {
>+            if (metadata->parseMode() == SourceParseMode::ArrowFunctionMode || metadata->parseMode() == SourceParseMode::AsyncArrowFunctionMode) {
>                 if (constructorKind() == ConstructorKind::Derived || isDerivedConstructorContext())
>                     newDerivedContextType = DerivedContextType::DerivedConstructorContext;
>                 else if (m_codeBlock->isClassContext() || isDerivedClassContext())
>@@ -826,7 +826,7 @@ namespace JSC {
>             // https://bugs.webkit.org/show_bug.cgi?id=151547
>             SourceParseMode parseMode = metadata->parseMode();
>             ConstructAbility constructAbility = ConstructAbility::CanConstruct;
>-            if (parseMode == SourceParseMode::GetterMode || parseMode == SourceParseMode::SetterMode || parseMode == SourceParseMode::ArrowFunctionMode || parseMode == SourceParseMode::GeneratorWrapperFunctionMode)
>+            if (parseMode == SourceParseMode::GetterMode || parseMode == SourceParseMode::SetterMode || parseMode == SourceParseMode::ArrowFunctionMode || parseMode == SourceParseMode::GeneratorWrapperFunctionMode || isAsyncFunctionParseMode(parseMode))
>                 constructAbility = ConstructAbility::CannotConstruct;
>             else if (parseMode == SourceParseMode::MethodMode && metadata->constructorKind() == ConstructorKind::None)
>                 constructAbility = ConstructAbility::CannotConstruct;
>diff --git a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
>index 2bb05ca49de6ee120488d75e7025ecea45056a15..1784a0139a3b75457e7fb6763bdd86fb2c79f6d0 100644
>--- a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
>+++ b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
>@@ -3113,6 +3113,67 @@ void FunctionNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
>         break;
>     }
> 
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncArrowFunctionMode: {
>+        StatementNode* singleStatement = this->singleStatement();
>+        ASSERT(singleStatement->isExprStatement());
>+        ExprStatementNode* exprStatement = static_cast<ExprStatementNode*>(singleStatement);
>+        ExpressionNode* expr = exprStatement->expr();
>+        ASSERT(expr->isFuncExprNode());
>+        FuncExprNode* funcExpr = static_cast<FuncExprNode*>(expr);
>+
>+        RefPtr<RegisterID> next = generator.newTemporary();
>+        generator.emitNode(next.get(), funcExpr);
>+
>+        if (generator.superBinding() == SuperBinding::Needed || generator.parseMode() == SourceParseMode::AsyncArrowFunctionMode) {
>+            // FIXME: Don't always load home object for async arrows
>+            RefPtr<RegisterID> homeObject = emitHomeObjectForCallee(generator);
>+            emitPutHomeObject(generator, next.get(), homeObject.get());
>+        }
>+
>+        // FIXME: Currently, we just create an object and store generator related fields as its properties for ease.
>+        // But to make it efficient, we will introduce JSGenerator class, add opcode new_generator and use its C++ fields instead of these private properties.
>+        // https://bugs.webkit.org/show_bug.cgi?id=151545
>+
>+        generator.emitDirectPutById(generator.generatorRegister(), generator.propertyNames().generatorNextPrivateName, next.get(), PropertyNode::KnownDirect);
>+
>+        generator.emitDirectPutById(generator.generatorRegister(), generator.propertyNames().generatorThisPrivateName, generator.thisRegister(), PropertyNode::KnownDirect);
>+
>+        RegisterID* initialState = generator.emitLoad(nullptr, jsNumber(0));
>+        generator.emitDirectPutById(generator.generatorRegister(), generator.propertyNames().generatorStatePrivateName, initialState, PropertyNode::KnownDirect);
>+
>+        generator.emitDirectPutById(generator.generatorRegister(), generator.propertyNames().generatorFramePrivateName, generator.emitLoad(nullptr, jsNull()), PropertyNode::KnownDirect);
>+
>+        ASSERT(startOffset() >= lineStartOffset());
>+        generator.emitDebugHook(WillLeaveCallFrame, lastLine(), startOffset(), lineStartOffset());
>+
>+        // load @asyncFunctionResume, and call.
>+        RefPtr<RegisterID> startAsyncFunction = generator.newTemporary();
>+        auto var = generator.variable(generator.propertyNames().builtinNames().asyncFunctionResumePrivateName());
>+
>+        RefPtr<RegisterID> scope = generator.newTemporary();
>+        generator.moveToDestinationIfNeeded(scope.get(), generator.emitResolveScope(scope.get(), var));
>+        generator.emitGetFromScope(startAsyncFunction.get(), scope.get(), var, ThrowIfNotFound);
>+
>+        // return @asyncFunctionResume.@call(this, @generator, @undefined, GeneratorResumeMode::NormalMode)
>+        CallArguments args(generator, nullptr, 3);
>+        unsigned argumentCount = 0;
>+        generator.emitLoad(args.thisRegister(), jsUndefined());
>+        generator.emitMove(args.argumentRegister(argumentCount++), generator.generatorRegister());
>+        generator.emitLoad(args.argumentRegister(argumentCount++), jsUndefined());
>+        generator.emitLoad(args.argumentRegister(argumentCount++), jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::NormalMode)));
>+        // JSTextPosition(int _line, int _offset, int _lineStartOffset)
>+        JSTextPosition divot(firstLine(), startOffset(), lineStartOffset());
>+
>+        RefPtr<RegisterID> result = generator.newTemporary();
>+        generator.emitCall(result.get(), startAsyncFunction.get(), NoExpectedFunction, args, divot, divot, divot);
>+        generator.emitReturn(result.get());
>+        break;
>+    }
>+
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>+    case SourceParseMode::AsyncFunctionBodyMode:
>     case SourceParseMode::GeneratorBodyMode: {
>         RefPtr<Label> generatorBodyLabel = generator.newLabel();
>         {
>diff --git a/Source/JavaScriptCore/inspector/agents/InspectorRuntimeAgent.cpp b/Source/JavaScriptCore/inspector/agents/InspectorRuntimeAgent.cpp
>index 81d03bdb2359844783071d18aeaec698eb80ca79..5b9cc62b4caa2d51280c136fc88733dec00179a2 100644
>--- a/Source/JavaScriptCore/inspector/agents/InspectorRuntimeAgent.cpp
>+++ b/Source/JavaScriptCore/inspector/agents/InspectorRuntimeAgent.cpp
>@@ -41,6 +41,7 @@
> #include "InspectorValues.h"
> #include "JSLock.h"
> #include "ParserError.h"
>+#include "RuntimeFlags.h"
> #include "ScriptDebugServer.h"
> #include "SourceCode.h"
> #include "TypeProfiler.h"
>@@ -90,7 +91,7 @@ void InspectorRuntimeAgent::parse(ErrorString&, const String& expression, Inspec
>     JSLockHolder lock(m_vm);
> 
>     ParserError error;
>-    checkSyntax(m_vm, JSC::makeSource(expression), error);
>+    checkSyntax(m_vm, RuntimeFlags(), JSC::makeSource(expression), error);
> 
>     switch (error.syntaxErrorType()) {
>     case ParserError::SyntaxErrorNone:
>diff --git a/Source/JavaScriptCore/jit/JIT.cpp b/Source/JavaScriptCore/jit/JIT.cpp
>index 2d74cf6f19575e326c7b7efa3cc61d1d09e79f29..91cb6a8ed605e495a0a094b530c44217bef60c37 100644
>--- a/Source/JavaScriptCore/jit/JIT.cpp
>+++ b/Source/JavaScriptCore/jit/JIT.cpp
>@@ -270,6 +270,8 @@ void JIT::privateCompileMainPass()
>         DEFINE_OP(op_new_func_exp)
>         DEFINE_OP(op_new_generator_func)
>         DEFINE_OP(op_new_generator_func_exp)
>+        DEFINE_OP(op_new_async_func)
>+        DEFINE_OP(op_new_async_func_exp)
>         DEFINE_OP(op_new_arrow_func_exp) 
>         DEFINE_OP(op_new_object)
>         DEFINE_OP(op_new_regexp)
>diff --git a/Source/JavaScriptCore/jit/JIT.h b/Source/JavaScriptCore/jit/JIT.h
>index d355a4c2a62fdf885182619fcbf0c6ed60a2e6d5..1d238f08c6b023e70f5a225013cc4c3933b04bc4 100644
>--- a/Source/JavaScriptCore/jit/JIT.h
>+++ b/Source/JavaScriptCore/jit/JIT.h
>@@ -546,6 +546,8 @@ namespace JSC {
>         void emit_op_new_func_exp(Instruction*);
>         void emit_op_new_generator_func(Instruction*);
>         void emit_op_new_generator_func_exp(Instruction*);
>+        void emit_op_new_async_func(Instruction*);
>+        void emit_op_new_async_func_exp(Instruction*);
>         void emit_op_new_arrow_func_exp(Instruction*);
>         void emit_op_new_object(Instruction*);
>         void emit_op_new_regexp(Instruction*);
>diff --git a/Source/JavaScriptCore/jit/JITOpcodes.cpp b/Source/JavaScriptCore/jit/JITOpcodes.cpp
>index f1364ffd9faf7327b173f44d563a8a4c95a00263..2072293f791deff15cc66eb9e8f037d1a1e84e41 100644
>--- a/Source/JavaScriptCore/jit/JITOpcodes.cpp
>+++ b/Source/JavaScriptCore/jit/JITOpcodes.cpp
>@@ -991,6 +991,11 @@ void JIT::emit_op_new_generator_func(Instruction* currentInstruction)
>     emitNewFuncCommon(currentInstruction);
> }
> 
>+void JIT::emit_op_new_async_func(Instruction* currentInstruction)
>+{
>+    emitNewFuncCommon(currentInstruction);
>+}
>+
> void JIT::emitNewFuncExprCommon(Instruction* currentInstruction)
> {
>     Jump notUndefinedScope;
>@@ -1012,6 +1017,8 @@ void JIT::emitNewFuncExprCommon(Instruction* currentInstruction)
> 
>     if (opcodeID == op_new_func_exp || opcodeID == op_new_arrow_func_exp)
>         callOperation(operationNewFunction, dst, regT0, function);
>+    else if (opcodeID == op_new_async_func_exp)
>+        callOperation(operationNewAsyncFunction, dst, regT0, function);
>     else {
>         ASSERT(opcodeID == op_new_generator_func_exp);
>         callOperation(operationNewGeneratorFunction, dst, regT0, function);
>@@ -1030,6 +1037,12 @@ void JIT::emit_op_new_generator_func_exp(Instruction* currentInstruction)
>     emitNewFuncExprCommon(currentInstruction);
> }
> 
>+void JIT::emit_op_new_async_func_exp(Instruction* currentInstruction)
>+{
>+    emitNewFuncExprCommon(currentInstruction);
>+}
>+
>+
> void JIT::emit_op_new_arrow_func_exp(Instruction* currentInstruction)
> {
>     emitNewFuncExprCommon(currentInstruction);
>diff --git a/Source/JavaScriptCore/jit/JITOperations.cpp b/Source/JavaScriptCore/jit/JITOperations.cpp
>index 3063c95a349c3f45da7405d7f7c8e54abac8c049..cccad7c3dafd295b7e3a8d562a88ec85900f8f9d 100644
>--- a/Source/JavaScriptCore/jit/JITOperations.cpp
>+++ b/Source/JavaScriptCore/jit/JITOperations.cpp
>@@ -46,6 +46,7 @@
> #include "JIT.h"
> #include "JITExceptions.h"
> #include "JITToDFGDeferredCompilationCallback.h"
>+#include "JSAsyncFunction.h"
> #include "JSCInlines.h"
> #include "JSGeneratorFunction.h"
> #include "JSGlobalObjectFunctions.h"
>@@ -1088,6 +1089,16 @@ EncodedJSValue JIT_OPERATION operationNewFunctionWithInvalidatedReallocationWatc
>     return operationNewFunctionCommon<JSFunction>(exec, scope, functionExecutable, true);
> }
> 
>+EncodedJSValue JIT_OPERATION operationNewAsyncFunction(ExecState* exec, JSScope* scope, JSCell* functionExecutable)
>+{
>+    return operationNewFunctionCommon<JSAsyncFunction>(exec, scope, functionExecutable, false);
>+}
>+
>+EncodedJSValue JIT_OPERATION operationNewAsyncFunctionWithInvalidatedReallocationWatchpoint(ExecState* exec, JSScope* scope, JSCell* functionExecutable)
>+{
>+    return operationNewFunctionCommon<JSAsyncFunction>(exec, scope, functionExecutable, true);
>+}
>+
> EncodedJSValue JIT_OPERATION operationNewGeneratorFunction(ExecState* exec, JSScope* scope, JSCell* functionExecutable)
> {
>     return operationNewFunctionCommon<JSGeneratorFunction>(exec, scope, functionExecutable, false);
>diff --git a/Source/JavaScriptCore/jit/JITOperations.h b/Source/JavaScriptCore/jit/JITOperations.h
>index d686ab03f471e7973cb4d249ab8621e93429c9d9..2ad813d8049c0edf8435639412a673d70d7019f4 100644
>--- a/Source/JavaScriptCore/jit/JITOperations.h
>+++ b/Source/JavaScriptCore/jit/JITOperations.h
>@@ -333,6 +333,8 @@ EncodedJSValue JIT_OPERATION operationNewArrayBufferWithProfile(ExecState*, Arra
> EncodedJSValue JIT_OPERATION operationNewArrayWithSizeAndProfile(ExecState*, ArrayAllocationProfile*, EncodedJSValue size) WTF_INTERNAL;
> EncodedJSValue JIT_OPERATION operationNewFunction(ExecState*, JSScope*, JSCell*) WTF_INTERNAL;
> EncodedJSValue JIT_OPERATION operationNewFunctionWithInvalidatedReallocationWatchpoint(ExecState*, JSScope*, JSCell*) WTF_INTERNAL;
>+EncodedJSValue JIT_OPERATION operationNewAsyncFunction(ExecState*, JSScope*, JSCell*) WTF_INTERNAL;
>+EncodedJSValue JIT_OPERATION operationNewAsyncFunctionWithInvalidatedReallocationWatchpoint(ExecState*, JSScope*, JSCell*) WTF_INTERNAL;
> EncodedJSValue JIT_OPERATION operationNewGeneratorFunction(ExecState*, JSScope*, JSCell*) WTF_INTERNAL;
> EncodedJSValue JIT_OPERATION operationNewGeneratorFunctionWithInvalidatedReallocationWatchpoint(ExecState*, JSScope*, JSCell*) WTF_INTERNAL;
> void JIT_OPERATION operationSetFunctionName(ExecState*, JSCell*, EncodedJSValue) WTF_INTERNAL;
>diff --git a/Source/JavaScriptCore/jsc.cpp b/Source/JavaScriptCore/jsc.cpp
>index e0a79f03ea170893107c26402f277ac6ba7df331..40f8dbf85e2c42c8e06f7f505a2773dfe128af44 100644
>--- a/Source/JavaScriptCore/jsc.cpp
>+++ b/Source/JavaScriptCore/jsc.cpp
>@@ -647,6 +647,7 @@ class CommandLine {
> public:
>     CommandLine(int argc, char** argv)
>     {
>+        m_runtimeFlags = RuntimeFlags::createAllEnabled();
>         parseArguments(argc, argv);
>     }
> 
>@@ -658,6 +659,7 @@ public:
>     Vector<String> m_arguments;
>     bool m_profile { false };
>     String m_profilerOutput;
>+    RuntimeFlags m_runtimeFlags;
> 
>     void parseArguments(int, char**);
> };
>@@ -710,10 +712,10 @@ private:
> public:
>     typedef JSGlobalObject Base;
> 
>-    static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)
>+    static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments, const RuntimeFlags& runtimeFlags)
>     {
>         GlobalObject* object = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure);
>-        object->finishCreation(vm, arguments);
>+        object->finishCreation(vm, arguments, runtimeFlags);
>         vm.heap.addFinalizer(object, destroy);
>         return object;
>     }
>@@ -728,12 +730,13 @@ public:
>         return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
>     }
> 
>-    static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject*) { return RuntimeFlags::createAllEnabled(); }
>+    static RuntimeFlags javaScriptRuntimeFlags(const JSGlobalObject* globalObject) { return globalObject->runtimeFlags(); }
> 
> protected:
>-    void finishCreation(VM& vm, const Vector<String>& arguments)
>+    void finishCreation(VM& vm, const Vector<String>& arguments, const RuntimeFlags& runtimeFlags)
>     {
>         Base::finishCreation(vm);
>+        m_runtimeFlags = runtimeFlags;
>         
>         addFunction(vm, "debug", functionDebug, 1);
>         addFunction(vm, "describe", functionDescribe, 1);
>@@ -1378,7 +1381,7 @@ EncodedJSValue JSC_HOST_CALL functionRun(ExecState* exec)
>     if (!fetchScriptFromLocalFileSystem(fileName, script))
>         return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));
> 
>-    GlobalObject* globalObject = GlobalObject::create(exec->vm(), GlobalObject::createStructure(exec->vm(), jsNull()), Vector<String>());
>+    GlobalObject* globalObject = GlobalObject::create(exec->vm(), GlobalObject::createStructure(exec->vm(), jsNull()), Vector<String>(), exec->lexicalGlobalObject()->runtimeFlags());
> 
>     JSArray* array = constructEmptyArray(globalObject->globalExec(), 0);
>     for (unsigned i = 1; i < exec->argumentCount(); ++i)
>@@ -2014,7 +2017,7 @@ static void runInteractive(GlobalObject* globalObject)
>                 break;
>             source = source + line;
>             source = source + '\n';
>-            checkSyntax(globalObject->vm(), makeSource(source, interpreterName), error);
>+            checkSyntax(globalObject->vm(), globalObject->runtimeFlags(), makeSource(source, interpreterName), error);
>             if (!line[0])
>                 break;
>             add_history(line);
>@@ -2073,6 +2076,12 @@ static NO_RETURN void printUsageStatement(bool help = false)
>     fprintf(stderr, "  --options                  Dumps all JSC VM options and exits\n");
>     fprintf(stderr, "  --dumpOptions              Dumps all JSC VM options before continuing\n");
>     fprintf(stderr, "  --<jsc VM option>=<value>  Sets the specified JSC VM option\n");
>+
>+#define FOR_EACH_RUNTIME_FLAG(name_, flagName_, isEnabled_) \
>+    fprintf(stderr, "  --%s\n", isEnabled_ ? "no-" flagName_ : flagName_);
>+    JSC_RUNTIME_FLAG(FOR_EACH_RUNTIME_FLAG)
>+#undef FOR_EACH_RUNTIME_FLAG
>+
>     fprintf(stderr, "\n");
> 
>     jscExit(help ? EXIT_SUCCESS : EXIT_FAILURE);
>@@ -2150,6 +2159,14 @@ void CommandLine::parseArguments(int argc, char** argv)
>             continue;
>         }
> 
>+#define FOR_EACH_RUNTIME_FLAG(name_, flagName_, isEnabled_) \
>+        if (!strcmp(arg, isEnabled_ ? "--no-" flagName_ : "--" flagName_)) { \
>+            m_runtimeFlags.set##name_(!isEnabled_); \
>+            continue; \
>+        }
>+        JSC_RUNTIME_FLAG(FOR_EACH_RUNTIME_FLAG)
>+#undef FOR_EACH_RUNTIME_FLAG
>+
>         // See if the -- option is a JSC VM option.
>         if (strstr(arg, "--") == arg) {
>             if (!JSC::Options::setOption(&arg[2])) {
>@@ -2189,7 +2206,7 @@ static int NEVER_INLINE runJSC(VM* vm, CommandLine options)
>     if (options.m_profile && !vm->m_perBytecodeProfiler)
>         vm->m_perBytecodeProfiler = std::make_unique<Profiler::Database>(*vm);
> 
>-    GlobalObject* globalObject = GlobalObject::create(*vm, GlobalObject::createStructure(*vm, jsNull()), options.m_arguments);
>+    GlobalObject* globalObject = GlobalObject::create(*vm, GlobalObject::createStructure(*vm, jsNull()), options.m_arguments, options.m_runtimeFlags);
>     bool success = runWithScripts(globalObject, options.m_scripts, options.m_dump, options.m_module);
>     if (options.m_interactive && success)
>         runInteractive(globalObject);
>diff --git a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp b/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
>index 42407bcc12e992ddabb66e157e3e0f3bd1c4b727..a6db359b54dbe47c0655ebb648c7eea3b1649ae8 100644
>--- a/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
>+++ b/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
>@@ -39,6 +39,7 @@
> #include "Interpreter.h"
> #include "JIT.h"
> #include "JITExceptions.h"
>+#include "JSAsyncFunction.h"
> #include "JSLexicalEnvironment.h"
> #include "JSCInlines.h"
> #include "JSCJSValue.h"
>@@ -1053,6 +1054,17 @@ LLINT_SLOW_PATH_DECL(slow_path_new_func)
>     LLINT_RETURN(JSFunction::create(vm, codeBlock->functionDecl(pc[3].u.operand), scope));
> }
> 
>+LLINT_SLOW_PATH_DECL(slow_path_new_async_func)
>+{
>+    LLINT_BEGIN();
>+    CodeBlock* codeBlock = exec->codeBlock();
>+    JSScope* scope = exec->uncheckedR(pc[2].u.operand).Register::scope();
>+#if LLINT_SLOW_PATH_TRACING
>+    dataLogF("Creating async function!\n");
>+#endif
>+    LLINT_RETURN(JSAsyncFunction::create(vm, codeBlock->functionDecl(pc[3].u.operand), scope));
>+}
>+
> LLINT_SLOW_PATH_DECL(slow_path_new_generator_func)
> {
>     LLINT_BEGIN();
>@@ -1086,6 +1098,17 @@ LLINT_SLOW_PATH_DECL(slow_path_new_generator_func_exp)
>     LLINT_RETURN(JSGeneratorFunction::create(vm, executable, scope));
> }
> 
>+LLINT_SLOW_PATH_DECL(slow_path_new_async_func_exp)
>+{
>+    LLINT_BEGIN();
>+    
>+    CodeBlock* codeBlock = exec->codeBlock();
>+    JSScope* scope = exec->uncheckedR(pc[2].u.operand).Register::scope();
>+    FunctionExecutable* executable = codeBlock->functionExpr(pc[3].u.operand);
>+    
>+    LLINT_RETURN(JSAsyncFunction::create(vm, executable, scope));
>+}
>+
> LLINT_SLOW_PATH_DECL(slow_path_new_arrow_func_exp)
> {
>     LLINT_BEGIN();
>diff --git a/Source/JavaScriptCore/llint/LLIntSlowPaths.h b/Source/JavaScriptCore/llint/LLIntSlowPaths.h
>index e3d41e45827fb0dc5bfd515e6307c21103a03f36..ab5c5510753777bd09f42269a26bc2ca7bcd44ed 100644
>--- a/Source/JavaScriptCore/llint/LLIntSlowPaths.h
>+++ b/Source/JavaScriptCore/llint/LLIntSlowPaths.h
>@@ -100,6 +100,8 @@ LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_switch_char);
> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_switch_string);
> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_func);
> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_func_exp);
>+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_async_func);
>+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_async_func_exp);
> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_generator_func);
> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_generator_func_exp);
> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_arrow_func_exp);
>diff --git a/Source/JavaScriptCore/llint/LowLevelInterpreter.asm b/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
>index 70907a423e2fcb7854586d3619d385a0dbec2c4a..e5b8c7d5bb270ce7af358db02ab4015488d8750c 100644
>--- a/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
>+++ b/Source/JavaScriptCore/llint/LowLevelInterpreter.asm
>@@ -1218,6 +1218,12 @@ _llint_op_new_func:
>     dispatch(4)
> 
> 
>+_llint_op_new_async_func:
>+    traceExecution()
>+    callSlowPath(_llint_slow_path_new_async_func)
>+    dispatch(4)
>+
>+
> _llint_op_new_generator_func:
>     traceExecution()
>     callSlowPath(_llint_slow_path_new_generator_func)
>@@ -1497,7 +1503,6 @@ _llint_op_switch_string:
>     callSlowPath(_llint_slow_path_switch_string)
>     dispatch(0)
> 
>-
> _llint_op_new_func_exp:
>     traceExecution()
>     callSlowPath(_llint_slow_path_new_func_exp)
>@@ -1508,6 +1513,11 @@ _llint_op_new_generator_func_exp:
>     callSlowPath(_llint_slow_path_new_generator_func_exp)
>     dispatch(4)
> 
>+_llint_op_new_async_func_exp:
>+    traceExecution()
>+    callSlowPath(_llint_slow_path_new_async_func_exp)
>+    dispatch(4)
>+
> _llint_op_new_arrow_func_exp:
>     traceExecution()
>     callSlowPath(_llint_slow_path_new_arrow_func_exp)
>diff --git a/Source/JavaScriptCore/parser/Keywords.table b/Source/JavaScriptCore/parser/Keywords.table
>index 4582d00aae97ed153ecf99af8db96a756191ed2a..16782760cd50d081dfa7f23f1672fdb1daf2aadb 100644
>--- a/Source/JavaScriptCore/parser/Keywords.table
>+++ b/Source/JavaScriptCore/parser/Keywords.table
>@@ -7,6 +7,8 @@ true		TRUETOKEN
> false		FALSETOKEN
> 
> # Keywords.
>+async		ASYNC
>+await		AWAIT
> break		BREAK
> case		CASE
> catch		CATCH
>diff --git a/Source/JavaScriptCore/parser/Lexer.cpp b/Source/JavaScriptCore/parser/Lexer.cpp
>index b471d33dfc7e9da1d114fc8637a2389b3593ac86..028015402855dc83ef892db05663993e852a43a0 100644
>--- a/Source/JavaScriptCore/parser/Lexer.cpp
>+++ b/Source/JavaScriptCore/parser/Lexer.cpp
>@@ -542,6 +542,7 @@ void Lexer<T>::setCode(const SourceCode& source, ParserArena* arena)
>     
>     m_lineNumber = source.firstLine();
>     m_lastToken = -1;
>+    m_prevToken = -1;
>     
>     StringView sourceString = source.provider()->source();
> 
>@@ -1788,6 +1789,7 @@ JSTokenType Lexer<T>::lex(JSToken* tokenRecord, unsigned lexerFlags, bool strict
> 
>     JSTokenType token = ERRORTOK;
>     m_terminator = false;
>+    m_prevToken = m_lastToken;
> 
> start:
>     skipWhitespace();
>diff --git a/Source/JavaScriptCore/parser/Lexer.h b/Source/JavaScriptCore/parser/Lexer.h
>index 0b5ad96be747a59392f27b89dfb9e3e09e645e21..57e0e8d4a74c40522a8e9ebed548b5742a7f2470 100644
>--- a/Source/JavaScriptCore/parser/Lexer.h
>+++ b/Source/JavaScriptCore/parser/Lexer.h
>@@ -78,6 +78,7 @@ public:
>     void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }
>     int lastLineNumber() const { return m_lastLineNumber; }
>     bool prevTerminator() const { return m_terminator; }
>+    int prevToken() const { return m_prevToken; }
>     bool scanRegExp(const Identifier*& pattern, const Identifier*& flags, UChar patternPrefix = 0);
>     enum class RawStringsBuildMode { BuildRawStrings, DontBuildRawStrings };
>     JSTokenType scanTrailingTemplateString(JSToken*, RawStringsBuildMode);
>@@ -194,6 +195,7 @@ private:
>     Vector<UChar> m_bufferForRawTemplateString16;
>     bool m_terminator;
>     int m_lastToken;
>+    int m_prevToken;
> 
>     const SourceCode* m_source;
>     unsigned m_sourceOffset;
>diff --git a/Source/JavaScriptCore/parser/Parser.cpp b/Source/JavaScriptCore/parser/Parser.cpp
>index 3937ce2cd3044b69a5eed76a6444dd26f9e60dc1..fc01179df2e0dc655bf74409b6afd8349e368950 100644
>--- a/Source/JavaScriptCore/parser/Parser.cpp
>+++ b/Source/JavaScriptCore/parser/Parser.cpp
>@@ -76,6 +76,8 @@
>         semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__); \
>     if (m_token.m_type & KeywordTokenFlag) \
>         semanticFail("Cannot use the keyword '", getToken(), "' as a ", __VA_ARGS__); \
>+    if (isDisallowedIdentifierAwait(m_token)) \
>+        semanticFail("Can't use 'await' as a ", __VA_ARGS__, " ", disallowedIdentifierAwaitReason()); \
> } while (0)
> 
> using namespace std;
>@@ -191,10 +193,11 @@ void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B
> }
> 
> template <typename LexerType>
>-Parser<LexerType>::Parser(VM* vm, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding, ConstructorKind defaultConstructorKind, ThisTDZMode thisTDZMode, DerivedContextType derivedContextType, bool isEvalContext, EvalContextType evalContextType)
>+Parser<LexerType>::Parser(VM* vm, RuntimeFlags runtimeFlags, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding, ConstructorKind defaultConstructorKind, ThisTDZMode thisTDZMode, DerivedContextType derivedContextType, bool isEvalContext, EvalContextType evalContextType)
>     : m_vm(vm)
>     , m_source(&source)
>     , m_hasStackOverflow(false)
>+    , m_runtimeFlags(runtimeFlags)
>     , m_allowsIn(true)
>     , m_syntaxAlreadyValidated(source.provider()->isValid())
>     , m_statementDepth(0)
>@@ -231,6 +234,8 @@ Parser<LexerType>::Parser(VM* vm, const SourceCode& source, JSParserBuiltinMode
>     if (strictMode == JSParserStrictMode::Strict)
>         scope->setStrictMode();
> 
>+    m_allowsAwait = true;
>+
>     next();
> }
> 
>@@ -252,13 +257,13 @@ String Parser<LexerType>::parseInner(const Identifier& calleeName, SourceParseMo
>     bool isArrowFunctionBodyExpression = false;
>     if (m_lexer->isReparsingFunction()) {
>         ParserFunctionInfo<ASTBuilder> functionInfo;
>-        if (parseMode == SourceParseMode::GeneratorBodyMode)
>+        if (parseMode == SourceParseMode::GeneratorBodyMode || isAsyncFunctionBodyParseMode(parseMode))
>             functionInfo.parameters = createGeneratorParameters(context);
>         else
>             parseFunctionParameters(context, parseMode, functionInfo);
>         m_parameters = functionInfo.parameters;
> 
>-        if (parseMode == SourceParseMode::ArrowFunctionMode && !hasError()) {
>+        if ((parseMode == SourceParseMode::ArrowFunctionMode || parseMode == SourceParseMode::AsyncArrowFunctionMode) && !hasError()) {
>             // The only way we could have an error wile reparsing is if we run out of stack space.
>             RELEASE_ASSERT(match(ARROWFUNCTION));
>             next();
>@@ -275,16 +280,16 @@ String Parser<LexerType>::parseInner(const Identifier& calleeName, SourceParseMo
>     SourceElements* sourceElements = nullptr;
>     // The only way we can error this early is if we reparse a function and we run out of stack space.
>     if (!hasError()) {
>-        if (isArrowFunctionBodyExpression)
>+        if (isAsyncFunctionWrapperParseMode(parseMode))
>+            sourceElements = parseAsyncFunctionSourceElements(context, parseMode, isArrowFunctionBodyExpression, CheckForStrictMode);
>+        else if (isArrowFunctionBodyExpression)
>             sourceElements = parseArrowFunctionSingleExpressionBodySourceElements(context);
>         else if (isModuleParseMode(parseMode))
>             sourceElements = parseModuleSourceElements(context, parseMode);
>-        else {
>-            if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode)
>-                sourceElements = parseGeneratorFunctionSourceElements(context, CheckForStrictMode);
>-            else
>-                sourceElements = parseSourceElements(context, CheckForStrictMode);
>-        }
>+        else if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode)
>+            sourceElements = parseGeneratorFunctionSourceElements(context, CheckForStrictMode);
>+        else
>+            sourceElements = parseSourceElements(context, CheckForStrictMode);
>     }
> 
>     bool validEnding;
>@@ -315,7 +320,7 @@ String Parser<LexerType>::parseInner(const Identifier& calleeName, SourceParseMo
>     for (auto& entry : capturedVariables)
>         varDeclarations.markVariableAsCaptured(entry);
> 
>-    if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode) {
>+    if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode || isAsyncFunctionWrapperParseMode(parseMode)) {
>         if (scope->usedVariablesContains(m_vm->propertyNames->arguments.impl()))
>             context.propagateArgumentsUse();
>     }
>@@ -365,7 +370,7 @@ template <typename LexerType>
> bool Parser<LexerType>::isArrowFunctionParameters()
> {
>     bool isOpenParen = match(OPENPAREN);
>-    bool isIdent = match(IDENT);
>+    bool isIdent = matchSpecIdentifier();
>     
>     if (!isOpenParen && !isIdent)
>         return false;
>@@ -538,6 +543,50 @@ template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseGenerato
> }
> 
> template <typename LexerType>
>+template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseAsyncFunctionSourceElements(TreeBuilder& context, SourceParseMode parseMode, bool isArrowFunctionBodyExpression, SourceElementsMode mode)
>+{
>+    ASSERT(isAsyncFunctionWrapperParseMode(parseMode));
>+    auto sourceElements = context.createSourceElements();
>+
>+    unsigned functionKeywordStart = tokenStart();
>+    JSTokenLocation startLocation(tokenLocation());
>+    JSTextPosition start = tokenStartPosition();
>+    unsigned startColumn = tokenColumn();
>+    int functionNameStart = m_token.m_location.startOffset;
>+    int parametersStart = m_token.m_location.startOffset;
>+
>+    ParserFunctionInfo<TreeBuilder> info;
>+    info.name = &m_vm->propertyNames->nullIdentifier;
>+    info.parameters = createGeneratorParameters(context);
>+    info.startOffset = parametersStart;
>+    info.startLine = tokenLine();
>+    info.parameterCount = 4; // generator, state, value, resume mode
>+    SourceParseMode innerParseMode = parseMode == SourceParseMode::AsyncArrowFunctionMode ? SourceParseMode::AsyncArrowFunctionBodyMode : SourceParseMode::AsyncFunctionBodyMode;
>+    {
>+        AutoPopScopeRef asyncFunctionBodyScope(this, pushScope());
>+        asyncFunctionBodyScope->setSourceParseMode(innerParseMode);
>+        SyntaxChecker asyncFunctionContext(const_cast<VM*>(m_vm), m_lexer.get());
>+        if (isArrowFunctionBodyExpression)
>+            failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(asyncFunctionContext), "Cannot parse the body of async arrow function");
>+        else
>+            failIfFalse(parseSourceElements(asyncFunctionContext, mode), "Cannot parse the body of async function");
>+        popScope(asyncFunctionBodyScope, TreeBuilder::NeedsFreeVariableInfo);
>+    }
>+
>+    info.body = context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, tokenColumn(), functionKeywordStart, functionNameStart, parametersStart, strictMode(), ConstructorKind::None, m_superBinding, info.parameterCount, innerParseMode, isArrowFunctionBodyExpression);
>+
>+    info.endLine = tokenLine();
>+    info.endOffset = m_token.m_data.offset;
>+    info.bodyStartColumn = startColumn;
>+
>+    auto functionExpr = context.createFunctionExpr(startLocation, info);
>+    auto statement = context.createExprStatement(startLocation, functionExpr, start, m_lastTokenEndPosition.line);
>+    context.appendStatement(sourceElements, statement);
>+
>+    return sourceElements;
>+}
>+
>+template <typename LexerType>
> template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatementListItem(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength)
> {
>     // The grammar is documented here:
>@@ -546,6 +595,7 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatementList
>     m_statementDepth++;
>     TreeStatement result = 0;
>     bool shouldSetEndOffset = true;
>+
>     switch (m_token.m_type) {
>     case CONSTTOKEN:
>         result = parseVariableDeclaration(context, DeclarationType::ConstDeclaration);
>@@ -560,7 +610,7 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatementList
>             // For example, under a generator context, matchSpecIdentifier() for "yield" returns `false`.
>             // But we would like to enter parseVariableDeclaration and raise an error under the context of parseVariableDeclaration
>             // to raise consistent errors between "var", "const" and "let".
>-            if (!(match(IDENT) || match(LET) || match(YIELD)) && !match(OPENBRACE) && !match(OPENBRACKET))
>+            if (!(match(IDENT) || match(ASYNC) || match(AWAIT) || match(LET) || match(YIELD)) && !match(OPENBRACE) && !match(OPENBRACKET))
>                 shouldParseVariableDeclaration = false;
>             restoreSavePoint(savePoint);
>         }
>@@ -579,6 +629,25 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatementList
>     case FUNCTION:
>         result = parseFunctionDeclaration(context);
>         break;
>+
>+    case ASYNC:
>+        if (m_runtimeFlags.isAsyncAwaitEnabled()) {
>+            // Eagerly parse as AsyncFUnctionDeclaration. This is the uncommon case,
>+            // but could be mistakenly parsed as an AsyncFunctionExpression.
>+            SavePoint savePoint = createSavePoint();
>+            bool allowFunctionDeclarationAsStatement = true;
>+            next();
>+            if (UNLIKELY(match(FUNCTION) && !m_lexer->prevTerminator()))
>+                result = parseAsyncFunctionDeclaration(context);
>+            else {
>+                restoreSavePoint(savePoint);
>+                result = parseExpressionOrLabelStatement(context, allowFunctionDeclarationAsStatement);
>+            }
>+            failIfFalse(result, "Failed to parse expression");
>+            break;
>+        }
>+        FALLTHROUGH;
>+    case AWAIT:
>     case IDENT:
>     case YIELD: {
>         // This is a convenient place to notice labeled statements
>@@ -688,6 +757,7 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVariableDecl
>         if (matchSpecIdentifier()) {
>             failIfTrue(match(LET) && (declarationType == DeclarationType::LetDeclaration || declarationType == DeclarationType::ConstDeclaration), 
>                 "Can't use 'let' as an identifier name for a LexicalDeclaration");
>+            semanticFailIfTrue(isDisallowedIdentifierAwait(m_token), "Can't use 'await' as a ", declarationTypeToVariableKind(declarationType), " ", disallowedIdentifierAwaitReason());
>             JSTextPosition varStart = tokenStartPosition();
>             JSTokenLocation varStartLocation(tokenLocation());
>             identStart = varStart;
>@@ -1014,6 +1084,7 @@ template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseDe
>                             reclassifyExpressionError(ErrorIndicatesPattern, ErrorIndicatesNothing);
>                         failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", propertyName->impl(), "' in strict mode");
>                     }
>+                    semanticFailIfTrue(isDisallowedIdentifierAwait(identifierToken), "Can't use 'await' as a ", destructuringKindToVariableKindName(kind), " ", disallowedIdentifierAwaitReason());
>                     innerPattern = createBindingPattern(context, kind, exportType, *propertyName, identifierToken, bindingContext, duplicateIdentifier);
>                 }
>             } else {
>@@ -1081,6 +1152,7 @@ template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseDe
>             failWithMessage("Expected a parameter pattern or a ')' in parameter list");
>         }
>         failIfTrue(match(LET) && (kind == DestructuringKind::DestructureToLet || kind == DestructuringKind::DestructureToConst), "Can't use 'let' as an identifier name for a LexicalDeclaration");
>+        semanticFailIfTrue(isDisallowedIdentifierAwait(m_token), "Can't use 'await' as a ", destructuringKindToVariableKindName(kind), " ", disallowedIdentifierAwaitReason());
>         pattern = createBindingPattern(context, kind, exportType, *m_token.m_data.ident, m_token, bindingContext, duplicateIdentifier);
>         next();
>         break;
>@@ -1716,6 +1788,43 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatement(Tre
>     case DEFAULT:
>         // These tokens imply the end of a set of source elements
>         return 0;
>+
>+    case ASYNC:
>+        if (m_runtimeFlags.isAsyncAwaitEnabled()) {
>+            SavePoint savePoint = createSavePoint();
>+            next();
>+            if (match(FUNCTION) && !m_lexer->prevTerminator()) {
>+                if (currentScope()->isFunction()) {
>+                    AutoPopScopeRef blockScope(this, pushScope());
>+                    blockScope->setIsLexicalScope();
>+                    blockScope->preventVarDeclarations();
>+                    JSTokenLocation location(tokenLocation());
>+                    int start = tokenLine();
>+
>+                    TreeStatement function = parseAsyncFunctionDeclaration(context);
>+                    failIfFalse(function, "Expected valid function statement after 'function' keyword");
>+                    TreeSourceElements sourceElements = context.createSourceElements();
>+                    context.appendStatement(sourceElements, function);
>+                    result = context.createBlockStatement(location, sourceElements, start, m_lastTokenEndPosition.line, currentScope()->finalizeLexicalEnvironment(), currentScope()->takeFunctionDeclarations());
>+                    popScope(blockScope, TreeBuilder::NeedsFreeVariableInfo);
>+                } else {
>+                    // We only implement annex B.3.3 if we're in function mode. Otherwise, we fall back
>+                    // to hoisting behavior.
>+                    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=155813
>+                    DepthManager statementDepth(&m_statementDepth);
>+                    m_statementDepth = 1;
>+                    result = parseAsyncFunctionDeclaration(context);
>+                }
>+            } else {
>+                restoreSavePoint(savePoint);
>+                bool allowFunctionDeclarationAsStatement = false;
>+                result = parseExpressionOrLabelStatement(context, allowFunctionDeclarationAsStatement);
>+            }
>+            failIfFalse(result, "Failed to parse expression");
>+            break;
>+        }
>+        FALLTHROUGH;
>+    case AWAIT:
>     case IDENT:
>     case YIELD: {
>         bool allowFunctionDeclarationAsStatement = false;
>@@ -1761,6 +1870,7 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFormalParameters(TreeB
>         if (match(DOTDOTDOT)) {
>             next();
>             failIfFalse(matchSpecIdentifier(), "Rest parameter '...' should be followed by a variable identifier");
>+            semanticFailIfTrue(!m_allowsAwait && match(AWAIT), "Can't use 'await' as a parameter name in an async function");
>             declareRestOrNormalParameter(*m_token.m_data.ident, &duplicateParameter);
>             propagateError();
>             JSTextPosition identifierStart = tokenStartPosition();
>@@ -1827,6 +1937,14 @@ static const char* stringForFunctionMode(SourceParseMode mode)
>         return "generator function";
>     case SourceParseMode::ArrowFunctionMode:
>         return "arrow function";
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+        return "async function";
>+    case SourceParseMode::AsyncMethodMode:
>+        return "async method";
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+        return "async arrow function";
>     case SourceParseMode::ProgramMode:
>     case SourceParseMode::ModuleAnalyzeMode:
>     case SourceParseMode::ModuleEvaluateMode:
>@@ -1846,8 +1964,8 @@ template <typename LexerType> template <class TreeBuilder> int Parser<LexerType>
>     functionInfo.startOffset = parametersStart;
>     SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Parameters);
>     
>-    if (mode == SourceParseMode::ArrowFunctionMode) {
>-        if (!match(IDENT) && !match(OPENPAREN)) {
>+    if (mode == SourceParseMode::ArrowFunctionMode || mode == SourceParseMode::AsyncArrowFunctionMode) {
>+        if (!matchSpecIdentifier() && !match(OPENPAREN)) {
>             semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
>             failWithMessage("Expected an arrow function input parameter");
>         } else {
>@@ -1939,6 +2057,9 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuild
>     RELEASE_ASSERT(isFunctionParseMode(mode));
> 
>     bool upperScopeIsGenerator = currentScope()->isGenerator();
>+    bool upperScopeIsAsync = currentScope()->isAsyncFunctionBoundary();
>+    bool isDisallowedAwaitFunctionName = isDisallowedIdentifierAwait(m_token);
>+    const char* isDisallowedAwaitFunctionNameReason = isDisallowedAwaitFunctionName ? disallowedIdentifierAwaitReason() : nullptr;
>     AutoPopScopeRef functionScope(this, pushScope());
>     functionScope->setSourceParseMode(mode);
>     SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Body);
>@@ -1950,12 +2071,15 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuild
>     int startColumn;
>     FunctionBodyType functionBodyType;
> 
>-    if (mode == SourceParseMode::ArrowFunctionMode) {
>+    if (mode == SourceParseMode::ArrowFunctionMode || mode == SourceParseMode::AsyncArrowFunctionMode) {
>         startLocation = tokenLocation();
>         functionInfo.startLine = tokenLine();
>         startColumn = tokenColumn();
> 
>-        parametersStart = parseFunctionParameters(context, mode, functionInfo);
>+        {
>+            AllowAwaitOverride allowAwait(this, !isAsyncFunctionParseMode(mode));
>+            parametersStart = parseFunctionParameters(context, mode, functionInfo);
>+        }
>         propagateError();
> 
>         matchOrFail(ARROWFUNCTION, "Expected a '=>' after arrow function parameter declaration");
>@@ -1985,19 +2109,27 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuild
>         // GeneratorExpression :
>         //     function * BindingIdentifier[Yield]opt ( FormalParameters[Yield] ) { GeneratorBody }
>         //
>-        // The name of FunctionExpression can accept "yield" even in the context of generator.
>-        if (functionDefinitionType == FunctionDefinitionType::Expression && mode == SourceParseMode::NormalFunctionMode)
>+        // The name of FunctionExpression and AsyncFunctionExpression can accept "yield" even in the context of generator.
>+        if (functionDefinitionType == FunctionDefinitionType::Expression && (mode == SourceParseMode::NormalFunctionMode || mode == SourceParseMode::AsyncFunctionMode))
>             upperScopeIsGenerator = false;
> 
>         if (matchSpecIdentifier(upperScopeIsGenerator)) {
>+            bool allowsAwait = mode != SourceParseMode::AsyncFunctionMode;
>+            if (functionDefinitionType == FunctionDefinitionType::Declaration)
>+                allowsAwait = upperScopeIsAsync;
>             functionInfo.name = m_token.m_data.ident;
>             m_parserState.lastFunctionName = functionInfo.name;
>+            if (allowsAwait)
>+                semanticFailIfTrue(isDisallowedAwaitFunctionName, "Cannot declare function named 'await' ", isDisallowedAwaitFunctionNameReason);
>+            else
>+                semanticFailIfTrue(isDisallowedAwaitFunctionName, "Cannot declare async function named 'await'");
>+            
>             next();
>             if (!nameIsInContainingScope)
>                 failIfTrueIfStrict(functionScope->declareCallee(functionInfo.name) & DeclarationResult::InvalidStrictMode, "'", functionInfo.name->impl(), "' is not a valid ", stringForFunctionMode(mode), " name in strict mode");
>         } else if (requirements == FunctionNeedsName) {
>-            if (match(OPENPAREN) && mode == SourceParseMode::NormalFunctionMode)
>-                semanticFail("Function statements must have a name");
>+            semanticFailIfTrue(match(OPENPAREN) && mode == SourceParseMode::NormalFunctionMode, "Function statements must have a name");
>+            semanticFailIfTrue(match(OPENPAREN) && mode == SourceParseMode::AsyncFunctionMode, "Async function statements must have a name");
>             semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
>             failDueToUnexpectedToken();
>             return false;
>@@ -2007,7 +2139,10 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuild
>         functionInfo.startLine = tokenLine();
>         startColumn = tokenColumn();
> 
>-        parametersStart = parseFunctionParameters(context, mode, functionInfo);
>+        {
>+            AllowAwaitOverride allowAwait(this, !isAsyncFunctionParseMode(mode));
>+            parametersStart = parseFunctionParameters(context, mode, functionInfo);
>+        }
>         propagateError();
>         
>         matchOrFail(OPENBRACE, "Expected an opening '{' at the start of a ", stringForFunctionMode(mode), " body");
>@@ -2062,7 +2197,7 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuild
>         m_lexer->setLineNumber(m_token.m_location.line);
>         functionInfo.endOffset = cachedInfo->endFunctionOffset;
> 
>-        if (mode == SourceParseMode::ArrowFunctionMode)
>+        if (mode == SourceParseMode::ArrowFunctionMode || mode == SourceParseMode::AsyncArrowFunctionMode)
>             functionBodyType = cachedInfo->isBodyArrowExpression ?  ArrowFunctionBodyExpression : ArrowFunctionBodyBlock;
>         else
>             functionBodyType = StandardFunctionBodyBlock;
>@@ -2089,18 +2224,31 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuild
>         return parseFunctionBody(context, startLocation, startColumn, functionKeywordStart, functionNameStart, parametersStart, constructorKind, expectedSuperBinding, functionBodyType, functionInfo.parameterCount, mode);
>     };
> 
>-    if (mode == SourceParseMode::GeneratorWrapperFunctionMode) {
>+    if (mode == SourceParseMode::GeneratorWrapperFunctionMode || isAsyncFunctionWrapperParseMode(mode)) {
>         AutoPopScopeRef generatorBodyScope(this, pushScope());
>-        generatorBodyScope->setSourceParseMode(SourceParseMode::GeneratorBodyMode);
>+        SourceParseMode innerParseMode = SourceParseMode::GeneratorBodyMode;
>+        if (isAsyncFunctionWrapperParseMode(mode)) {
>+            innerParseMode = mode == SourceParseMode::AsyncArrowFunctionMode
>+                ? SourceParseMode::AsyncArrowFunctionBodyMode
>+                : SourceParseMode::AsyncFunctionBodyMode;
>+        }
>+        generatorBodyScope->setSourceParseMode(innerParseMode);
>         functionInfo.body = performParsingFunctionBody();
> 
>         // When a generator has a "use strict" directive, a generator function wrapping it should be strict mode.
>         if  (generatorBodyScope->strictMode())
>             functionScope->setStrictMode();
> 
>-        semanticFailIfTrue(generatorBodyScope->hasDirectSuper(), "Cannot call super() outside of a class constructor");
>-        if (generatorBodyScope->needsSuperBinding())
>-            semanticFailIfTrue(expectedSuperBinding == SuperBinding::NotNeeded, "super can only be used in a method of a derived class");
>+        if (mode != SourceParseMode::AsyncArrowFunctionMode) {
>+            semanticFailIfTrue(generatorBodyScope->hasDirectSuper(), "Cannot call super() outside of a class constructor");
>+            if (generatorBodyScope->needsSuperBinding())
>+                semanticFailIfTrue(expectedSuperBinding == SuperBinding::NotNeeded, "super can only be used in a method of a derived class");
>+        } else {
>+            if (generatorBodyScope->hasDirectSuper())
>+                functionScope->setHasDirectSuper();
>+            if (generatorBodyScope->needsSuperBinding())
>+                functionScope->setNeedsSuperBinding();
>+        }
> 
>         popScope(generatorBodyScope, TreeBuilder::NeedsFreeVariableInfo);
>     } else
>@@ -2110,7 +2258,7 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuild
>     failIfFalse(functionInfo.body, "Cannot parse the body of this ", stringForFunctionMode(mode));
>     context.setEndOffset(functionInfo.body, m_lexer->currentOffset());
>     if (functionScope->strictMode() && functionInfo.name) {
>-        RELEASE_ASSERT(mode == SourceParseMode::NormalFunctionMode || mode == SourceParseMode::MethodMode || mode == SourceParseMode::ArrowFunctionMode || mode == SourceParseMode::GeneratorBodyMode || mode == SourceParseMode::GeneratorWrapperFunctionMode);
>+        RELEASE_ASSERT(mode == SourceParseMode::NormalFunctionMode || mode == SourceParseMode::MethodMode || mode == SourceParseMode::ArrowFunctionMode || mode == SourceParseMode::GeneratorBodyMode || mode == SourceParseMode::GeneratorWrapperFunctionMode || isAsyncFunctionWrapperParseMode(mode));
>         semanticFailIfTrue(m_vm->propertyNames->arguments == *functionInfo.name, "'", functionInfo.name->impl(), "' is not a valid function name in strict mode");
>         semanticFailIfTrue(m_vm->propertyNames->eval == *functionInfo.name, "'", functionInfo.name->impl(), "' is not a valid function name in strict mode");
>     }
>@@ -2219,6 +2367,35 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDecla
> }
> 
> template <typename LexerType>
>+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseAsyncFunctionDeclaration(TreeBuilder& context, ExportType exportType)
>+{
>+    ASSERT(match(FUNCTION));
>+    JSTokenLocation location(tokenLocation());
>+    unsigned functionKeywordStart = tokenStart();
>+    next();
>+    ParserFunctionInfo<TreeBuilder> functionInfo;
>+    SourceParseMode parseMode = SourceParseMode::AsyncFunctionMode;
>+
>+    failIfFalse((parseFunctionInfo(context, FunctionNeedsName, parseMode, true, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, functionInfo, FunctionDefinitionType::Declaration)), "Cannot parse this async function");
>+    failIfFalse(functionInfo.name, "Async function statements must have a name");
>+
>+    std::pair<DeclarationResultMask, ScopeRef> functionDeclaration = declareFunction(functionInfo.name);
>+    DeclarationResultMask declarationResult = functionDeclaration.first;
>+    failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare an async function named '", functionInfo.name->impl(), "' in strict mode");
>+    if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration)
>+        internalFailWithMessage(false, "Cannot declare an async function that shadows a let/const/class/function variable '", functionInfo.name->impl(), "' in strict mode");
>+    if (exportType == ExportType::Exported) {
>+        semanticFailIfFalse(exportName(*functionInfo.name), "Cannot export a duplicate function name: '", functionInfo.name->impl(), "'");
>+        currentScope()->moduleScopeData().exportBinding(*functionInfo.name);
>+    }
>+
>+    TreeStatement result = context.createFuncDeclStatement(location, functionInfo);
>+    if (TreeBuilder::CreatesAST)
>+        functionDeclaration.second->appendFunction(getMetadata(functionInfo));
>+    return result;
>+}
>+
>+template <typename LexerType>
> template <class TreeBuilder> TreeStatement Parser<LexerType>::parseClassDeclaration(TreeBuilder& context, ExportType exportType)
> {
>     ASSERT(match(CLASSTOKEN));
>@@ -2316,10 +2493,13 @@ template <class TreeBuilder> TreeClassExpression Parser<LexerType>::parseClass(T
>         bool isGetter = false;
>         bool isSetter = false;
>         bool isGenerator = false;
>+        bool isAsyncMethod = false;
> #if ENABLE(ES6_GENERATORS)
>         if (consume(TIMES))
>             isGenerator = true;
> #endif
>+
>+parseMethod:
>         switch (m_token.m_type) {
>         namedKeyword:
>         case STRING:
>@@ -2327,13 +2507,19 @@ template <class TreeBuilder> TreeClassExpression Parser<LexerType>::parseClass(T
>             ASSERT(ident);
>             next();
>             break;
>+        case ASYNC:
>+        case AWAIT:
>         case IDENT:
>             ident = m_token.m_data.ident;
>             ASSERT(ident);
>             next();
>-            if (!isGenerator && (matchIdentifierOrKeyword() || match(STRING) || match(DOUBLE) || match(INTEGER) || match(OPENBRACKET))) {
>+            if (!isGenerator && !isAsyncMethod && (matchIdentifierOrKeyword() || match(STRING) || match(DOUBLE) || match(INTEGER) || match(OPENBRACKET))) {
>                 isGetter = *ident == propertyNames.get;
>                 isSetter = *ident == propertyNames.set;
>+                if (UNLIKELY(m_runtimeFlags.isAsyncAwaitEnabled() && !isAsyncMethod && *ident == propertyNames.async && !m_lexer->prevTerminator())) {
>+                    isAsyncMethod = true;
>+                    goto parseMethod;
>+                }
>             }
>             break;
>         case DOUBLE:
>@@ -2364,7 +2550,12 @@ template <class TreeBuilder> TreeClassExpression Parser<LexerType>::parseClass(T
>             ParserFunctionInfo<TreeBuilder> methodInfo;
>             bool isConstructor = !isStaticMethod && *ident == propertyNames.constructor;
>             SourceParseMode parseMode = SourceParseMode::MethodMode;
>-            if (isGenerator) {
>+            if (isAsyncMethod) {
>+                isConstructor = false;
>+                parseMode = SourceParseMode::AsyncMethodMode;
>+                semanticFailIfTrue(*ident == m_vm->propertyNames->prototype, "Cannot declare an async method named 'prototype'");
>+                semanticFailIfTrue(*ident == m_vm->propertyNames->constructor, "Cannot declare an async method named 'constructor'");
>+            } else if (isGenerator) {
>                 isConstructor = false;
>                 parseMode = SourceParseMode::GeneratorWrapperFunctionMode;
>                 semanticFailIfTrue(*ident == m_vm->propertyNames->prototype, "Cannot declare a generator named 'prototype'");
>@@ -2446,9 +2637,11 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrL
>             return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
>         }
>         const Identifier* ident = m_token.m_data.ident;
>+        const bool isDisallowedLabelAwait = isDisallowedIdentifierAwait(m_token);
>         JSTextPosition end = tokenEndPosition();
>         next();
>         consumeOrFail(COLON, "Labels must be followed by a ':'");
>+        semanticFailIfTrue(isDisallowedLabelAwait, "Can't use 'await' as a label ", disallowedIdentifierAwaitReason());
>         if (!m_syntaxAlreadyValidated) {
>             // This is O(N^2) over the current list of consecutive labels, but I
>             // have never seen more than one label in a row in the real world.
>@@ -2823,8 +3016,17 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExportDeclara
>         TreeStatement result = 0;
>         bool isFunctionOrClassDeclaration = false;
>         const Identifier* localName = nullptr;
>+        bool isAsyncFunctionExport = false;
>         SavePoint savePoint = createSavePoint();
> 
>+        if (m_runtimeFlags.isAsyncAwaitEnabled() && match(ASYNC)) {
>+            next();
>+            if (UNLIKELY(match(FUNCTION) && !m_lexer->prevTerminator()))
>+                isAsyncFunctionExport = true;
>+            else
>+                restoreSavePoint(savePoint);
>+        }
>+
>         bool startsWithFunction = match(FUNCTION);
>         if (startsWithFunction || match(CLASSTOKEN)) {
>             isFunctionOrClassDeclaration = true;
>@@ -2844,7 +3046,11 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExportDeclara
>             if (match(FUNCTION)) {
>                 DepthManager statementDepth(&m_statementDepth);
>                 m_statementDepth = 1;
>-                result = parseFunctionDeclaration(context);
>+                if (UNLIKELY(isAsyncFunctionExport)) {
>+                    ASSERT(m_runtimeFlags.isAsyncAwaitEnabled());
>+                    result = parseAsyncFunctionDeclaration(context);
>+                } else
>+                    result = parseFunctionDeclaration(context);
>             } else {
>                 ASSERT(match(CLASSTOKEN));
>                 result = parseClassDeclaration(context);
>@@ -2859,9 +3065,11 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExportDeclara
>             //
>             // In the above example, *default* is the invisible variable to the users.
>             // We use the private symbol to represent the name of this variable.
>+            ExpressionErrorClassifier classifier(this);
>             JSTokenLocation location(tokenLocation());
>             JSTextPosition start = tokenStartPosition();
>             TreeExpression expression = parseAssignmentExpression(context);
>+
>             failIfFalse(expression, "Cannot parse expression");
> 
>             DeclarationResultMask declarationResult = declareVariable(&m_vm->propertyNames->starDefaultPrivateName, DeclarationType::ConstDeclaration);
>@@ -2963,6 +3171,17 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExportDeclara
>             result = parseClassDeclaration(context, ExportType::Exported);
>             break;
> 
>+        case ASYNC:
>+            if (m_runtimeFlags.isAsyncAwaitEnabled()) {
>+                SavePoint beforeAsync = createSavePoint();
>+                next();
>+                if (match(FUNCTION) && !m_lexer->prevTerminator()) {
>+                    result = parseAsyncFunctionDeclaration(context, ExportType::Exported);
>+                    break;
>+                }
>+                restoreSavePoint(beforeAsync);
>+            }
>+            FALLTHROUGH;
>         default:
>             failWithMessage("Expected either a declaration or a variable statement");
>             break;
>@@ -3035,10 +3254,10 @@ template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmen
>     bool maybeAssignmentPattern = match(OPENBRACE) || match(OPENBRACKET);
> #if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
>     bool wasOpenParen = match(OPENPAREN);
>-    bool isValidArrowFunctionStart = match(OPENPAREN) || match(IDENT);
>+    bool isValidArrowFunctionStart = match(OPENPAREN) || matchSpecIdentifier();
>     SavePoint savePoint = createSavePoint();
>     size_t usedVariablesSize;
>-    if (wasOpenParen) {
>+    if (wasOpenParen || (m_runtimeFlags.isAsyncAwaitEnabled() && match(ASYNC))) {
>         usedVariablesSize = currentScope()->currentUsedVariablesSize();
>         currentScope()->pushUsedVariableSet();
>     }
>@@ -3049,30 +3268,45 @@ template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmen
>         return parseYieldExpression(context);
> #endif
> 
>-    TreeExpression lhs = parseConditionalExpression(context);
>+    TreeExpression lhs = 0;
> 
> #if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
>-    if (isValidArrowFunctionStart && !match(EOFTOK)) {
>-        bool isArrowFunctionToken = match(ARROWFUNCTION);
>-        if (!lhs || isArrowFunctionToken) {
>-            SavePoint errorRestorationSavePoint = createSavePointForError();
>-            String oldErrorMessage = m_errorMessage;
>-            String oldLexerErrorMessage = m_lexer->getErrorMessage();
>-            bool hasLexerError = m_lexer->sawError();
>-            restoreSavePoint(savePoint);
>-            if (isArrowFunctionParameters()) {
>-                if (wasOpenParen)
>-                    currentScope()->revertToPreviousUsedVariables(usedVariablesSize);
>-                return parseArrowFunctionExpression(context);
>+    {
>+        ExpressionErrorClassifier arrowFunctionClassifier(this);
>+        lhs = parseConditionalExpression(context);
>+        if (isValidArrowFunctionStart && !match(EOFTOK)) {
>+            bool isArrowFunctionToken = match(ARROWFUNCTION);
>+
>+            if (!lhs || isArrowFunctionToken) {
>+                SavePoint errorRestorationSavePoint = createSavePointForError();
>+                String oldErrorMessage = m_errorMessage;
>+                String oldLexerErrorMessage = m_lexer->getErrorMessage();
>+                bool hasLexerError = m_lexer->sawError();
>+                restoreSavePoint(savePoint);
>+                bool isAsyncArrow = false;
>+                if (UNLIKELY(arrowFunctionClassifier.indicatesPossibleAsyncArrowFunction())) {
>+                    ASSERT(m_runtimeFlags.isAsyncAwaitEnabled());
>+                    ASSERT(match(ASYNC));
>+                    next();
>+                    isAsyncArrow = !m_lexer->prevTerminator();
>+                }
>+                if (isArrowFunctionParameters()) {
>+                    if (wasOpenParen || isAsyncArrow)
>+                        currentScope()->revertToPreviousUsedVariables(usedVariablesSize);
>+                    return parseArrowFunctionExpression(context, isAsyncArrow);
>+                }
>+
>+                restoreSavePointWithError(errorRestorationSavePoint, oldErrorMessage);
>+                m_lexer->setErrorMessage(oldLexerErrorMessage);
>+                m_lexer->setSawError(hasLexerError);
>+                if (isArrowFunctionToken)
>+                    failDueToUnexpectedToken();
>             }
>-            restoreSavePointWithError(errorRestorationSavePoint, oldErrorMessage);
>-            m_lexer->setErrorMessage(oldLexerErrorMessage);
>-            m_lexer->setSawError(hasLexerError);
>-            if (isArrowFunctionToken)
>-                failDueToUnexpectedToken();
>         }
>+        arrowFunctionClassifier.propagateExpressionErrorClass();
>     }
>-
>+#else
>+    lhs = parseConditionalExpression(context);
> #endif
> 
>     if (!lhs && (!maybeAssignmentPattern || !classifier.indicatesPossiblePattern()))
>@@ -3196,6 +3430,23 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseYieldExpress
> }
> 
> template <typename LexerType>
>+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseAwaitExpression(TreeBuilder& context)
>+{
>+    // AwaitExpression desugared to YieldExpression
>+    ASSERT(match(AWAIT));
>+    ASSERT(currentScope()->isAsyncFunction());
>+    failIfTrue(m_parserState.functionParsePhase == FunctionParsePhase::Parameters, "Cannot use await expression within parameters");
>+    JSTokenLocation location(tokenLocation());
>+    JSTextPosition divotStart = tokenStartPosition();
>+    next();
>+    JSTextPosition argumentStart = tokenStartPosition();
>+    TreeExpression argument = parseUnaryExpression(context);
>+    failIfFalse(argument, "Failed to parse await expression");
>+    const bool delegate = false;
>+    return context.createYield(location, argument, delegate, divotStart, argumentStart, lastTokenEndPosition());
>+}
>+
>+template <typename LexerType>
> template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalExpression(TreeBuilder& context)
> {
>     JSTokenLocation location(tokenLocation());
>@@ -3280,19 +3531,29 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB
> {
>     bool wasIdent = false;
>     bool isGenerator = false;
>+    bool isAsyncMethod = false;
>+    bool parsingAsyncMethodName = false;
>+
> #if ENABLE(ES6_GENERATORS)
>     if (consume(TIMES))
>         isGenerator = true;
> #endif
>+
>+parseProperty:
>     switch (m_token.m_type) {
>     namedProperty:
>+    case ASYNC:
>+        if (m_runtimeFlags.isAsyncAwaitEnabled() && !parsingAsyncMethodName)
>+            isAsyncMethod = !isGenerator;
>+        FALLTHROUGH;
>+    case AWAIT:
>     case IDENT:
>         wasIdent = true;
>         FALLTHROUGH;
>     case STRING: {
>         const Identifier* ident = m_token.m_data.ident;
>         unsigned getterOrSetterStartOffset = tokenStart();
>-        if (complete || (wasIdent && !isGenerator && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set)))
>+        if (complete || (wasIdent && !isGenerator && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set || isAsyncMethod)))
>             nextExpectIdentifier(LexerFlagsIgnoreReservedWords);
>         else
>             nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
>@@ -3306,10 +3567,11 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB
>         }
> 
>         if (match(OPENPAREN)) {
>-            auto method = parsePropertyMethod(context, ident, isGenerator);
>+            auto method = parsePropertyMethod(context, ident, isGenerator, isAsyncMethod);
>             propagateError();
>             return context.createProperty(ident, method, PropertyNode::Constant, PropertyNode::KnownDirect, complete);
>         }
>+
>         failIfTrue(isGenerator, "Expected a parenthesis for argument list");
> 
>         failIfFalse(wasIdent, "Expected an identifier as property name");
>@@ -3332,6 +3594,11 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB
>             type = PropertyNode::Getter;
>         else if (*ident == m_vm->propertyNames->set)
>             type = PropertyNode::Setter;
>+        else if (isAsyncMethod && !parsingAsyncMethodName) {
>+            parsingAsyncMethodName = true;
>+            failIfTrue(m_lexer->prevTerminator(), "Expected a property name following keyword 'async'");
>+            goto parseProperty;
>+        }
>         else
>             failWithMessage("Expected a ':' following the property name '", ident->impl(), "'");
>         return parseGetterSetter(context, complete, type, getterOrSetterStartOffset);
>@@ -3343,7 +3610,7 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB
> 
>         if (match(OPENPAREN)) {
>             const Identifier& ident = m_parserArena.identifierArena().makeNumericIdentifier(const_cast<VM*>(m_vm), propertyName);
>-            auto method = parsePropertyMethod(context, &ident, isGenerator);
>+            auto method = parsePropertyMethod(context, &ident, isGenerator, isAsyncMethod);
>             propagateError();
>             return context.createProperty(&ident, method, PropertyNode::Constant, PropertyNode::Unknown, complete);
>         }
>@@ -3362,7 +3629,7 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB
>         handleProductionOrFail(CLOSEBRACKET, "]", "end", "computed property name");
> 
>         if (match(OPENPAREN)) {
>-            auto method = parsePropertyMethod(context, &m_vm->propertyNames->nullIdentifier, isGenerator);
>+            auto method = parsePropertyMethod(context, &m_vm->propertyNames->nullIdentifier, isGenerator, isAsyncMethod);
>             propagateError();
>             return context.createProperty(propertyName, method, static_cast<PropertyNode::Type>(PropertyNode::Constant | PropertyNode::Computed), PropertyNode::KnownDirect, complete);
>         }
>@@ -3381,12 +3648,12 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB
> }
> 
> template <typename LexerType>
>-template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator)
>+template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator, bool isAsync)
> {
>     JSTokenLocation methodLocation(tokenLocation());
>     unsigned methodStart = tokenStart();
>     ParserFunctionInfo<TreeBuilder> methodInfo;
>-    SourceParseMode parseMode = isGenerator ? SourceParseMode::GeneratorWrapperFunctionMode : SourceParseMode::MethodMode;
>+    SourceParseMode parseMode = isGenerator ? SourceParseMode::GeneratorWrapperFunctionMode : isAsync ? SourceParseMode::AsyncMethodMode : SourceParseMode::MethodMode;
>     failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, parseMode, false, ConstructorKind::None, SuperBinding::NotNeeded, methodStart, methodInfo, FunctionDefinitionType::Method)), "Cannot parse this method");
>     methodInfo.name = methodName;
>     return context.createMethodDefinition(methodLocation, methodInfo);
>@@ -3646,6 +3913,20 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseFunctionExpr
> }
> 
> template <typename LexerType>
>+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseAsyncFunctionExpression(TreeBuilder& context)
>+{
>+    ASSERT(match(FUNCTION));
>+    JSTokenLocation location(tokenLocation());
>+    unsigned functionKeywordStart = tokenStart();
>+    next();
>+    ParserFunctionInfo<TreeBuilder> functionInfo;
>+    functionInfo.name = &m_vm->propertyNames->nullIdentifier;
>+    SourceParseMode parseMode = SourceParseMode::AsyncFunctionMode;
>+    failIfFalse(parseFunctionInfo(context, FunctionNoRequirements, parseMode, false, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, functionInfo, FunctionDefinitionType::Expression), "Cannot parse async function expression");
>+    return context.createFunctionExpr(location, functionInfo);
>+}
>+
>+template <typename LexerType>
> template <class TreeBuilder> typename TreeBuilder::TemplateString Parser<LexerType>::parseTemplateString(TreeBuilder& context, bool isTemplateHead, typename LexerType::RawStringsBuildMode rawStringsBuildMode, bool& elementIsTail)
> {
>     if (!isTemplateHead) {
>@@ -3726,6 +4007,10 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpre
>         TreeExpression result = parseExpression(context);
>         m_parserState.nonLHSCount = oldNonLHSCount;
>         handleProductionOrFail(CLOSEPAREN, ")", "end", "compound expression");
>+        if (UNLIKELY(match(ARROWFUNCTION))) {
>+            forceClassifyExpressionError(ErrorIndicatesArrowFunction);
>+            return 0;
>+        }
>         return result;
>     }
>     case THISTOKEN: {
>@@ -3735,14 +4020,18 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpre
>             currentScope()->setInnerArrowFunctionUsesThis();
>         return context.createThisExpr(location, m_thisTDZMode);
>     }
>+    case ASYNC:
>+    case AWAIT:
>     case IDENT: {
>     identifierExpression:
>         JSTextPosition start = tokenStartPosition();
>         const Identifier* ident = m_token.m_data.ident;
>         JSTokenLocation location(tokenLocation());
>         next();
>-        if (UNLIKELY(match(ARROWFUNCTION)))
>+        if (UNLIKELY(match(ARROWFUNCTION))) {
>+            classifyExpressionError(ErrorIndicatesArrowFunction);
>             return 0;
>+        }
>         currentScope()->useVariable(ident, m_vm->propertyNames->eval == *ident);
>         m_parserState.lastIdentifier = ident;
>         return context.createResolve(location, *ident, start, lastTokenEndPosition());
>@@ -3921,10 +4210,23 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres
>         base = context.createSuperExpr(location);
>         next();
>         currentFunctionScope()->setNeedsSuperBinding();
>-    } else if (!baseIsNewTarget)
>+    } else if (!baseIsNewTarget) {
>         base = parsePrimaryExpression(context);
>+        failIfFalse(base, "Cannot parse base expression");
>+        if (UNLIKELY(m_runtimeFlags.isAsyncAwaitEnabled() && m_lexer->prevToken() == ASYNC && context.isResolve(base) && !m_lexer->prevTerminator())) {
>+            if (match(FUNCTION)) {
>+                base = parseAsyncFunctionExpression(context);
>+                failIfFalse(base, "Failed to parse async function expression");
>+            } else if (matchSpecIdentifier()) {
>+                // AsyncArrowFunction
>+                forceClassifyExpressionError(ErrorIndicatesAsyncArrowFunction);
>+                return 0;
>+            }
>+        }
>+    }
> 
>     failIfFalse(base, "Cannot parse base expression");
>+
>     while (true) {
>         location = tokenLocation();
>         switch (m_token.m_type) {
>@@ -3956,7 +4258,10 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres
>                 base = context.createNewExpr(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition());
>             } else {
>                 JSTextPosition expressionEnd = lastTokenEndPosition();
>+                bool isCallAsync = m_runtimeFlags.isAsyncAwaitEnabled() && m_lexer->prevToken() == ASYNC && context.isResolve(base);
>                 TreeArguments arguments = parseArguments(context);
>+                if (UNLIKELY(isCallAsync && (!arguments || match(ARROWFUNCTION))))
>+                    forceClassifyExpressionError(ErrorIndicatesAsyncArrowFunction);
>                 failIfFalse(arguments, "Cannot parse call arguments");
>                 if (baseIsSuper) {
>                     currentFunctionScope()->setHasDirectSuper();
>@@ -3989,6 +4294,7 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres
>             m_parserState.nonLHSCount = nonLHSCount;
>             break;
>         }
>+
>         default:
>             goto endMemberExpression;
>         }
>@@ -4002,7 +4308,7 @@ endMemberExpression:
> }
> 
> template <typename LexerType>
>-template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrowFunctionExpression(TreeBuilder& context)
>+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrowFunctionExpression(TreeBuilder& context, bool isAsync)
> {
>     JSTokenLocation location;
> 
>@@ -4010,7 +4316,9 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrowFunctio
>     location = tokenLocation();
>     ParserFunctionInfo<TreeBuilder> info;
>     info.name = &m_vm->propertyNames->nullIdentifier;
>-    failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SourceParseMode::ArrowFunctionMode, true, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, info, FunctionDefinitionType::Expression)), "Cannot parse arrow function expression");
>+    SourceParseMode parseMode = isAsync ? SourceParseMode::AsyncArrowFunctionMode : SourceParseMode::ArrowFunctionMode;
>+
>+    failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, parseMode, true, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, info, FunctionDefinitionType::Expression)), "Cannot parse arrow function expression");
> 
>     return context.createArrowFunctionExpr(location, info);
> }
>@@ -4054,6 +4362,10 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpress
>     bool modifiesExpr = false;
>     bool requiresLExpr = false;
>     unsigned lastOperator = 0;
>+
>+    if (m_runtimeFlags.isAsyncAwaitEnabled() && match(AWAIT) && currentFunctionScope()->isAsyncFunction())
>+        return parseAwaitExpression(context);
>+
>     while (isUnaryOp(m_token.m_type)) {
>         if (strictMode()) {
>             switch (m_token.m_type) {
>@@ -4234,7 +4546,9 @@ template <typename LexerType> void Parser<LexerType>::printUnexpectedTokenText(W
>     case INVALID_PRIVATE_NAME_ERRORTOK:
>         out.print("Invalid private name '", getToken(), "'");
>         return;
>-            
>+
>+    case ASYNC:
>+    case AWAIT:
>     case IDENT:
>         out.print("Unexpected identifier '", getToken(), "'");
>         return;
>diff --git a/Source/JavaScriptCore/parser/Parser.h b/Source/JavaScriptCore/parser/Parser.h
>index 838f692a1a2080e8cc4e52d5b0bc3ead9c6c5de9..2bdfc27f8db61833a53a50076a3bf01f526400d2 100644
>--- a/Source/JavaScriptCore/parser/Parser.h
>+++ b/Source/JavaScriptCore/parser/Parser.h
>@@ -33,6 +33,7 @@
> #include "ParserError.h"
> #include "ParserFunctionInfo.h"
> #include "ParserTokens.h"
>+#include "RuntimeFlags.h"
> #include "SourceProvider.h"
> #include "SourceProviderCache.h"
> #include "SourceProviderCacheItem.h"
>@@ -124,7 +125,7 @@ ALWAYS_INLINE static bool isEvalOrArgumentsIdentifier(const VM* vm, const Identi
> }
> ALWAYS_INLINE static bool isIdentifierOrKeyword(const JSToken& token)
> {
>-    return token.m_type == IDENT || token.m_type & KeywordTokenFlag;
>+    return token.m_type == IDENT || token.m_type == ASYNC || token.m_type == AWAIT || token.m_type & KeywordTokenFlag;
> }
> 
> class ModuleScopeData : public RefCounted<ModuleScopeData> {
>@@ -152,7 +153,7 @@ struct Scope {
>     WTF_MAKE_NONCOPYABLE(Scope);
> 
> public:
>-    Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode, bool isArrowFunction)
>+    Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode, bool isArrowFunction, bool isAsyncFunction)
>         : m_vm(vm)
>         , m_shadowsArguments(false)
>         , m_usesEval(false)
>@@ -167,6 +168,8 @@ public:
>         , m_isGeneratorBoundary(false)
>         , m_isArrowFunction(isArrowFunction)
>         , m_isArrowFunctionBoundary(false)
>+        , m_isAsyncFunction(isAsyncFunction)
>+        , m_isAsyncFunctionBoundary(false)
>         , m_isLexicalScope(false)
>         , m_isFunctionBoundary(false)
>         , m_isValidStrictMode(true)
>@@ -255,6 +258,14 @@ public:
>     void setSourceParseMode(SourceParseMode mode)
>     {
>         switch (mode) {
>+        case SourceParseMode::AsyncArrowFunctionBodyMode:
>+            setIsAsyncArrowFunctionBody();
>+            break;
>+
>+        case SourceParseMode::AsyncFunctionBodyMode:
>+            setIsAsyncFunctionBody();
>+            break;
>+
>         case SourceParseMode::GeneratorBodyMode:
>             setIsGenerator();
>             break;
>@@ -274,6 +285,15 @@ public:
>             setIsArrowFunction();
>             break;
> 
>+        case SourceParseMode::AsyncFunctionMode:
>+        case SourceParseMode::AsyncMethodMode:
>+            setIsAsyncFunction();
>+            break;
>+
>+        case SourceParseMode::AsyncArrowFunctionMode:
>+            setIsAsyncArrowFunction();
>+            break;
>+
>         case SourceParseMode::ProgramMode:
>             break;
> 
>@@ -288,6 +308,8 @@ public:
>     bool isFunctionBoundary() const { return m_isFunctionBoundary; }
>     bool isGenerator() const { return m_isGenerator; }
>     bool isGeneratorBoundary() const { return m_isGeneratorBoundary; }
>+    bool isAsyncFunction() const { return m_isAsyncFunction; }
>+    bool isAsyncFunctionBoundary() const { return m_isAsyncFunctionBoundary; }
> 
>     bool hasArguments() const { return m_hasArguments; }
> 
>@@ -317,6 +339,11 @@ public:
>         return *m_moduleScopeData;
>     }
> 
>+    bool isModule() const
>+    {
>+        return !!m_moduleScopeData;
>+    }
>+
>     void computeLexicallyCapturedVariablesAndPurgeCandidates()
>     {
>         // Because variables may be defined at any time in the range of a lexical scope, we must
>@@ -711,6 +738,8 @@ private:
>         m_isGeneratorBoundary = false;
>         m_isArrowFunctionBoundary = false;
>         m_isArrowFunction = false;
>+        m_isAsyncFunctionBoundary = false;
>+        m_isAsyncFunction = false;
>     }
> 
>     void setIsGeneratorFunction()
>@@ -734,6 +763,34 @@ private:
>         m_isArrowFunction = true;
>     }
> 
>+    void setIsAsyncArrowFunction()
>+    {
>+        setIsArrowFunction();
>+        m_isAsyncFunction = true;
>+    }
>+
>+    void setIsAsyncFunction()
>+    {
>+        setIsFunction();
>+        m_isAsyncFunction = true;
>+    }
>+
>+    void setIsAsyncFunctionBody()
>+    {
>+        setIsFunction();
>+        m_hasArguments = false;
>+        m_isAsyncFunction = true;
>+        m_isAsyncFunctionBoundary = true;
>+    }
>+
>+    void setIsAsyncArrowFunctionBody()
>+    {
>+        setIsArrowFunction();
>+        m_hasArguments = false;
>+        m_isAsyncFunction = true;
>+        m_isAsyncFunctionBoundary = true;
>+    }
>+
>     void setIsModule()
>     {
>         m_moduleScopeData = ModuleScopeData::create();
>@@ -753,6 +810,8 @@ private:
>     bool m_isGeneratorBoundary;
>     bool m_isArrowFunction;
>     bool m_isArrowFunctionBoundary;
>+    bool m_isAsyncFunction;
>+    bool m_isAsyncFunctionBoundary;
>     bool m_isLexicalScope;
>     bool m_isFunctionBoundary;
>     bool m_isValidStrictMode;
>@@ -827,7 +886,7 @@ class Parser {
>     WTF_MAKE_FAST_ALLOCATED;
> 
> public:
>-    Parser(VM*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode, SuperBinding, ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode = ThisTDZMode::CheckIfNeeded, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None);
>+    Parser(VM*, RuntimeFlags, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode, SuperBinding, ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode = ThisTDZMode::CheckIfNeeded, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None);
>     ~Parser();
> 
>     template <class ParsedNode>
>@@ -852,6 +911,21 @@ private:
>         bool m_oldAllowsIn;
>     };
> 
>+    struct AllowAwaitOverride {
>+        AllowAwaitOverride(Parser* parser, bool value)
>+            : m_parser(parser)
>+            , m_oldAllowsAwait(parser->m_allowsAwait)
>+        {
>+            parser->m_allowsAwait = value;
>+        }
>+        ~AllowAwaitOverride()
>+        {
>+            m_parser->m_allowsAwait = m_oldAllowsAwait;
>+        }
>+        Parser* m_parser;
>+        bool m_oldAllowsAwait;
>+    };
>+
>     struct AutoPopScopeRef : public ScopeRef {
>         AutoPopScopeRef(Parser* parser, ScopeRef scope)
>         : ScopeRef(scope)
>@@ -916,8 +990,10 @@ private:
>     };
> 
>     enum ExpressionErrorClass {
>-        ErrorIndicatesNothing,
>-        ErrorIndicatesPattern
>+        ErrorIndicatesNothing = 0,
>+        ErrorIndicatesPattern,
>+        ErrorIndicatesArrowFunction,
>+        ErrorIndicatesAsyncArrowFunction
>     };
> 
>     struct ExpressionErrorClassifier {
>@@ -941,6 +1017,11 @@ private:
>             m_class = classification;
>         }
> 
>+        void forceClassifyExpressionError(ExpressionErrorClass classification)
>+        {
>+            m_class = classification;
>+        }
>+
>         void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
>         {
>             if (m_class != oldClassification)
>@@ -950,12 +1031,13 @@ private:
> 
>         void propagateExpressionErrorClass()
>         {
>-            if (m_previous && m_class != ErrorIndicatesNothing)
>+            if (m_previous)
>                 m_previous->m_class = m_class;
>         }
> 
>         bool indicatesPossiblePattern() const { return m_class == ErrorIndicatesPattern; }
>-
>+        bool indicatesPossibleArrowFunction() const { return m_class == ErrorIndicatesArrowFunction || indicatesPossibleAsyncArrowFunction(); }
>+        bool indicatesPossibleAsyncArrowFunction() const { return m_class == ErrorIndicatesAsyncArrowFunction; }
>     private:
>         ExpressionErrorClass m_class;
>         ExpressionErrorClassifier* m_previous;
>@@ -968,6 +1050,12 @@ private:
>             m_expressionErrorClassifier->classifyExpressionError(classification);
>     }
> 
>+    ALWAYS_INLINE void forceClassifyExpressionError(ExpressionErrorClass classification)
>+    {
>+        if (m_expressionErrorClassifier)
>+            m_expressionErrorClassifier->forceClassifyExpressionError(classification);
>+    }
>+
>     ALWAYS_INLINE void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
>     {
>         if (m_expressionErrorClassifier)
>@@ -989,6 +1077,19 @@ private:
>         return DestructuringKind::DestructureToVariables;
>     }
> 
>+    ALWAYS_INLINE const char* declarationTypeToVariableKind(DeclarationType type)
>+    {
>+        switch (type) {
>+        case DeclarationType::VarDeclaration:
>+            return "variable name";
>+        case DeclarationType::LetDeclaration:
>+        case DeclarationType::ConstDeclaration:
>+            return "lexical variable name";
>+        }
>+        RELEASE_ASSERT_NOT_REACHED();
>+        return "invalid";
>+    }
>+
>     ALWAYS_INLINE AssignmentContext assignmentContextFromDeclarationType(DeclarationType type)
>     {
>         switch (type) {
>@@ -1045,7 +1146,7 @@ private:
>     {
>         unsigned i = m_scopeStack.size() - 1;
>         ASSERT(i < m_scopeStack.size() && m_scopeStack.size());
>-        while (i && (!m_scopeStack[i].isFunctionBoundary() || m_scopeStack[i].isGeneratorBoundary() || m_scopeStack[i].isArrowFunctionBoundary()))
>+        while (i && (!m_scopeStack[i].isFunctionBoundary() || m_scopeStack[i].isGeneratorBoundary() || m_scopeStack[i].isArrowFunctionBoundary() || m_scopeStack[i].isAsyncFunctionBoundary()))
>             i--;
>         return ScopeRef(&m_scopeStack, i);
>     }
>@@ -1056,13 +1157,15 @@ private:
>         bool isStrict = false;
>         bool isGenerator = false;
>         bool isArrowFunction = false;
>+        bool isAsyncFunction = false;
>         if (!m_scopeStack.isEmpty()) {
>             isStrict = m_scopeStack.last().strictMode();
>             isFunction = m_scopeStack.last().isFunction();
>             isGenerator = m_scopeStack.last().isGenerator();
>             isArrowFunction = m_scopeStack.last().isArrowFunction();
>+            isAsyncFunction = m_scopeStack.last().isAsyncFunction();
>         }
>-        m_scopeStack.constructAndAppend(m_vm, isFunction, isGenerator, isStrict, isArrowFunction);
>+        m_scopeStack.constructAndAppend(m_vm, isFunction, isGenerator, isStrict, isArrowFunction, isAsyncFunction);
>         return currentScope();
>     }
> 
>@@ -1074,7 +1177,7 @@ private:
>         
>         if (m_scopeStack.last().isArrowFunction())
>             m_scopeStack.last().setInnerArrowFunctionUsesEvalAndUseArgumentsIfNeeded();
>-        
>+
>         if (!(m_scopeStack.last().isFunctionBoundary() && !m_scopeStack.last().isArrowFunctionBoundary()))
>             m_scopeStack[m_scopeStack.size() - 2].mergeInnerArrowFunctionFeatures(m_scopeStack.last().innerArrowFunctionFeatures());
> 
>@@ -1382,7 +1485,7 @@ private:
>     // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors
>     ALWAYS_INLINE bool matchSpecIdentifier(bool inGenerator)
>     {
>-        return match(IDENT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(inGenerator);
>+        return match(IDENT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(inGenerator) || match(ASYNC) || match(AWAIT);
>     }
> 
>     ALWAYS_INLINE bool matchSpecIdentifier()
>@@ -1392,11 +1495,13 @@ private:
> 
>     template <class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&, SourceElementsMode);
>     template <class TreeBuilder> TreeSourceElements parseGeneratorFunctionSourceElements(TreeBuilder&, SourceElementsMode);
>+    template <class TreeBuilder> TreeSourceElements parseAsyncFunctionSourceElements(TreeBuilder&, SourceParseMode, bool isArrowFunctionBodyExpression, SourceElementsMode);
>     template <class TreeBuilder> TreeStatement parseStatementListItem(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength);
>     template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength = 0);
>     enum class ExportType { Exported, NotExported };
>     template <class TreeBuilder> TreeStatement parseClassDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
>     template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
>+    template <class TreeBuilder> TreeStatement parseAsyncFunctionDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
>     template <class TreeBuilder> TreeStatement parseVariableDeclaration(TreeBuilder&, DeclarationType, ExportType = ExportType::NotExported);
>     template <class TreeBuilder> TreeStatement parseDoWhileStatement(TreeBuilder&);
>     template <class TreeBuilder> TreeStatement parseWhileStatement(TreeBuilder&);
>@@ -1423,23 +1528,25 @@ private:
>     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseConditionalExpression(TreeBuilder&);
>     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseBinaryExpression(TreeBuilder&);
>     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseUnaryExpression(TreeBuilder&);
>+    template <class TreeBuilder> NEVER_INLINE TreeExpression parseAwaitExpression(TreeBuilder&);
>     template <class TreeBuilder> TreeExpression parseMemberExpression(TreeBuilder&);
>     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parsePrimaryExpression(TreeBuilder&);
>     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArrayLiteral(TreeBuilder&);
>     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseObjectLiteral(TreeBuilder&);
>     template <class TreeBuilder> NEVER_INLINE TreeExpression parseStrictObjectLiteral(TreeBuilder&);
>     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseFunctionExpression(TreeBuilder&);
>+    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseAsyncFunctionExpression(TreeBuilder&);
>     template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&);
>     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArgument(TreeBuilder&, ArgumentType&);
>     template <class TreeBuilder> TreeProperty parseProperty(TreeBuilder&, bool strict);
>-    template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator);
>+    template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator, bool isAsyncMethod);
>     template <class TreeBuilder> TreeProperty parseGetterSetter(TreeBuilder&, bool strict, PropertyNode::Type, unsigned getterOrSetterStartOffset, ConstructorKind = ConstructorKind::None, SuperBinding = SuperBinding::NotNeeded);
>     template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, const JSTokenLocation&, int, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind, SuperBinding, FunctionBodyType, unsigned, SourceParseMode);
>     template <class TreeBuilder> ALWAYS_INLINE bool parseFormalParameters(TreeBuilder&, TreeFormalParameterList, unsigned&);
>     enum VarDeclarationListContext { ForLoopContext, VarDeclarationContext };
>     template <class TreeBuilder> TreeExpression parseVariableDeclarationList(TreeBuilder&, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext, DeclarationType, ExportType, bool& forLoopConstDoesNotHaveInitializer);
>     template <class TreeBuilder> TreeSourceElements parseArrowFunctionSingleExpressionBodySourceElements(TreeBuilder&);
>-    template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&);
>+    template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&, bool isAsync);
>     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createBindingPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier&, JSToken, AssignmentContext, const Identifier** duplicateIdentifier);
>     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createAssignmentElement(TreeBuilder&, TreeExpression&, const JSTextPosition&, const JSTextPosition&);
>     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseBindingOrAssignmentElement(TreeBuilder& context, DestructuringKind, ExportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth);
>@@ -1502,6 +1609,21 @@ private:
>         return !m_errorMessage.isNull();
>     }
> 
>+    bool isDisallowedIdentifierAwait(const JSToken& token)
>+    {
>+        return token.m_type == AWAIT && (currentScope()->isAsyncFunctionBoundary() || currentScope()->isModule() || !m_allowsAwait);
>+    }
>+
>+    const char* disallowedIdentifierAwaitReason()
>+    {
>+        if (!m_allowsAwait || currentScope()->isAsyncFunctionBoundary())
>+            return "in an async function";
>+        if (currentScope()->isModule())
>+            return "in a module";
>+        ASSERT(false);
>+        return "(unknown)";
>+    }
>+
>     enum class FunctionParsePhase { Parameters, Body };
>     struct ParserState {
>         int assignmentCount { 0 };
>@@ -1595,7 +1717,9 @@ private:
>     bool m_hasStackOverflow;
>     String m_errorMessage;
>     JSToken m_token;
>+    RuntimeFlags m_runtimeFlags;
>     bool m_allowsIn;
>+    bool m_allowsAwait;
>     JSTextPosition m_lastTokenEndPosition;
>     bool m_syntaxAlreadyValidated;
>     int m_statementDepth;
>@@ -1728,7 +1852,7 @@ std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const I
> 
> template <class ParsedNode>
> std::unique_ptr<ParsedNode> parse(
>-    VM* vm, const SourceCode& source,
>+    VM* vm, RuntimeFlags runtimeFlags, const SourceCode& source,
>     const Identifier& name, JSParserBuiltinMode builtinMode,
>     JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding,
>     ParserError& error, JSTextPosition* positionBeforeLastNewline = nullptr,
>@@ -1737,7 +1861,7 @@ std::unique_ptr<ParsedNode> parse(
> {
>     ASSERT(!source.provider()->source().isNull());
>     if (source.provider()->source().is8Bit()) {
>-        Parser<Lexer<LChar>> parser(vm, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, thisTDZMode, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
>+        Parser<Lexer<LChar>> parser(vm, runtimeFlags, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, thisTDZMode, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
>         std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
>         if (positionBeforeLastNewline)
>             *positionBeforeLastNewline = parser.positionBeforeLastNewline();
>@@ -1748,7 +1872,7 @@ std::unique_ptr<ParsedNode> parse(
>         return result;
>     }
>     ASSERT_WITH_MESSAGE(defaultConstructorKind == ConstructorKind::None, "BuiltinExecutables::createDefaultConstructor should always use a 8-bit string");
>-    Parser<Lexer<UChar>> parser(vm, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, thisTDZMode, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
>+    Parser<Lexer<UChar>> parser(vm, runtimeFlags, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, thisTDZMode, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
>     std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
>     if (positionBeforeLastNewline)
>         *positionBeforeLastNewline = parser.positionBeforeLastNewline();
>diff --git a/Source/JavaScriptCore/parser/ParserModes.h b/Source/JavaScriptCore/parser/ParserModes.h
>index 3d7c559af3d6e2dc7fdd93f2556bd601cdf9b909..1b9c620cccc0183a4f4458d19d311b48832cceb6 100644
>--- a/Source/JavaScriptCore/parser/ParserModes.h
>+++ b/Source/JavaScriptCore/parser/ParserModes.h
>@@ -52,6 +52,11 @@ enum class SourceParseMode : uint8_t {
>     SetterMode,
>     MethodMode,
>     ArrowFunctionMode,
>+    AsyncFunctionBodyMode,
>+    AsyncArrowFunctionBodyMode,
>+    AsyncFunctionMode,
>+    AsyncMethodMode,
>+    AsyncArrowFunctionMode,
>     ProgramMode,
>     ModuleAnalyzeMode,
>     ModuleEvaluateMode
>@@ -67,6 +72,11 @@ inline bool isFunctionParseMode(SourceParseMode parseMode)
>     case SourceParseMode::SetterMode:
>     case SourceParseMode::MethodMode:
>     case SourceParseMode::ArrowFunctionMode:
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>         return true;
> 
>     case SourceParseMode::ProgramMode:
>@@ -78,6 +88,111 @@ inline bool isFunctionParseMode(SourceParseMode parseMode)
>     return false;
> }
> 
>+inline bool isAsyncFunctionParseMode(SourceParseMode parseMode)
>+{
>+    switch (parseMode) {
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+        return true;
>+
>+    case SourceParseMode::NormalFunctionMode:
>+    case SourceParseMode::GeneratorBodyMode:
>+    case SourceParseMode::GeneratorWrapperFunctionMode:
>+    case SourceParseMode::GetterMode:
>+    case SourceParseMode::SetterMode:
>+    case SourceParseMode::MethodMode:
>+    case SourceParseMode::ArrowFunctionMode:
>+    case SourceParseMode::ModuleAnalyzeMode:
>+    case SourceParseMode::ModuleEvaluateMode:
>+    case SourceParseMode::ProgramMode:
>+        return false;
>+    }
>+    RELEASE_ASSERT_NOT_REACHED();
>+    return false;
>+}
>+
>+inline bool isAsyncArrowFunctionParseMode(SourceParseMode parseMode)
>+{
>+    switch (parseMode) {
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>+        return true;
>+
>+    case SourceParseMode::NormalFunctionMode:
>+    case SourceParseMode::GeneratorBodyMode:
>+    case SourceParseMode::GeneratorWrapperFunctionMode:
>+    case SourceParseMode::GetterMode:
>+    case SourceParseMode::SetterMode:
>+    case SourceParseMode::MethodMode:
>+    case SourceParseMode::ArrowFunctionMode:
>+    case SourceParseMode::ModuleAnalyzeMode:
>+    case SourceParseMode::ModuleEvaluateMode:
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::ProgramMode:
>+        return false;
>+    }
>+
>+    RELEASE_ASSERT_NOT_REACHED();
>+    return false;
>+}
>+
>+inline bool isAsyncFunctionWrapperParseMode(SourceParseMode parseMode)
>+{
>+    switch (parseMode) {
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+        return true;
>+
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>+    case SourceParseMode::NormalFunctionMode:
>+    case SourceParseMode::GeneratorBodyMode:
>+    case SourceParseMode::GeneratorWrapperFunctionMode:
>+    case SourceParseMode::GetterMode:
>+    case SourceParseMode::SetterMode:
>+    case SourceParseMode::MethodMode:
>+    case SourceParseMode::ArrowFunctionMode:
>+    case SourceParseMode::ModuleAnalyzeMode:
>+    case SourceParseMode::ModuleEvaluateMode:
>+    case SourceParseMode::ProgramMode:
>+        return false;
>+    }
>+    RELEASE_ASSERT_NOT_REACHED();
>+    return false;
>+}
>+
>+inline bool isAsyncFunctionBodyParseMode(SourceParseMode parseMode)
>+{
>+    switch (parseMode) {
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>+        return true;
>+
>+    case SourceParseMode::NormalFunctionMode:
>+    case SourceParseMode::GeneratorBodyMode:
>+    case SourceParseMode::GeneratorWrapperFunctionMode:
>+    case SourceParseMode::GetterMode:
>+    case SourceParseMode::SetterMode:
>+    case SourceParseMode::MethodMode:
>+    case SourceParseMode::ArrowFunctionMode:
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+    case SourceParseMode::ModuleAnalyzeMode:
>+    case SourceParseMode::ModuleEvaluateMode:
>+    case SourceParseMode::ProgramMode:
>+        return false;
>+    }
>+    RELEASE_ASSERT_NOT_REACHED();
>+    return false;
>+}
>+
> inline bool isModuleParseMode(SourceParseMode parseMode)
> {
>     switch (parseMode) {
>@@ -92,6 +207,11 @@ inline bool isModuleParseMode(SourceParseMode parseMode)
>     case SourceParseMode::SetterMode:
>     case SourceParseMode::MethodMode:
>     case SourceParseMode::ArrowFunctionMode:
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>     case SourceParseMode::ProgramMode:
>         return false;
>     }
>@@ -112,6 +232,11 @@ inline bool isProgramParseMode(SourceParseMode parseMode)
>     case SourceParseMode::SetterMode:
>     case SourceParseMode::MethodMode:
>     case SourceParseMode::ArrowFunctionMode:
>+    case SourceParseMode::AsyncFunctionBodyMode:
>+    case SourceParseMode::AsyncFunctionMode:
>+    case SourceParseMode::AsyncMethodMode:
>+    case SourceParseMode::AsyncArrowFunctionMode:
>+    case SourceParseMode::AsyncArrowFunctionBodyMode:
>     case SourceParseMode::ModuleAnalyzeMode:
>     case SourceParseMode::ModuleEvaluateMode:
>         return false;
>diff --git a/Source/JavaScriptCore/parser/ParserTokens.h b/Source/JavaScriptCore/parser/ParserTokens.h
>index aff4a30133c751e61faf123ed5680e90da964717..ada0f17d7334929073945dfe96ee43f64aaf8f97 100644
>--- a/Source/JavaScriptCore/parser/ParserTokens.h
>+++ b/Source/JavaScriptCore/parser/ParserTokens.h
>@@ -113,6 +113,9 @@ enum JSTokenType {
>     OREQUAL,
>     DOTDOTDOT,
>     ARROWFUNCTION,
>+    // Untagged conditional keywords
>+    ASYNC,
>+    AWAIT,
>     LastUntaggedToken,
> 
>     // Begin tagged tokens
>diff --git a/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.cpp b/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..55246f9e2432e7a6df49f8c354d6202423a3331a
>--- /dev/null
>+++ b/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.cpp
>@@ -0,0 +1,77 @@
>+/*
>+ * Copyright (C) 2016 Caitlin Potter <caitp@igalia.com>.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "AsyncFunctionConstructor.h"
>+
>+#include "AsyncFunctionPrototype.h"
>+#include "FunctionConstructor.h"
>+#include "JSCInlines.h"
>+
>+namespace JSC {
>+
>+STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(AsyncFunctionConstructor);
>+
>+const ClassInfo AsyncFunctionConstructor::s_info = { "AsyncFunction", &Base::s_info, nullptr, CREATE_METHOD_TABLE(AsyncFunctionConstructor) };
>+
>+AsyncFunctionConstructor::AsyncFunctionConstructor(VM& vm, Structure* structure)
>+    : InternalFunction(vm, structure)
>+{
>+}
>+
>+void AsyncFunctionConstructor::finishCreation(VM& vm, AsyncFunctionPrototype* asyncFunctionPrototype)
>+{
>+    Base::finishCreation(vm, "AsyncFunction");
>+    putDirectWithoutTransition(vm, vm.propertyNames->prototype, asyncFunctionPrototype, DontEnum | DontDelete | ReadOnly);
>+
>+    // Number of arguments for constructor
>+    putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontDelete | DontEnum);
>+}
>+
>+static EncodedJSValue JSC_HOST_CALL callAsyncFunctionConstructor(ExecState* exec)
>+{
>+    ArgList args(exec);
>+    return JSValue::encode(constructFunction(exec, asInternalFunction(exec->callee())->globalObject(), args, FunctionConstructionMode::Async));
>+}
>+
>+static EncodedJSValue JSC_HOST_CALL constructAsyncFunctionConstructor(ExecState* exec)
>+{
>+    ArgList args(exec);
>+    return JSValue::encode(constructFunction(exec, asInternalFunction(exec->callee())->globalObject(), args, FunctionConstructionMode::Async));
>+}
>+
>+CallType AsyncFunctionConstructor::getCallData(JSCell*, CallData& callData)
>+{
>+    callData.native.function = callAsyncFunctionConstructor;
>+    return CallType::Host;
>+}
>+
>+ConstructType AsyncFunctionConstructor::getConstructData(JSCell*, ConstructData& constructData)
>+{
>+    constructData.native.function = constructAsyncFunctionConstructor;
>+    return ConstructType::Host;
>+}
>+
>+} // namespace JSC
>diff --git a/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.h b/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..3c4afcff8307af35dc4345421600c0e8d49a147d
>--- /dev/null
>+++ b/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.h
>@@ -0,0 +1,66 @@
>+/*
>+ * Copyright (C) 2016 Caitlin Potter <caitp@igalia.com>.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#ifndef AsyncFunctionConstructor_h
>+#define AsyncFunctionConstructor_h
>+
>+#include "InternalFunction.h"
>+
>+namespace WTF {
>+class TextPosition;
>+}
>+
>+namespace JSC {
>+
>+class AsyncFunctionPrototype;
>+
>+class AsyncFunctionConstructor : public InternalFunction {
>+public:
>+    typedef InternalFunction Base;
>+
>+    static AsyncFunctionConstructor* create(VM& vm, Structure* structure, AsyncFunctionPrototype* asyncFunctionPrototype)
>+    {
>+        AsyncFunctionConstructor* constructor = new (NotNull, allocateCell<AsyncFunctionConstructor>(vm.heap)) AsyncFunctionConstructor(vm, structure);
>+        constructor->finishCreation(vm, asyncFunctionPrototype);
>+        return constructor;
>+    }
>+
>+    DECLARE_INFO;
>+
>+    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
>+    {
>+        return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
>+    }
>+
>+private:
>+    AsyncFunctionConstructor(VM&, Structure*);
>+    void finishCreation(VM&, AsyncFunctionPrototype*);
>+    static ConstructType getConstructData(JSCell*, ConstructData&);
>+    static CallType getCallData(JSCell*, CallData&);
>+};
>+
>+} // namespace JSC
>+
>+#endif // AsyncFunctionConstructor_h
>diff --git a/Source/JavaScriptCore/runtime/AsyncFunctionPrototype.cpp b/Source/JavaScriptCore/runtime/AsyncFunctionPrototype.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..d8201e2e37d0a833086923a2797fe611f23074cb
>--- /dev/null
>+++ b/Source/JavaScriptCore/runtime/AsyncFunctionPrototype.cpp
>@@ -0,0 +1,56 @@
>+/*
>+ * Copyright (C) 2016 Caitlin Potter <caitp@igalia.com>.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "AsyncFunctionPrototype.h"
>+
>+#include "BuiltinExecutables.h"
>+#include "BuiltinNames.h"
>+#include "Error.h"
>+#include "JSArray.h"
>+#include "JSCInlines.h"
>+#include "JSFunction.h"
>+#include "JSString.h"
>+#include "JSStringBuilder.h"
>+#include "Lexer.h"
>+
>+namespace JSC {
>+
>+STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(AsyncFunctionPrototype);
>+
>+const ClassInfo AsyncFunctionPrototype::s_info = { "AsyncFunction", &Base::s_info, nullptr, CREATE_METHOD_TABLE(AsyncFunctionPrototype) };
>+
>+AsyncFunctionPrototype::AsyncFunctionPrototype(VM& vm, Structure* structure)
>+    : JSNonFinalObject(vm, structure)
>+{
>+}
>+
>+void AsyncFunctionPrototype::finishCreation(VM& vm)
>+{
>+    Base::finishCreation(vm);
>+    putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(0), DontDelete | ReadOnly | DontEnum);
>+}
>+
>+} // namespace JSC
>diff --git a/Source/JavaScriptCore/runtime/AsyncFunctionPrototype.h b/Source/JavaScriptCore/runtime/AsyncFunctionPrototype.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..171af42499e71181fd9650d10b2b3d0c6cedd9e7
>--- /dev/null
>+++ b/Source/JavaScriptCore/runtime/AsyncFunctionPrototype.h
>@@ -0,0 +1,60 @@
>+/*
>+ * Copyright (C) 2016 Caitlin Potter <caitp@igalia.com>.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#ifndef AsyncFunctionPrototype_h
>+#define AsyncFunctionPrototype_h
>+
>+#include "JSObject.h"
>+
>+namespace JSC {
>+
>+class AsyncFunctionPrototype : public JSNonFinalObject {
>+public:
>+    typedef JSNonFinalObject Base;
>+
>+    static AsyncFunctionPrototype* create(VM& vm, Structure* structure)
>+    {
>+        AsyncFunctionPrototype* prototype = new (NotNull, allocateCell<AsyncFunctionPrototype>(vm.heap)) AsyncFunctionPrototype(vm, structure);
>+        prototype->finishCreation(vm);
>+        return prototype;
>+    }
>+
>+    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
>+    {
>+        return Structure::create(vm, globalObject, proto, TypeInfo(ObjectType, StructureFlags), info());
>+    }
>+
>+    DECLARE_INFO;
>+
>+protected:
>+    void finishCreation(VM&);
>+
>+private:
>+    AsyncFunctionPrototype(VM&, Structure*);
>+};
>+
>+} // namespace JSC
>+
>+#endif // AsyncFunctionPrototype_h
>diff --git a/Source/JavaScriptCore/runtime/CodeCache.cpp b/Source/JavaScriptCore/runtime/CodeCache.cpp
>index 674a518b92658535bb62b2ab95485fca778ad867..e2a2c7d99662b72745df6493b102cf8f2951a655 100644
>--- a/Source/JavaScriptCore/runtime/CodeCache.cpp
>+++ b/Source/JavaScriptCore/runtime/CodeCache.cpp
>@@ -84,7 +84,7 @@ template <> struct CacheTypes<UnlinkedModuleProgramCodeBlock> {
> };
> 
> template <class UnlinkedCodeBlockType, class ExecutableType>
>-UnlinkedCodeBlockType* CodeCache::getGlobalCodeBlock(VM& vm, ExecutableType* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, ThisTDZMode thisTDZMode, bool, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
>+UnlinkedCodeBlockType* CodeCache::getGlobalCodeBlock(VM& vm, const RuntimeFlags& runtimeFlags, ExecutableType* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, ThisTDZMode thisTDZMode, bool, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
> {
>     SourceCodeKey key = SourceCodeKey(source, String(), CacheTypes<UnlinkedCodeBlockType>::codeType, builtinMode, strictMode, thisTDZMode);
>     SourceCodeValue* cache = m_sourceCode.findCacheAndUpdateAge(key);
>@@ -104,7 +104,7 @@ UnlinkedCodeBlockType* CodeCache::getGlobalCodeBlock(VM& vm, ExecutableType* exe
>     typedef typename CacheTypes<UnlinkedCodeBlockType>::RootNode RootNode;
>     DerivedContextType derivedContextType = executable->derivedContextType();
>     std::unique_ptr<RootNode> rootNode = parse<RootNode>(
>-        &vm, source, Identifier(), builtinMode, strictMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, thisTDZMode, derivedContextType, evalContextType);
>+        &vm, runtimeFlags, source, Identifier(), builtinMode, strictMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, thisTDZMode, derivedContextType, evalContextType);
>     if (!rootNode)
>         return nullptr;
> 
>@@ -131,25 +131,25 @@ UnlinkedCodeBlockType* CodeCache::getGlobalCodeBlock(VM& vm, ExecutableType* exe
>     return unlinkedCodeBlock;
> }
> 
>-UnlinkedProgramCodeBlock* CodeCache::getProgramCodeBlock(VM& vm, ProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
>+UnlinkedProgramCodeBlock* CodeCache::getProgramCodeBlock(VM& vm, const RuntimeFlags& runtimeFlags, ProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
> {
>     VariableEnvironment emptyParentTDZVariables;
>-    return getGlobalCodeBlock<UnlinkedProgramCodeBlock>(vm, executable, source, builtinMode, strictMode, ThisTDZMode::CheckIfNeeded, false, debuggerMode, profilerMode, error, EvalContextType::None, &emptyParentTDZVariables);
>+    return getGlobalCodeBlock<UnlinkedProgramCodeBlock>(vm, runtimeFlags, executable, source, builtinMode, strictMode, ThisTDZMode::CheckIfNeeded, false, debuggerMode, profilerMode, error, EvalContextType::None, &emptyParentTDZVariables);
> }
> 
>-UnlinkedEvalCodeBlock* CodeCache::getEvalCodeBlock(VM& vm, EvalExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, ThisTDZMode thisTDZMode, bool isArrowFunctionContext, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
>+UnlinkedEvalCodeBlock* CodeCache::getEvalCodeBlock(VM& vm, const RuntimeFlags& runtimeFlags, EvalExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, ThisTDZMode thisTDZMode, bool isArrowFunctionContext, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
> {
>-    return getGlobalCodeBlock<UnlinkedEvalCodeBlock>(vm, executable, source, builtinMode, strictMode, thisTDZMode, isArrowFunctionContext, debuggerMode, profilerMode, error, evalContextType, variablesUnderTDZ);
>+    return getGlobalCodeBlock<UnlinkedEvalCodeBlock>(vm, runtimeFlags, executable, source, builtinMode, strictMode, thisTDZMode, isArrowFunctionContext, debuggerMode, profilerMode, error, evalContextType, variablesUnderTDZ);
> }
> 
>-UnlinkedModuleProgramCodeBlock* CodeCache::getModuleProgramCodeBlock(VM& vm, ModuleProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
>+UnlinkedModuleProgramCodeBlock* CodeCache::getModuleProgramCodeBlock(VM& vm, const RuntimeFlags& runtimeFlags, ModuleProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
> {
>     VariableEnvironment emptyParentTDZVariables;
>-    return getGlobalCodeBlock<UnlinkedModuleProgramCodeBlock>(vm, executable, source, builtinMode, JSParserStrictMode::Strict, ThisTDZMode::CheckIfNeeded, false, debuggerMode, profilerMode, error, EvalContextType::None, &emptyParentTDZVariables);
>+    return getGlobalCodeBlock<UnlinkedModuleProgramCodeBlock>(vm, runtimeFlags, executable, source, builtinMode, JSParserStrictMode::Strict, ThisTDZMode::CheckIfNeeded, false, debuggerMode, profilerMode, error, EvalContextType::None, &emptyParentTDZVariables);
> }
> 
> // FIXME: There's no need to add the function's name to the key here. It's already in the source code.
>-UnlinkedFunctionExecutable* CodeCache::getFunctionExecutableFromGlobalCode(VM& vm, const Identifier& name, const SourceCode& source, ParserError& error)
>+UnlinkedFunctionExecutable* CodeCache::getFunctionExecutableFromGlobalCode(VM& vm, const RuntimeFlags& runtimeFlags, const Identifier& name, const SourceCode& source, ParserError& error)
> {
>     SourceCodeKey key = SourceCodeKey(
>         source, name.string(), SourceCodeKey::FunctionType, 
>@@ -161,7 +161,7 @@ UnlinkedFunctionExecutable* CodeCache::getFunctionExecutableFromGlobalCode(VM& v
> 
>     JSTextPosition positionBeforeLastNewline;
>     std::unique_ptr<ProgramNode> program = parse<ProgramNode>(
>-        &vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
>+        &vm, runtimeFlags, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
>         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded,
>         error, &positionBeforeLastNewline);
>     if (!program) {
>@@ -191,7 +191,10 @@ UnlinkedFunctionExecutable* CodeCache::getFunctionExecutableFromGlobalCode(VM& v
>     metadata->setEndPosition(positionBeforeLastNewline);
>     // The Function constructor only has access to global variables, so no variables will be under TDZ.
>     VariableEnvironment emptyTDZVariables;
>-    UnlinkedFunctionExecutable* functionExecutable = UnlinkedFunctionExecutable::create(&vm, source, metadata, UnlinkedNormalFunction, ConstructAbility::CanConstruct, emptyTDZVariables, DerivedContextType::None);
>+    ConstructAbility constructAbility = ConstructAbility::CanConstruct;
>+    if (isAsyncFunctionParseMode(metadata->parseMode()))
>+        constructAbility = ConstructAbility::CannotConstruct;
>+    UnlinkedFunctionExecutable* functionExecutable = UnlinkedFunctionExecutable::create(&vm, source, metadata, UnlinkedNormalFunction, constructAbility, emptyTDZVariables, DerivedContextType::None);
> 
>     m_sourceCode.addCache(key, SourceCodeValue(vm, functionExecutable, m_sourceCode.age()));
>     return functionExecutable;
>diff --git a/Source/JavaScriptCore/runtime/CodeCache.h b/Source/JavaScriptCore/runtime/CodeCache.h
>index 470307234fdb477225a8e43b13922ec797c524ce..e748cbc290c2f4e4a3d0635948bc97f035529e67 100644
>--- a/Source/JavaScriptCore/runtime/CodeCache.h
>+++ b/Source/JavaScriptCore/runtime/CodeCache.h
>@@ -54,6 +54,7 @@ class UnlinkedFunctionCodeBlock;
> class UnlinkedFunctionExecutable;
> class UnlinkedProgramCodeBlock;
> class VM;
>+class RuntimeFlags;
> class SourceCode;
> class SourceProvider;
> class VariableEnvironment;
>@@ -194,10 +195,10 @@ public:
>     CodeCache();
>     ~CodeCache();
> 
>-    UnlinkedProgramCodeBlock* getProgramCodeBlock(VM&, ProgramExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ProfilerMode, ParserError&);
>-    UnlinkedEvalCodeBlock* getEvalCodeBlock(VM&, EvalExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, ThisTDZMode, bool, DebuggerMode, ProfilerMode, ParserError&, EvalContextType, const VariableEnvironment*);
>-    UnlinkedModuleProgramCodeBlock* getModuleProgramCodeBlock(VM&, ModuleProgramExecutable*, const SourceCode&, JSParserBuiltinMode, DebuggerMode, ProfilerMode, ParserError&);
>-    UnlinkedFunctionExecutable* getFunctionExecutableFromGlobalCode(VM&, const Identifier&, const SourceCode&, ParserError&);
>+    UnlinkedProgramCodeBlock* getProgramCodeBlock(VM&, const RuntimeFlags&, ProgramExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ProfilerMode, ParserError&);
>+    UnlinkedEvalCodeBlock* getEvalCodeBlock(VM&, const RuntimeFlags&, EvalExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, ThisTDZMode, bool, DebuggerMode, ProfilerMode, ParserError&, EvalContextType, const VariableEnvironment*);
>+    UnlinkedModuleProgramCodeBlock* getModuleProgramCodeBlock(VM&, const RuntimeFlags&, ModuleProgramExecutable*, const SourceCode&, JSParserBuiltinMode, DebuggerMode, ProfilerMode, ParserError&);
>+    UnlinkedFunctionExecutable* getFunctionExecutableFromGlobalCode(VM&, const RuntimeFlags&, const Identifier&, const SourceCode&, ParserError&);
> 
>     void clear()
>     {
>@@ -206,7 +207,7 @@ public:
> 
> private:
>     template <class UnlinkedCodeBlockType, class ExecutableType> 
>-    UnlinkedCodeBlockType* getGlobalCodeBlock(VM&, ExecutableType*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, ThisTDZMode, bool, DebuggerMode, ProfilerMode, ParserError&, EvalContextType, const VariableEnvironment*);
>+    UnlinkedCodeBlockType* getGlobalCodeBlock(VM&, const RuntimeFlags&, ExecutableType*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, ThisTDZMode, bool, DebuggerMode, ProfilerMode, ParserError&, EvalContextType, const VariableEnvironment*);
> 
>     CodeCacheMap m_sourceCode;
> };
>diff --git a/Source/JavaScriptCore/runtime/CommonIdentifiers.h b/Source/JavaScriptCore/runtime/CommonIdentifiers.h
>index a086ded8fb48e38471a32c8de53b79df5a5270db..49add74c908b47782657aaac22d666cb88bb79ba 100644
>--- a/Source/JavaScriptCore/runtime/CommonIdentifiers.h
>+++ b/Source/JavaScriptCore/runtime/CommonIdentifiers.h
>@@ -33,6 +33,7 @@
>     macro(ArrayBuffer) \
>     macro(ArrayIterator) \
>     macro(Audio) \
>+    macro(AsyncFunction) \
>     macro(BYTES_PER_ELEMENT) \
>     macro(Boolean) \
>     macro(Collator) \
>@@ -103,6 +104,8 @@
>     macro(arguments) \
>     macro(as) \
>     macro(assign) \
>+    macro(async) \
>+    macro(await) \
>     macro(back) \
>     macro(bind) \
>     macro(blur) \
>@@ -260,6 +263,8 @@
>     macro(year)
> 
> #define JSC_COMMON_IDENTIFIERS_EACH_KEYWORD(macro) \
>+    macro(async) \
>+    macro(await) \
>     macro(break) \
>     macro(case) \
>     macro(catch) \
>diff --git a/Source/JavaScriptCore/runtime/Completion.cpp b/Source/JavaScriptCore/runtime/Completion.cpp
>index c178a4a52be81b1cf45f058488a11beb90dd979a..3b803164e453f90999c4a49088a9316b824a7079 100644
>--- a/Source/JavaScriptCore/runtime/Completion.cpp
>+++ b/Source/JavaScriptCore/runtime/Completion.cpp
>@@ -38,6 +38,7 @@
> #include "ModuleAnalyzer.h"
> #include "ModuleLoaderObject.h"
> #include "Parser.h"
>+#include "RuntimeFlags.h"
> #include "ScriptProfilingScope.h"
> #include <wtf/WTFThreadData.h>
> 
>@@ -59,12 +60,12 @@ bool checkSyntax(ExecState* exec, const SourceCode& source, JSValue* returnedExc
>     return true;
> }
>     
>-bool checkSyntax(VM& vm, const SourceCode& source, ParserError& error)
>+bool checkSyntax(VM& vm, const RuntimeFlags& runtimeFlags, const SourceCode& source, ParserError& error)
> {
>     JSLockHolder lock(vm);
>     RELEASE_ASSERT(vm.atomicStringTable() == wtfThreadData().atomicStringTable());
>     return !!parse<ProgramNode>(
>-        &vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
>+        &vm, runtimeFlags, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
>         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded, error);
> }
> 
>@@ -74,7 +75,7 @@ bool checkModuleSyntax(ExecState* exec, const SourceCode& source, ParserError& e
>     JSLockHolder lock(vm);
>     RELEASE_ASSERT(vm.atomicStringTable() == wtfThreadData().atomicStringTable());
>     std::unique_ptr<ModuleProgramNode> moduleProgramNode = parse<ModuleProgramNode>(
>-        &vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
>+        &vm, exec->lexicalGlobalObject()->runtimeFlags(), source, Identifier(), JSParserBuiltinMode::NotBuiltin,
>         JSParserStrictMode::Strict, SourceParseMode::ModuleAnalyzeMode, SuperBinding::NotNeeded, error);
>     if (!moduleProgramNode)
>         return false;
>diff --git a/Source/JavaScriptCore/runtime/Completion.h b/Source/JavaScriptCore/runtime/Completion.h
>index 53ba195fd81fb3a9213334111608ba2843f6f158..91b5141d3653d5788994691576a57dab6944c598 100644
>--- a/Source/JavaScriptCore/runtime/Completion.h
>+++ b/Source/JavaScriptCore/runtime/Completion.h
>@@ -33,11 +33,12 @@ class Exception;
> class ExecState;
> class JSScope;
> class ParserError;
>+class RuntimeFlags;
> class SourceCode;
> class VM;
> class JSInternalPromise;
> 
>-JS_EXPORT_PRIVATE bool checkSyntax(VM&, const SourceCode&, ParserError&);
>+JS_EXPORT_PRIVATE bool checkSyntax(VM&, const RuntimeFlags&, const SourceCode&, ParserError&);
> JS_EXPORT_PRIVATE bool checkSyntax(ExecState*, const SourceCode&, JSValue* exception = 0);
> JS_EXPORT_PRIVATE bool checkModuleSyntax(ExecState*, const SourceCode&, ParserError&);
> 
>diff --git a/Source/JavaScriptCore/runtime/Executable.cpp b/Source/JavaScriptCore/runtime/Executable.cpp
>index 7be73984ee0c852bd2ae16960044380d21a4bd56..33ae5fb656a5019d6665be48dd921a2d4d8abddb 100644
>--- a/Source/JavaScriptCore/runtime/Executable.cpp
>+++ b/Source/JavaScriptCore/runtime/Executable.cpp
>@@ -281,7 +281,7 @@ CodeBlock* ScriptExecutable::newCodeBlockFor(
>     ProfilerMode profilerMode = globalObject->hasLegacyProfiler() ? ProfilerOn : ProfilerOff;
>     UnlinkedFunctionCodeBlock* unlinkedCodeBlock = 
>         executable->m_unlinkedExecutable->unlinkedCodeBlockFor(
>-            *vm, executable->m_source, kind, debuggerMode, profilerMode, error, 
>+            *vm, globalObject->runtimeFlags(), executable->m_source, kind, debuggerMode, profilerMode, error, 
>             executable->parseMode());
>     recordParse(
>         executable->m_unlinkedExecutable->features(), 
>@@ -536,7 +536,7 @@ JSObject* ProgramExecutable::checkSyntax(ExecState* exec)
>     VM* vm = &exec->vm();
>     JSGlobalObject* lexicalGlobalObject = exec->lexicalGlobalObject();
>     std::unique_ptr<ProgramNode> programNode = parse<ProgramNode>(
>-        vm, m_source, Identifier(), JSParserBuiltinMode::NotBuiltin, 
>+        vm, lexicalGlobalObject->runtimeFlags(), m_source, Identifier(), JSParserBuiltinMode::NotBuiltin, 
>         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded, error);
>     if (programNode)
>         return 0;
>diff --git a/Source/JavaScriptCore/runtime/FunctionConstructor.cpp b/Source/JavaScriptCore/runtime/FunctionConstructor.cpp
>index d4390663ba0f2a05652997269d13354dea427dcf..98d630474db18eb9a094467c474001baa089dbbe 100644
>--- a/Source/JavaScriptCore/runtime/FunctionConstructor.cpp
>+++ b/Source/JavaScriptCore/runtime/FunctionConstructor.cpp
>@@ -95,14 +95,18 @@ JSObject* constructFunctionSkippingEvalEnabledCheck(
>     // See https://bugs.webkit.org/show_bug.cgi?id=24350.
>     String program;
>     if (args.isEmpty())
>-        program = makeString("{function ", functionConstructionMode == FunctionConstructionMode::Generator ? "*" : "", functionName.string(), "() {\n\n}}");
>+        program = makeString("{", functionConstructionMode == FunctionConstructionMode::Async ? "async function " : "function ", functionConstructionMode == FunctionConstructionMode::Generator ? "*" : "", functionName.string(), "() {\n\n}}");
>     else if (args.size() == 1)
>-        program = makeString("{function ", functionConstructionMode == FunctionConstructionMode::Generator ? "*" : "", functionName.string(), "() {\n", args.at(0).toString(exec)->value(exec), "\n}}");
>+        program = makeString("{", functionConstructionMode == FunctionConstructionMode::Async ? "async function " : "function ", functionConstructionMode == FunctionConstructionMode::Generator ? "*" : "", functionName.string(), "() {\n", args.at(0).toString(exec)->value(exec), "\n}}");
>     else {
>         StringBuilder builder;
>-        builder.appendLiteral("{function ");
>-        if (functionConstructionMode == FunctionConstructionMode::Generator)
>-            builder.append('*');
>+        if (functionConstructionMode == FunctionConstructionMode::Async)
>+            builder.appendLiteral("{async function ");
>+        else {
>+            builder.appendLiteral("{function ");
>+            if (functionConstructionMode == FunctionConstructionMode::Generator)
>+                builder.append('*');
>+        }
>         builder.append(functionName.string());
>         builder.append('(');
>         builder.append(args.at(0).toString(exec)->view(exec).get());
>diff --git a/Source/JavaScriptCore/runtime/FunctionConstructor.h b/Source/JavaScriptCore/runtime/FunctionConstructor.h
>index 63bc408c4b017d8d54b4effdcadd09f70d13d51f..54c12f466926087f4622001236aba38149014972 100644
>--- a/Source/JavaScriptCore/runtime/FunctionConstructor.h
>+++ b/Source/JavaScriptCore/runtime/FunctionConstructor.h
>@@ -59,6 +59,7 @@ private:
> enum class FunctionConstructionMode {
>     Function,
>     Generator,
>+    Async
> };
> 
> JSObject* constructFunction(ExecState*, JSGlobalObject*, const ArgList&, const Identifier& functionName, const String& sourceURL, const WTF::TextPosition&, FunctionConstructionMode = FunctionConstructionMode::Function, JSValue newTarget = JSValue());
>diff --git a/Source/JavaScriptCore/runtime/JSAsyncFunction.cpp b/Source/JavaScriptCore/runtime/JSAsyncFunction.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..d3490967f736d72a61bc8435321e4040a2d2148d
>--- /dev/null
>+++ b/Source/JavaScriptCore/runtime/JSAsyncFunction.cpp
>@@ -0,0 +1,69 @@
>+/*
>+ * Copyright (C) 2016 Caitlin Potter <caitp@igalia.com>.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "JSAsyncFunction.h"
>+
>+#include "Error.h"
>+#include "JSCInlines.h"
>+#include "JSCJSValue.h"
>+#include "JSFunction.h"
>+#include "JSFunctionInlines.h"
>+#include "JSObject.h"
>+#include "PropertySlot.h"
>+#include "VM.h"
>+
>+namespace JSC {
>+
>+const ClassInfo JSAsyncFunction::s_info = { "AsyncFunction", &Base::s_info, nullptr, CREATE_METHOD_TABLE(JSAsyncFunction) };
>+
>+JSAsyncFunction::JSAsyncFunction(VM& vm, FunctionExecutable* executable, JSScope* scope)
>+    : Base(vm, executable, scope, scope->globalObject()->asyncFunctionStructure())
>+{
>+}
>+
>+JSAsyncFunction* JSAsyncFunction::createImpl(VM& vm, FunctionExecutable* executable, JSScope* scope)
>+{
>+    JSAsyncFunction* asyncFunction = new (NotNull, allocateCell<JSAsyncFunction>(vm.heap)) JSAsyncFunction(vm, executable, scope);
>+    ASSERT(asyncFunction->structure()->globalObject());
>+    asyncFunction->finishCreation(vm);
>+    return asyncFunction;
>+}
>+
>+JSAsyncFunction* JSAsyncFunction::create(VM& vm, FunctionExecutable* executable, JSScope* scope)
>+{
>+    JSAsyncFunction* asyncFunction = createImpl(vm, executable, scope);
>+    executable->singletonFunction()->notifyWrite(vm, asyncFunction, "Allocating an async function");
>+    return asyncFunction;
>+}
>+
>+JSAsyncFunction* JSAsyncFunction::createWithInvalidatedReallocationWatchpoint(VM& vm, FunctionExecutable* executable, JSScope* scope)
>+{
>+    return createImpl(vm, executable, scope);
>+}
>+
>+} // namespace JSC
>+
>+
>diff --git a/Source/JavaScriptCore/runtime/JSAsyncFunction.h b/Source/JavaScriptCore/runtime/JSAsyncFunction.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..e9959ec5531eb754b7fdb6fadcfbe6f53382385c
>--- /dev/null
>+++ b/Source/JavaScriptCore/runtime/JSAsyncFunction.h
>@@ -0,0 +1,76 @@
>+/*
>+ * Copyright (C) 2016 Caitlin Potter <caitp@igalia.com>.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#ifndef JSAsyncFunction_h
>+#define JSAsyncFunction_h
>+
>+#include "JSFunction.h"
>+
>+namespace JSC {
>+
>+class JSGlobalObject;
>+class LLIntOffsetsExtractor;
>+class LLIntDesiredOffsets;
>+
>+class JSAsyncFunction : public JSFunction {
>+    friend class JIT;
>+#if ENABLE(DFG_JIT)
>+    friend class DFG::SpeculativeJIT;
>+    friend class DFG::JITCompiler;
>+#endif
>+    friend class VM;
>+public:
>+    typedef JSFunction Base;
>+
>+    const static unsigned StructureFlags = Base::StructureFlags;
>+
>+    DECLARE_EXPORT_INFO;
>+
>+    static JSAsyncFunction* create(VM&, FunctionExecutable*, JSScope*);
>+    static JSAsyncFunction* createWithInvalidatedReallocationWatchpoint(VM&, FunctionExecutable*, JSScope*);
>+
>+    static size_t allocationSize(size_t inlineCapacity)
>+    {
>+        ASSERT_UNUSED(inlineCapacity, !inlineCapacity);
>+        return sizeof(JSAsyncFunction);
>+    }
>+
>+    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
>+    {
>+        ASSERT(globalObject);
>+        return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info());
>+    }
>+
>+private:
>+    JSAsyncFunction(VM&, FunctionExecutable*, JSScope*);
>+
>+    static JSAsyncFunction* createImpl(VM&, FunctionExecutable*, JSScope*);
>+
>+    friend class LLIntOffsetsExtractor;
>+};
>+
>+} // namespace JSC
>+
>+#endif // JSAsyncFunction_h
>diff --git a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
>index bae10b2595834307cc1b5b89d0030ebee2f027cd..501e00b139c54cdebf1c336ab4ae493924c07b82 100644
>--- a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
>+++ b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
>@@ -33,6 +33,8 @@
> #include "ArrayConstructor.h"
> #include "ArrayIteratorPrototype.h"
> #include "ArrayPrototype.h"
>+#include "AsyncFunctionConstructor.h"
>+#include "AsyncFunctionPrototype.h"
> #include "BooleanConstructor.h"
> #include "BooleanPrototype.h"
> #include "BuiltinNames.h"
>@@ -63,6 +65,7 @@
> #include "JSArrayBufferConstructor.h"
> #include "JSArrayBufferPrototype.h"
> #include "JSArrayIterator.h"
>+#include "JSAsyncFunction.h"
> #include "JSBoundFunction.h"
> #include "JSBoundSlotBaseFunction.h"
> #include "JSCInlines.h"
>@@ -440,6 +443,12 @@ m_ ## lowerName ## Prototype->putDirectWithoutTransition(vm, vm.propertyNames->c
>     m_typeErrorConstructor.set(vm, this, NativeErrorConstructor::create(vm, this, nativeErrorStructure, nativeErrorPrototypeStructure, ASCIILiteral("TypeError")));
>     m_URIErrorConstructor.set(vm, this, NativeErrorConstructor::create(vm, this, nativeErrorStructure, nativeErrorPrototypeStructure, ASCIILiteral("URIError")));
> 
>+    AsyncFunctionConstructor* asyncFunctionConstructor = nullptr;
>+    m_asyncFunctionPrototype.set(vm, this, AsyncFunctionPrototype::create(vm, AsyncFunctionPrototype::createStructure(vm, this, m_functionPrototype.get())));
>+    asyncFunctionConstructor = AsyncFunctionConstructor::create(vm, AsyncFunctionConstructor::createStructure(vm, this, functionConstructor), m_asyncFunctionPrototype.get());
>+    m_asyncFunctionPrototype->putDirectWithoutTransition(vm, vm.propertyNames->constructor, asyncFunctionConstructor, DontEnum);
>+    m_asyncFunctionStructure.set(vm, this, JSAsyncFunction::createStructure(vm, this, m_asyncFunctionPrototype.get()));
>+
>     m_generatorFunctionPrototype.set(vm, this, GeneratorFunctionPrototype::create(vm, GeneratorFunctionPrototype::createStructure(vm, this, m_functionPrototype.get())));
>     GeneratorFunctionConstructor* generatorFunctionConstructor = GeneratorFunctionConstructor::create(vm, GeneratorFunctionConstructor::createStructure(vm, this, functionConstructor), m_generatorFunctionPrototype.get());
>     m_generatorFunctionPrototype->putDirectWithoutTransition(vm, vm.propertyNames->constructor, generatorFunctionConstructor, DontEnum);
>@@ -465,8 +474,10 @@ m_ ## lowerName ## Prototype->putDirectWithoutTransition(vm, vm.propertyNames->c
>     putDirectWithoutTransition(vm, vm.propertyNames->URIError, m_URIErrorConstructor.get(), DontEnum);
> 
>     putDirectWithoutTransition(vm, vm.propertyNames->Proxy, ProxyConstructor::create(vm, ProxyConstructor::createStructure(vm, this, m_functionPrototype.get())), DontEnum);
>-    
>-    
>+
>+    if (m_runtimeFlags.isAsyncAwaitEnabled())
>+        putDirectWithoutTransition(vm, vm.propertyNames->AsyncFunction, asyncFunctionConstructor, DontEnum);
>+
> #define PUT_CONSTRUCTOR_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
> putDirectWithoutTransition(vm, vm.propertyNames-> jsName, lowerName ## Constructor, DontEnum); \
> 
>@@ -600,6 +611,7 @@ putDirectWithoutTransition(vm, vm.propertyNames-> jsName, lowerName ## Construct
>         GlobalPropertyInfo(vm.propertyNames->MapPrivateName, mapConstructor, DontEnum | DontDelete | ReadOnly),
>         GlobalPropertyInfo(vm.propertyNames->builtinNames().generatorResumePrivateName(), JSFunction::createBuiltinFunction(vm, generatorPrototypeGeneratorResumeCodeGenerator(vm), this), DontEnum | DontDelete | ReadOnly),
>         GlobalPropertyInfo(vm.propertyNames->builtinNames().thisTimeValuePrivateName(), privateFuncThisTimeValue, DontEnum | DontDelete | ReadOnly),
>+        GlobalPropertyInfo(vm.propertyNames->builtinNames().asyncFunctionResumePrivateName(), JSFunction::createBuiltinFunction(vm, asyncFunctionPrototypeAsyncFunctionResumeCodeGenerator(vm), this), DontEnum | DontDelete | ReadOnly),
> #if ENABLE(INTL)
>         GlobalPropertyInfo(vm.propertyNames->builtinNames().CollatorPrivateName(), intl->getDirect(vm, vm.propertyNames->Collator), DontEnum | DontDelete | ReadOnly),
>         GlobalPropertyInfo(vm.propertyNames->builtinNames().DateTimeFormatPrivateName(), intl->getDirect(vm, vm.propertyNames->DateTimeFormat), DontEnum | DontDelete | ReadOnly),
>@@ -1017,7 +1029,7 @@ UnlinkedProgramCodeBlock* JSGlobalObject::createProgramCodeBlock(CallFrame* call
>     DebuggerMode debuggerMode = hasInteractiveDebugger() ? DebuggerOn : DebuggerOff;
>     ProfilerMode profilerMode = hasLegacyProfiler() ? ProfilerOn : ProfilerOff;
>     UnlinkedProgramCodeBlock* unlinkedCodeBlock = vm().codeCache()->getProgramCodeBlock(
>-        vm(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode, 
>+        vm(), runtimeFlags(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode, 
>         debuggerMode, profilerMode, error);
> 
>     if (hasDebugger())
>@@ -1040,7 +1052,7 @@ UnlinkedEvalCodeBlock* JSGlobalObject::createEvalCodeBlock(CallFrame* callFrame,
>     
>     ProfilerMode profilerMode = hasLegacyProfiler() ? ProfilerOn : ProfilerOff;
>     UnlinkedEvalCodeBlock* unlinkedCodeBlock = vm().codeCache()->getEvalCodeBlock(
>-        vm(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode, thisTDZMode, isArrowFunctionContext, debuggerMode, profilerMode, error, evalContextType, variablesUnderTDZ);
>+        vm(), runtimeFlags(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode, thisTDZMode, isArrowFunctionContext, debuggerMode, profilerMode, error, evalContextType, variablesUnderTDZ);
> 
>     if (hasDebugger())
>         debugger()->sourceParsed(callFrame, executable->source().provider(), error.line(), error.message());
>@@ -1059,7 +1071,7 @@ UnlinkedModuleProgramCodeBlock* JSGlobalObject::createModuleProgramCodeBlock(Cal
>     DebuggerMode debuggerMode = hasInteractiveDebugger() ? DebuggerOn : DebuggerOff;
>     ProfilerMode profilerMode = hasLegacyProfiler() ? ProfilerOn : ProfilerOff;
>     UnlinkedModuleProgramCodeBlock* unlinkedCodeBlock = vm().codeCache()->getModuleProgramCodeBlock(
>-        vm(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, debuggerMode, profilerMode, error);
>+        vm(), runtimeFlags(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, debuggerMode, profilerMode, error);
> 
>     if (hasDebugger())
>         debugger()->sourceParsed(callFrame, executable->source().provider(), error.line(), error.message());
>diff --git a/Source/JavaScriptCore/runtime/JSGlobalObject.h b/Source/JavaScriptCore/runtime/JSGlobalObject.h
>index dcaa9baec06ccb1bf2089ac3967889d762685823..215a2527865efa064b95a022e7675e46e8a0efce 100644
>--- a/Source/JavaScriptCore/runtime/JSGlobalObject.h
>+++ b/Source/JavaScriptCore/runtime/JSGlobalObject.h
>@@ -54,6 +54,7 @@ class JSGlobalObjectInspectorController;
> namespace JSC {
> 
> class ArrayPrototype;
>+class AsyncFunctionPrototype;
> class BooleanPrototype;
> class ConsoleClient;
> class Debugger;
>@@ -234,6 +235,7 @@ protected:
>     WriteBarrier<ObjectPrototype> m_objectPrototype;
>     WriteBarrier<FunctionPrototype> m_functionPrototype;
>     WriteBarrier<ArrayPrototype> m_arrayPrototype;
>+    WriteBarrier<AsyncFunctionPrototype> m_asyncFunctionPrototype;
>     WriteBarrier<RegExpPrototype> m_regExpPrototype;
>     WriteBarrier<IteratorPrototype> m_iteratorPrototype;
>     WriteBarrier<GeneratorFunctionPrototype> m_generatorFunctionPrototype;
>@@ -272,6 +274,7 @@ protected:
>     PropertyOffset m_functionNameOffset;
>     WriteBarrier<Structure> m_privateNameStructure;
>     WriteBarrier<Structure> m_regExpStructure;
>+    WriteBarrier<Structure> m_asyncFunctionStructure;
>     WriteBarrier<Structure> m_generatorFunctionStructure;
>     WriteBarrier<Structure> m_consoleStructure;
>     WriteBarrier<Structure> m_dollarVMStructure;
>@@ -462,6 +465,7 @@ public:
>     ObjectPrototype* objectPrototype() const { return m_objectPrototype.get(); }
>     FunctionPrototype* functionPrototype() const { return m_functionPrototype.get(); }
>     ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
>+    AsyncFunctionPrototype* asyncFunctionPrototype() const { return m_asyncFunctionPrototype.get(); }
>     BooleanPrototype* booleanPrototype() const { return m_booleanPrototype.get(); }
>     StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
>     SymbolPrototype* symbolPrototype() const { return m_symbolPrototype.get(); }
>@@ -529,6 +533,7 @@ public:
>     Structure* internalFunctionStructure() const { return m_internalFunctionStructure.get(); }
>     Structure* mapStructure() const { return m_mapStructure.get(); }
>     Structure* regExpStructure() const { return m_regExpStructure.get(); }
>+    Structure* asyncFunctionStructure() const { return m_asyncFunctionStructure.get(); }
>     Structure* generatorFunctionStructure() const { return m_generatorFunctionStructure.get(); }
>     Structure* setStructure() const { return m_setStructure.get(); }
>     Structure* stringObjectStructure() const { return m_stringObjectStructure.get(); }
>diff --git a/Source/JavaScriptCore/runtime/ModuleLoaderObject.cpp b/Source/JavaScriptCore/runtime/ModuleLoaderObject.cpp
>index b94b86582fa977abc6013b990cbc5f8f790d8415..68f2373a860579af393910ddb24668988527d8c3 100644
>--- a/Source/JavaScriptCore/runtime/ModuleLoaderObject.cpp
>+++ b/Source/JavaScriptCore/runtime/ModuleLoaderObject.cpp
>@@ -280,7 +280,7 @@ EncodedJSValue JSC_HOST_CALL moduleLoaderObjectParseModule(ExecState* exec)
> 
>     ParserError error;
>     std::unique_ptr<ModuleProgramNode> moduleProgramNode = parse<ModuleProgramNode>(
>-        &vm, sourceCode, Identifier(), JSParserBuiltinMode::NotBuiltin,
>+        &vm, exec->vmEntryGlobalObject()->runtimeFlags(), sourceCode, Identifier(), JSParserBuiltinMode::NotBuiltin,
>         JSParserStrictMode::Strict, SourceParseMode::ModuleAnalyzeMode, SuperBinding::NotNeeded, error);
> 
>     if (error.isValid()) {
>diff --git a/Source/JavaScriptCore/runtime/RuntimeFlags.h b/Source/JavaScriptCore/runtime/RuntimeFlags.h
>index 8cd30c6da523abdd1f7448240dd580c9dbf94943..6e32b8abba5d97fccdc8f5583e7948934106ed37 100644
>--- a/Source/JavaScriptCore/runtime/RuntimeFlags.h
>+++ b/Source/JavaScriptCore/runtime/RuntimeFlags.h
>@@ -30,25 +30,26 @@
> 
> namespace JSC {
> 
>-// macro(name, isEnabledFlag)
>-#define JSC_RUNTIME_FLAG(macro)
>+// macro(name, flagName, isEnabledFlag)
>+#define JSC_RUNTIME_FLAG(macro) \
>+    macro(AsyncAwaitEnabled, "es7-async-await", false)
> 
> class RuntimeFlags {
> private:
>     enum RuntimeFlagShiftValue : unsigned {
>-#define JSC_DECLARE_RUNTIME_FLAG_SHIFT_VALUE(name, isEnabledFlag) shiftValueFor##name,
>+#define JSC_DECLARE_RUNTIME_FLAG_SHIFT_VALUE(name, flagName, isEnabledFlag) shiftValueFor##name,
>         JSC_RUNTIME_FLAG(JSC_DECLARE_RUNTIME_FLAG_SHIFT_VALUE)
> #undef JSC_DECLARE_RUNTIME_FLAG_SHIFT_VALUE
>     };
> 
> public:
>     enum RuntimeFlag : unsigned {
>-#define JSC_DECLARE_RUNTIME_FLAG(name, isEnabledFlag) name = 1u << (shiftValueFor##name),
>+#define JSC_DECLARE_RUNTIME_FLAG(name, flagName, isEnabledFlag) name = 1u << (shiftValueFor##name),
>         JSC_RUNTIME_FLAG(JSC_DECLARE_RUNTIME_FLAG)
> #undef JSC_DECLARE_RUNTIME_FLAG
>     };
> 
>-#define JSC_DECLARE_RUNTIME_FLAG_ACCESSOR(name, isEnabledFlag) \
>+#define JSC_DECLARE_RUNTIME_FLAG_ACCESSOR(name, flagName, isEnabledFlag) \
>     void set##name(bool value)\
>     {\
>         if (value)\
>@@ -83,7 +84,7 @@ public:
>     static RuntimeFlags createAllEnabled()
>     {
>         return RuntimeFlags(
>-#define JSC_USE_RUNTIME_FLAG(name, isEnabledFlag) ((isEnabledFlag) ? name : 0u) |
>+#define JSC_USE_RUNTIME_FLAG(name, flagName, isEnabledFlag) ((isEnabledFlag) ? name : 0u) |
>             JSC_RUNTIME_FLAG(JSC_USE_RUNTIME_FLAG)
> #undef JSC_USE_RUNTIME_FLAG
>             0u
>diff --git a/Source/JavaScriptCore/test.js b/Source/JavaScriptCore/test.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..f9fac2670abeb29ae628562c672c6ebf233c391b
>--- /dev/null
>+++ b/Source/JavaScriptCore/test.js
>@@ -0,0 +1,28 @@
>+var log = [];
>+var sym = Symbol('test');
>+var O = {
>+    0: 0,
>+    [sym]: 3,
>+    'a': 2,
>+    1: 1
>+};
>+
>+var P = new Proxy(O, {
>+    ownKeys(target) {
>+        log.push('ownKeys()');
>+        return Reflect.ownKeys(target);
>+    },
>+    getOwnPropertyDescriptor(target, name) {
>+        log.push(`getOwnPropertyDescriptor(${String(name)})`);
>+        return Reflect.getOwnPropertyDescriptor(target, name);
>+    },
>+    get() { throw new Error('[[Get]] trap should be unreachable'); },
>+    set() { throw new Error('[[Set]] trap should be unreachable'); },
>+    deleteProperty() { throw new Error('[[Delete]] trap should be unreachable'); },
>+    defineProperty() { throw new Error('[[DefineOwnProperty]] trap should be unreachable'); }
>+});
>+
>+var result = Object.getOwnPropertyDescriptors(P);
>+
>+print(JSON.stringify(result, null, 2));
>+print(JSON.stringify(log, null, 2));
>\ No newline at end of file
>diff --git a/Source/JavaScriptCore/tests/es6.yaml b/Source/JavaScriptCore/tests/es6.yaml
>index 78435cc23e8e624d134d5ce96f6dcb4725dafa7a..9434331c21af52e1969e4c96e5f39385e1222314 100644
>--- a/Source/JavaScriptCore/tests/es6.yaml
>+++ b/Source/JavaScriptCore/tests/es6.yaml
>@@ -1236,3 +1236,17 @@
>   cmd: runES6 :normal
> - path: es6/Object_static_methods_Object.getOwnPropertyDescriptors-proxy.js
>   cmd: runES6 :fail
>+- path: es6/async-await-reserved-word.js
>+  cmd: runES6 :normal, ["--es7-async-await"]
>+- path: es6/async-await-basic.js
>+  cmd: runES6 :normal, ["--es7-async-await"]
>+- path: es6/async_arrow_functions_lexical_arguments_binding.js
>+  cmd: runES6 :normal, ["--es7-async-await"]
>+- path: es6/async_arrow_functions_lexical_new.target_binding.js
>+  cmd: runES6 :normal, ["--es7-async-await"]
>+- path: es6/async_arrow_functions_lexical_super_binding.js
>+  cmd: runES6 :normal, ["--es7-async-await"]
>+- path: es6/async_arrow_functions_lexical_this_binding.js
>+  cmd: runES6 :normal, ["--es7-async-await"]
>+- path: es6/async-await-mozilla.js
>+  cmd: runES6 :normal, ["--es7-async-await"]
>diff --git a/Source/JavaScriptCore/tests/es6/async-await-basic.js b/Source/JavaScriptCore/tests/es6/async-await-basic.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..fc9ba8d3fbfec13e4555fc36e114e7e8e29fe85b
>--- /dev/null
>+++ b/Source/JavaScriptCore/tests/es6/async-await-basic.js
>@@ -0,0 +1,221 @@
>+function shouldBe(expected, actual, msg) {
>+    if (msg === void 0)
>+        msg = "";
>+    else
>+        msg = " for " + msg;
>+    if (actual !== expected)
>+        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
>+}
>+
>+function shouldBeAsync(expected, run, msg) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+
>+    if (hadError)
>+        throw actual;
>+
>+    shouldBe(expected, actual, msg);
>+}
>+
>+function shouldThrow(run, errorType, message) {
>+    let actual;
>+    var hadError = false;
>+
>+    try {
>+        actual = run();
>+    } catch (e) {
>+        hadError = true;
>+        actual = e;
>+    }
>+
>+    if (!hadError)
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
>+    if (!(actual instanceof errorType))
>+        throw new Error("Expeced " + run + "() to throw " + errorType.name + " , but threw '" + actual + "'");
>+    if (message !== void 0 && actual.message !== message)
>+        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
>+}
>+
>+function shouldThrowAsync(run, errorType, message) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+
>+    if (!hadError)
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
>+    if (!(actual instanceof errorType))
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but threw '" + actual + "'");
>+    if (message !== void 0 && actual.message !== message)
>+        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
>+}
>+
>+// Let functionPrototype be the intrinsic object %AsyncFunctionPrototype%.
>+/*async function asyncFunctionForProto() {}
>+shouldBe(AsyncFunction.prototype, Object.getPrototypeOf(asyncFunctionForProto));*/
>+shouldBe(AsyncFunction.prototype, Object.getPrototypeOf(async function() {}));
>+/*shouldBe(AsyncFunction.prototype, Object.getPrototypeOf(async () => {}));
>+shouldBe(AsyncFunction.prototype, Object.getPrototypeOf({ async method() {} }.method));
>+
>+// FIXME: AsyncFunction constructor should build functions with correct prototype.
>+//shouldBe(AsyncFunction.prototype, Object.getPrototypeOf(AsyncFunction()));
>+
>+// Let F be ! FunctionAllocate(functionPrototype, Strict, "non-constructor")
>+async function asyncNonConstructorDecl() {}
>+shouldThrow(() => new asyncNonConstructorDecl(), TypeError);
>+shouldThrow(() => new (async function() {}), TypeError);
>+shouldThrow(() => new ({ async nonConstructor() {} }).nonConstructor(), TypeError);
>+shouldThrow(() => new (() => "not a constructor!"), TypeError);
>+shouldThrow(() => new (AsyncFunction()), TypeError);
>+
>+// Normal completion
>+async function asyncDecl() { return "test"; }
>+shouldBeAsync("test", asyncDecl);
>+shouldBeAsync("test2", async function() { return "test2"; });
>+shouldBeAsync("test3", async () => "test3");
>+shouldBeAsync("test4", () => ({ async f() { return "test4"; } }).f());
>+
>+class MyError extends Error {};
>+
>+// Throw completion
>+async function asyncDeclThrower(e) { throw new MyError(e); }
>+shouldThrowAsync(() => asyncDeclThrower("boom!"), MyError, "boom!");
>+shouldThrowAsync(() => (async function(e) { throw new MyError(e); })("boom!!!"), MyError, "boom!!!");
>+shouldThrowAsync(() => (async e => { throw new MyError(e) })("boom!!"), MyError, "boom!!");
>+shouldThrowAsync(() => ({ async thrower(e) { throw new MyError(e); } }).thrower("boom!!!!"), MyError, "boom!!!!");
>+
>+function resolveLater(value) { return Promise.resolve(value); }
>+function rejectLater(error) { return Promise.reject(error); }
>+
>+// Resume after Normal completion
>+var log = [];
>+async function resumeAfterNormal(value) {
>+    log.push("start:" + value);
>+    value = await resolveLater(value + 1);
>+    log.push("resume:" + value);
>+    value = await resolveLater(value + 1);
>+    log.push("resume:" + value);
>+    return value + 1;
>+}
>+
>+shouldBeAsync(4, () => resumeAfterNormal(1));
>+shouldBe("start:1 resume:2 resume:3", log.join(" "));
>+
>+var O = {
>+    async resumeAfterNormal(value) {
>+        log.push("start:" + value);
>+        value = await resolveLater(value + 1);
>+        log.push("resume:" + value);
>+        value = await resolveLater(value + 1);
>+        log.push("resume:" + value);
>+        return value + 1;
>+    }
>+};
>+log = [];
>+shouldBeAsync(5, () => O.resumeAfterNormal(2));
>+shouldBe("start:2 resume:3 resume:4", log.join(" "));
>+
>+var resumeAfterNormalArrow = async (value) => {
>+    log.push("start:" + value);
>+    value = await resolveLater(value + 1);
>+    log.push("resume:" + value);
>+    value = await resolveLater(value + 1);
>+    log.push("resume:" + value);
>+    return value + 1;
>+};
>+log = [];
>+shouldBeAsync(6, () => resumeAfterNormalArrow(3));
>+shouldBe("start:3 resume:4 resume:5", log.join(" "));
>+
>+var resumeAfterNormalEval = AsyncFunction("value", `
>+    log.push("start:" + value);
>+    value = await resolveLater(value + 1);
>+    log.push("resume:" + value);
>+    value = await resolveLater(value + 1);
>+    log.push("resume:" + value);
>+    return value + 1;
>+`);
>+log = [];
>+shouldBeAsync(7, () => resumeAfterNormalEval(4));
>+shouldBe("start:4 resume:5 resume:6", log.join(" "));
>+
>+// Resume after Throw completion
>+async function resumeAfterThrow(value) {
>+    log.push("start:" + value);
>+    try {
>+        value = await rejectLater("throw1");
>+    } catch (e) {
>+        log.push("resume:" + e);
>+    }
>+    try {
>+        value = await rejectLater("throw2");
>+    } catch (e) {
>+        log.push("resume:" + e);
>+    }
>+    return value + 1;
>+}
>+
>+log = [];
>+shouldBeAsync(2, () => resumeAfterThrow(1));
>+shouldBe("start:1 resume:throw1 resume:throw2", log.join(" "));
>+
>+var O = {
>+    async resumeAfterThrow(value) {
>+        log.push("start:" + value);
>+        try {
>+            value = await rejectLater("throw1");
>+        } catch (e) {
>+            log.push("resume:" + e);
>+        }
>+        try {
>+            value = await rejectLater("throw2");
>+        } catch (e) {
>+            log.push("resume:" + e);
>+        }
>+        return value + 1;
>+    }
>+}
>+log = [];
>+shouldBeAsync(3, () => O.resumeAfterThrow(2));
>+shouldBe("start:2 resume:throw1 resume:throw2", log.join(" "));
>+
>+var resumeAfterThrowArrow = async (value) => {
>+    log.push("start:" + value);
>+    try {
>+        value = await rejectLater("throw1");
>+    } catch (e) {
>+        log.push("resume:" + e);
>+    }
>+    try {
>+        value = await rejectLater("throw2");
>+    } catch (e) {
>+        log.push("resume:" + e);
>+    }
>+    return value + 1;
>+};
>+log = [];
>+shouldBeAsync(4, () => resumeAfterThrowArrow(3));
>+shouldBe("start:3 resume:throw1 resume:throw2", log.join(" "));
>+
>+var resumeAfterThrowEval = AsyncFunction("value", `
>+    log.push("start:" + value);
>+    try {
>+        value = await rejectLater("throw1");
>+    } catch (e) {
>+        log.push("resume:" + e);
>+    }
>+    try {
>+        value = await rejectLater("throw2");
>+    } catch (e) {
>+        log.push("resume:" + e);
>+    }
>+    return value + 1;
>+`);
>+log = [];
>+shouldBeAsync(5, () => resumeAfterThrowEval(4));
>+shouldBe("start:4 resume:throw1 resume:throw2", log.join(" "));
>+*/
>\ No newline at end of file
>diff --git a/Source/JavaScriptCore/tests/es6/async-await-mozilla.js b/Source/JavaScriptCore/tests/es6/async-await-mozilla.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..eac71aad4c45df3cf8b22a834ba79a587c9a49e5
>--- /dev/null
>+++ b/Source/JavaScriptCore/tests/es6/async-await-mozilla.js
>@@ -0,0 +1,304 @@
>+/* This Source Code Form is subject to the terms of the Mozilla Public
>+ * License, v. 2.0. If a copy of the MPL was not distributed with this
>+ * file, You can obtain one at http://moz.org/MPL/2.0/. */
>+
>+function shouldBe(expected, actual, msg) {
>+    if (msg === void 0)
>+        msg = "";
>+    else
>+        msg = " for " + msg;
>+    if (actual !== expected)
>+        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
>+}
>+
>+function shouldBeAsync(expected, run, msg) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+    if (hadError)
>+        throw actual;
>+    shouldBe(expected, actual, msg);
>+}
>+
>+function shouldThrow(run, errorType, message) {
>+    let actual;
>+    var hadError = false;
>+    try {
>+        actual = run();
>+    } catch (e) {
>+        hadError = true;
>+        actual = e;
>+    }
>+    if (!hadError)
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
>+    if (!(actual instanceof errorType))
>+        throw new Error("Expeced " + run + "() to throw " + errorType.name + " , but threw '" + actual + "'");
>+    if (message !== void 0 && actual.message !== message)
>+        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
>+}
>+
>+function shouldThrowAsync(run, errorType, message) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+    if (!hadError)
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
>+    if (!(actual instanceof errorType))
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but threw '" + actual + "'");
>+    if (message !== void 0 && actual.message !== message)
>+        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
>+}
>+
>+function assert(cond, msg = "") {
>+    if (!cond)
>+        throw new Error(msg);
>+}
>+
>+function shouldThrowSyntaxError(str, message) {
>+    var hadError = false;
>+    try {
>+        eval(str);
>+    } catch (e) {
>+        if (e instanceof SyntaxError) {
>+            hadError = true;
>+            if (typeof message === "string")
>+                assert(e.message === message, "Expected '" + message + "' but threw '" + e.message + "'");
>+        }
>+    }
>+    assert(hadError, "Did not throw syntax error");
>+}
>+
>+// semantics.js
>+(function mozSemantics() {
>+
>+async function empty() {
>+}
>+
>+async function simpleReturn() {
>+    return 1;
>+}
>+
>+async function simpleAwait() {
>+    var result = await 2;
>+    return result;
>+}
>+
>+async function simpleAwaitAsync() {
>+    var result = await simpleReturn();
>+    return 2 + result;
>+}
>+
>+async function returnOtherAsync() {
>+    return 1 + await simpleAwaitAsync();
>+}
>+
>+async function simpleThrower() {
>+    throw new Error();
>+}
>+
>+async function delegatedThrower() {
>+    var val = await simpleThrower();
>+    return val;
>+}
>+
>+async function tryCatch() {
>+    try {
>+        await delegatedThrower();
>+        return 'FAILED';
>+    } catch (_) {
>+        return 5;
>+    }
>+}
>+
>+async function tryCatchThrow() {
>+    try {
>+        await delegatedThrower();
>+        return 'FAILED';
>+    } catch (_) {
>+        return delegatedThrower();
>+    }
>+}
>+
>+async function wellFinally() {
>+    try {
>+        await delegatedThrower();
>+    } catch (_) {
>+        return 'FAILED';
>+    } finally {
>+        return 6;
>+    }
>+}
>+
>+async function finallyMayFail() {
>+    try {
>+        await delegatedThrower();
>+    } catch (_) {
>+        return 5;
>+    } finally {
>+        return delegatedThrower();
>+    }
>+}
>+
>+async function embedded() {
>+    async function inner() {
>+        return 7;
>+    }
>+    return await inner();
>+}
>+
>+// recursion, it works!
>+async function fib(n) {
>+    return (n == 0 || n == 1) ? n : await fib(n - 1) + await fib(n - 2);
>+}
>+
>+// mutual recursion
>+async function isOdd(n) {
>+    async function isEven(n) {
>+        return n === 0 || await isOdd(n - 1);
>+    }
>+    return n !== 0 && await isEven(n - 1);
>+}
>+
>+// recursion, take three!
>+var hardcoreFib = async function fib2(n) {
>+    return (n == 0 || n == 1) ? n : await fib2(n - 1) + await fib2(n - 2);
>+}
>+
>+var asyncExpr = async function() {
>+    return 10;
>+}
>+
>+var namedAsyncExpr = async function simple() {
>+    return 11;
>+}
>+
>+async function executionOrder() {
>+    var value = 0;
>+    async function first() {
>+        return (value = value === 0 ? 1 : value);
>+    }
>+    async function second() {
>+        return (value = value === 0 ? 2 : value);
>+    }
>+    async function third() {
>+        return (value = value === 0 ? 3 : value);
>+    }
>+    return await first() + await second() + await third() + 6;
>+}
>+
>+async function miscellaneous() {
>+    if (arguments.length === 3 &&
>+        arguments.callee.name === "miscellaneous")
>+        return 14;
>+}
>+
>+function thrower() {
>+    throw 15;
>+}
>+
>+async function defaultArgs(arg = thrower()) {
>+}
>+
>+// Async functions are not constructible
>+shouldThrow(() => {
>+    async function Person() {
>+    }
>+    new Person();
>+}, TypeError);
>+
>+shouldBeAsync(undefined, empty);
>+shouldBeAsync(1, simpleReturn);
>+shouldBeAsync(2, simpleAwait);
>+shouldBeAsync(3, simpleAwaitAsync);
>+shouldBeAsync(4, returnOtherAsync);
>+shouldThrowAsync(simpleThrower, Error);
>+shouldBeAsync(5, tryCatch);
>+shouldBeAsync(6, wellFinally);
>+shouldThrowAsync(finallyMayFail, Error);
>+shouldBeAsync(7, embedded);
>+shouldBeAsync(8, () => fib(6));
>+shouldBeAsync(9, executionOrder);
>+shouldBeAsync(10, asyncExpr);
>+shouldBeAsync(11, namedAsyncExpr);
>+shouldBeAsync(12, () => isOdd(12).then(v => v ? "oops" : 12));
>+shouldBeAsync(13, () => hardcoreFib(7));
>+shouldBeAsync(14, () => miscellaneous(1, 2, 3));
>+shouldBeAsync(15, () => defaultArgs().catch(e => e));
>+
>+})();
>+
>+// methods.js
>+(function mozMethods() {
>+
>+class X {
>+    constructor() {
>+        this.value = 42;
>+    }
>+    async getValue() {
>+        return this.value;
>+    }
>+    setValue(value) {
>+        this.value = value;
>+    }
>+    async increment() {
>+        var value = await this.getValue();
>+        this.setValue(value + 1);
>+        return this.getValue();
>+    }
>+    async getBaseClassName() {
>+        return 'X';
>+    }
>+    static async getStaticValue() {
>+        return 44;
>+    }
>+}
>+
>+class Y extends X {
>+    async getBaseClassName() {
>+        return super.getBaseClassName();
>+    }
>+}
>+
>+var objLiteral = {
>+    async get() {
>+        return 45;
>+    },
>+    someStuff: 5
>+};
>+
>+var x = new X();
>+var y = new Y();
>+
>+shouldBeAsync(42, () => x.getValue());
>+shouldBeAsync(43, () => x.increment());
>+shouldBeAsync(44, () => X.getStaticValue());
>+shouldBeAsync(45, () => objLiteral.get());
>+shouldBeAsync('X', () => y.getBaseClassName());
>+
>+})();
>+
>+(function mozFunctionNameInferrence() {
>+
>+async function test() { }
>+
>+var anon = async function() { }
>+
>+shouldBe("test", test.name);
>+shouldBe("anon", anon.name);
>+
>+})();
>+
>+(function mozSyntaxErrors() {
>+
>+shouldThrowSyntaxError("'use strict'; async function eval() {}");
>+shouldThrowSyntaxError("'use strict'; async function arguments() {}");
>+shouldThrowSyntaxError("async function a(k = super.prop) { }");
>+shouldThrowSyntaxError("async function a() { super.prop(); }");
>+shouldThrowSyntaxError("async function a() { super(); }");
>+shouldThrowSyntaxError("async function a(k = await 3) {}");
>+
>+})();
>diff --git a/Source/JavaScriptCore/tests/es6/async-await-reserved-word.js b/Source/JavaScriptCore/tests/es6/async-await-reserved-word.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..1d2c73df22a85effa32894c268d5ee8fc85eeb80
>--- /dev/null
>+++ b/Source/JavaScriptCore/tests/es6/async-await-reserved-word.js
>@@ -0,0 +1,161 @@
>+function assert(cond, msg = "") {
>+    if (!cond)
>+        throw new Error(msg);
>+}
>+noInline(assert);
>+
>+function shouldThrowSyntaxError(str, message) {
>+    var hadError = false;
>+    try {
>+        eval(str);
>+    } catch (e) {
>+        if (e instanceof SyntaxError) {
>+            hadError = true;
>+            if (typeof message === "string")
>+                assert(e.message === message, "Expected '" + message + "' but threw '" + e.message + "'");
>+        }
>+    }
>+    assert(hadError, "Did not throw syntax error");
>+}
>+noInline(shouldThrowSyntaxError);
>+
>+// AsyncFunctionExpression
>+shouldThrowSyntaxError("(async function() { var await; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { var [await] = []; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { var [...await] = []; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { var {await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { var {isAsync: await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { var {isAsync: await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { let await; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { let [await] = []; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { let [...await] = []; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { let {await} = {}; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { let {isAsync: await} = {}; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { let {isAsync: await} = {}; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { const await; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { const [await] = []; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { const [...await] = []; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { const {await} = {}; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { const {isAsync: await} = {}; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { const {isAsync: await} = {}; })", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("(async function() { function await() {} })", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("(async function() { async function await() {} })", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("(async function(await) {})", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("(async function f([await]) {})", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("(async function f([...await]) {})", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("(async function f(...await) {})", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("(async function f({await}) {})", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("(async function f({isAsync: await}) {})", "Can't use 'await' as a parameter name in an async function.");
>+
>+// AsyncFunctionDeclaration
>+shouldThrowSyntaxError("async function f() { var await; }", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { var [await] = []; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { var [...await] = []; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { var {await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { var {isAsync: await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { var {isAsync: await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { let await; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { let [await] = []; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { let [...await] = []; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { let {await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { let {isAsync: await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { let {isAsync: await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { const await; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { const [await] = []; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { const [...await] = []; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { const {await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { const {isAsync: await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { const {isAsync: await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("async function f() { function await() {} }", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("async function f() { async function await() {} }", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("async function f(await) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("async function f([await]) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("async function f([...await]) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("async function f(...await) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("async function f({await}) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("async function f({isAsync: await}) {}", "Can't use 'await' as a parameter name in an async function.");
>+
>+// AsyncArrowFunction
>+shouldThrowSyntaxError("var f = async () => { var await; }", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { var [await] = []; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { var [...await] = []; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { var {await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { var {isAsync: await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { var {isAsync: await} = {}; })", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { let await; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { let [await] = []; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { let [...await] = []; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { let {await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { let {isAsync: await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { let {isAsync: await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { const await; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { const [await] = []; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { const [...await] = []; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { const {await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { const {isAsync: await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { const {isAsync: await} = {}; }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var f = async () => { function await() {} }", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("var f = async () => { async function await() {} }", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("var f = async (await) => {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var f = async ([await]) => {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var f = async ([...await]) => {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var f = async (...await) => {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var f = async ({await}) => {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var f = async ({isAsync: await}) => {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var f = async await => {}", "Can't use 'await' as a parameter name in an async function.");
>+
>+// AsyncMethod
>+shouldThrowSyntaxError("var O = { async f() { var await; } }", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { var [await] = []; } }", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { var [...await] = []; } }", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { var {await} = {}; } }", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { var {isAsync: await} = {}; } }", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { var {isAsync: await} = {}; } }", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { let await; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { let [await] = []; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { let [...await] = []; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { let {await} = {}; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { let {isAsync: await} = {}; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { let {isAsync: await} = {}; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { const await; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { const [await] = []; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { const [...await] = []; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { const {await} = {}; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { const {isAsync: await} = {}; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { const {isAsync: await} = {}; } }", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { function await() {} }", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("var O = { async f() { async function await() {} } }", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("var O = { async f(await) {} } ", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var O = { async f([await]) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var O = { async f([...await]) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var O = { async f(...await) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var O = { async f({await}) {}", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("var O = { async f({isAsync: await}) {}", "Can't use 'await' as a parameter name in an async function.");
>+
>+// AsyncFunction constructor
>+shouldThrowSyntaxError("AsyncFunction('var await;')", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('var [await] = [];')", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('var [...await] = [];')", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('var {await} = {};')", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('var {isAsync: await} = {};')", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('var {isAsync: await} = {};')", "Can't use 'await' as a variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('let await;')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('let [await] = [];')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('let [...await] = [];')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('let {await} = {};')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('let {isAsync: await} = {};')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('let {isAsync: await} = {};')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('const await;')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('const [await] = [];')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('const [...await] = [];')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('const {await} = {};')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('const {isAsync: await} = {};')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('const {isAsync: await} = {};')", "Can't use 'await' as a lexical variable name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('function await() {}')", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('async function await() {}')", "Cannot declare function named 'await' in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('await', '')", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('[await]', '')", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('[...await]', '')", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('...await', '')", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('{await}', '')", "Can't use 'await' as a parameter name in an async function.");
>+shouldThrowSyntaxError("AsyncFunction('{isAsync: await}', '')", "Can't use 'await' as a parameter name in an async function.");
>diff --git a/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_arguments_binding.js b/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_arguments_binding.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..1c6764a0901eb6f67dd4e89f6fa3d23147891791
>--- /dev/null
>+++ b/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_arguments_binding.js
>@@ -0,0 +1,44 @@
>+function shouldBe(expected, actual, msg) {
>+    if (msg === void 0)
>+        msg = "";
>+    else
>+        msg = " for " + msg;
>+    if (actual !== expected)
>+        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
>+}
>+
>+function shouldBeAsync(expected, run, msg) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+
>+    if (hadError)
>+        throw actual;
>+
>+    shouldBe(expected, actual, msg);
>+}
>+
>+function shouldThrowAsync(run, errorType, message) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+
>+    if (!hadError)
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
>+    if (!(actual instanceof errorType))
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but threw '" + actual + "'");
>+    if (message !== void 0 && actual.message !== message)
>+        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
>+}
>+
>+var noArgumentsArrow = async () => await [...arguments];
>+shouldThrowAsync(() => noArgumentsArrow(1, 2, 3), ReferenceError);
>+var noArgumentsArrow2 = async () => { return await [...arguments]; }
>+shouldThrowAsync(() => noArgumentsArrow2(1, 2, 3), ReferenceError);
>+
>+shouldBeAsync("[1,2,3]", () => (function() { return (async () => JSON.stringify([...arguments]))(); })(1, 2, 3));
>+shouldBeAsync("[4,5,6]", () => (function() { return (async () => { return JSON.stringify([...await arguments]) })(); })(4, 5, 6));
>diff --git a/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_new.target_binding.js b/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_new.target_binding.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..36df0a31106e3bcbedbfaf58a1c3935312458c4d
>--- /dev/null
>+++ b/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_new.target_binding.js
>@@ -0,0 +1,52 @@
>+function shouldBe(expected, actual, msg) {
>+    if (msg === void 0)
>+        msg = "";
>+    else
>+        msg = " for " + msg;
>+    if (actual !== expected)
>+        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
>+}
>+
>+function shouldBeAsync(expected, run, msg) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+
>+    if (hadError)
>+        throw actual;
>+
>+    shouldBe(expected, actual, msg);
>+}
>+
>+function shouldThrowAsync(run, errorType, message) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+
>+    if (!hadError)
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
>+    if (!(actual instanceof errorType))
>+        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but threw '" + actual + "'");
>+    if (message !== void 0 && actual.message !== message)
>+        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
>+}
>+
>+function C1() {
>+    return async () => await new.target;
>+}
>+
>+function C2() {
>+    return async () => { return await new.target };
>+}
>+
>+shouldBeAsync(C1, new C1());
>+shouldBeAsync(undefined, C1());
>+shouldBeAsync(C2, new C2());
>+shouldBeAsync(undefined, C2());
>+
>+shouldThrowAsync(async () => await new.target, ReferenceError);
>+shouldThrowAsync(async () => { return await new.target; }, ReferenceError);
>diff --git a/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_super_binding.js b/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_super_binding.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..7e7dc2cc89e101b381e95ea120d69953f9d323bd
>--- /dev/null
>+++ b/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_super_binding.js
>@@ -0,0 +1,35 @@
>+function shouldBe(expected, actual, msg) {
>+    if (msg === void 0)
>+        msg = "";
>+    else
>+        msg = " for " + msg;
>+    if (actual !== expected)
>+        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
>+}
>+
>+function shouldBeAsync(expected, run, msg) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+
>+    if (hadError)
>+        throw actual;
>+
>+    shouldBe(expected, actual, msg);
>+}
>+
>+class BaseClass {
>+    baseClassValue() {
>+        return "BaseClassValue";
>+    }
>+}
>+
>+class ChildClass extends BaseClass {
>+    asyncSuperProp() {
>+        return async x => super.baseClassValue();
>+    }
>+}
>+
>+shouldBeAsync("BaseClassValue", new ChildClass().asyncSuperProp());
>diff --git a/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_this_binding.js b/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_this_binding.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..3d06682b41a13962b2e8f0ecf1703995dda82a8e
>--- /dev/null
>+++ b/Source/JavaScriptCore/tests/es6/async_arrow_functions_lexical_this_binding.js
>@@ -0,0 +1,27 @@
>+function shouldBe(expected, actual, msg) {
>+    if (msg === void 0)
>+        msg = "";
>+    else
>+        msg = " for " + msg;
>+    if (actual !== expected)
>+        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
>+}
>+
>+function shouldBeAsync(expected, run, msg) {
>+    let actual;
>+    var hadError = false;
>+    run().then(function(value) { actual = value; },
>+               function(error) { hadError = true; actual = error; });
>+    drainMicrotasks();
>+
>+    if (hadError)
>+        throw actual;
>+
>+    shouldBe(expected, actual, msg);
>+}
>+
>+var d = ({ x : "bar", y : function() { return async z => this.x + z; }}).y();
>+var e = { x : "baz", y : d };
>+
>+shouldBeAsync("barley", () => d("ley"));
>+shouldBeAsync("barley", () => e.y("ley"));
>diff --git a/Source/WebKit/mac/WebView/WebPreferencesPrivate.h b/Source/WebKit/mac/WebView/WebPreferencesPrivate.h
>index 2fc3f156203c2c4b3509d63da038adf64586717b..173910d2301650be1d625c6d8477a39d3cbd204d 100644
>--- a/Source/WebKit/mac/WebView/WebPreferencesPrivate.h
>+++ b/Source/WebKit/mac/WebView/WebPreferencesPrivate.h
>@@ -53,6 +53,7 @@ typedef enum {
> } WebStorageBlockingPolicy;
> 
> typedef enum {
>+    WebKitJavaScriptRuntimeFlagsAsyncAwaitEnabled = 1u << 0,
>     WebKitJavaScriptRuntimeFlagsAllEnabled = 0
> } WebKitJavaScriptRuntimeFlags;
> 
>diff --git a/Source/WebKit/win/Interfaces/IWebPreferences.idl b/Source/WebKit/win/Interfaces/IWebPreferences.idl
>index c32c3c166a1492876b43df41bbb8f8ab4b667db0..fcb3f329babcccd6413bde6724c2b12d9c0061e5 100644
>--- a/Source/WebKit/win/Interfaces/IWebPreferences.idl
>+++ b/Source/WebKit/win/Interfaces/IWebPreferences.idl
>@@ -31,6 +31,11 @@ import "oaidl.idl";
> import "ocidl.idl";
> #endif
> 
>+typedef enum WebKitJavaScriptRuntimeFlags {
>+    WebKitJavaScriptRuntimeFlagsAsyncAwaitEnabled = 1, // 1u << 0
>+    WebKitJavaScriptRuntimeFlagsAllEnabled = 0,
>+} WebKitJavaScriptRuntimeFlags;
>+
> typedef enum FontSmoothingType {
>     FontSmoothingTypeStandard=0,
>     FontSmoothingTypeLight,
>diff --git a/Source/WebKit2/UIProcess/API/C/WKPreferencesRefPrivate.h b/Source/WebKit2/UIProcess/API/C/WKPreferencesRefPrivate.h
>index 13d51825d662441355b93c3f92521d52f50674ab..3daa2c913e6c7d50004091dbc0d604a9b552ec92 100644
>--- a/Source/WebKit2/UIProcess/API/C/WKPreferencesRefPrivate.h
>+++ b/Source/WebKit2/UIProcess/API/C/WKPreferencesRefPrivate.h
>@@ -50,6 +50,7 @@ enum WKEditableLinkBehavior {
> typedef enum WKEditableLinkBehavior WKEditableLinkBehavior;
> 
> enum WKJavaScriptRuntimeFlags {
>+    kWKJavaScriptRuntimeFlagsAsyncAwaitEnabled = 1 << 0,
>     kWKJavaScriptRuntimeFlagsAllEnabled = 0
> };
> typedef unsigned WKJavaScriptRuntimeFlagSet;
>diff --git a/Source/WebKit2/UIProcess/API/Cocoa/WKPreferencesPrivate.h b/Source/WebKit2/UIProcess/API/Cocoa/WKPreferencesPrivate.h
>index 09ced5a454130e48abe7295b437edc68c0da830f..bba20a556ac681afc5160564d157a377007caf59 100644
>--- a/Source/WebKit2/UIProcess/API/Cocoa/WKPreferencesPrivate.h
>+++ b/Source/WebKit2/UIProcess/API/Cocoa/WKPreferencesPrivate.h
>@@ -43,6 +43,7 @@ typedef NS_OPTIONS(NSUInteger, _WKDebugOverlayRegions) {
> } WK_ENUM_AVAILABLE(10_11, 9_0);
> 
> typedef NS_OPTIONS(NSUInteger, _WKJavaScriptRuntimeFlags) {
>+    _WKJavaScriptRuntimeFlagsAsyncAwaitEnabled = 1 << 0,
>     _WKJavaScriptRuntimeFlagsAllEnabled = 0
> } WK_ENUM_AVAILABLE(10_11, 9_0);
> 
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index 3c63d864430431e51df880c4da6263ac64ad20dc..6851f982c1c5530bdf348174ee93b598938ec432 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,14 @@
>+2016-04-08  Caitlin Potter  <caitp@igalia.com>
>+
>+        [JSC] implement async functions proposal
>+        https://bugs.webkit.org/show_bug.cgi?id=156147
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Enable jsc command line switches to be passed to `runES6` command
>+
>+        * Scripts/run-jsc-stress-tests:
>+
> 2016-04-08  Youenn Fablet  <youenn.fablet@crf.canon.fr>
> 
>         Testharness-based tests that time out should be able to produce a detailed output
>diff --git a/Tools/Scripts/run-jsc-stress-tests b/Tools/Scripts/run-jsc-stress-tests
>index 95663ecc66a89ae2087f3419981a5367d4ae4af8..df3a206abd177dc6f89aacb4f9cd9b15425415a0 100755
>--- a/Tools/Scripts/run-jsc-stress-tests
>+++ b/Tools/Scripts/run-jsc-stress-tests
>@@ -1011,8 +1011,8 @@ def runControlFlowProfiler
>     end
> end
> 
>-def runES6(mode)
>-    args = [pathToVM.to_s] + BASE_OPTIONS + [$benchmark.to_s]
>+def runES6(mode, flags = [])
>+    args = [pathToVM.to_s] + BASE_OPTIONS + flags + [$benchmark.to_s]
>     case mode
>     when :normal
>         errorHandler = simpleErrorHandler

Actions: View | Formatted Diff | Diff

Attachments on bug 156147: 275508 | 275509 | 275510 | 275521 | 275522 | 275523 | 275524 | 275525 | 275526 | 275529 | 276009 | 276012 | 276013 | 276014 | 276015 | 276020 | 276022 | 276089 | 276098 | 276150 | 276413 | 276565 | 276758 | 277330 | 277702 | 277919 | 277925 | 277938 | 278277 | 278300 | 278692 | 278735 | 279242 | 279546 | 279829 | 279921 | 280020 | 280096 | 280104 | 280106 | 280133 | 280137