Changeset 201542 in webkit

Timestamp:

May 31, 2016, 9:30:57 PM (9 years ago)

Author:

Yusuke Suzuki

Message:

Unreviewed, roll out r201481, r201523: 0.3% regression in Octane code-load
​https://bugs.webkit.org/show_bug.cgi?id=158249

Source/JavaScriptCore:

• API/JSScriptRef.cpp:

(parseScript):

• CMakeLists.txt:
• DerivedSources.make:
• JavaScriptCore.xcodeproj/project.pbxproj:
• builtins/AsyncFunctionPrototype.js: Removed.

(asyncFunctionResume): Deleted.

• builtins/BuiltinExecutables.cpp:

(JSC::BuiltinExecutables::createExecutable):

• bytecode/BytecodeList.json:
• bytecode/BytecodeUseDef.h:

(JSC::computeUsesForBytecodeOffset): Deleted.
(JSC::computeDefsForBytecodeOffset): Deleted.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::finishCreation):
(JSC::CodeBlock::dumpBytecode): Deleted.

• bytecode/UnlinkedCodeBlock.h:

(JSC::UnlinkedCodeBlock::isArrowFunction):
(JSC::UnlinkedCodeBlock::isOrdinaryArrowFunction): Deleted.
(JSC::UnlinkedCodeBlock::isAsyncArrowFunction): Deleted.

• bytecode/UnlinkedFunctionExecutable.cpp:

(JSC::generateUnlinkedFunctionCodeBlock):
(JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
(JSC::UnlinkedFunctionExecutable::fromGlobalCode):
(JSC::UnlinkedFunctionExecutable::unlinkedCodeBlockFor):

• bytecode/UnlinkedFunctionExecutable.h:
• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::BytecodeGenerator):
(JSC::BytecodeGenerator::emitNewArrowFunctionExpression):
(JSC::BytecodeGenerator::emitNewMethodDefinition):
(JSC::BytecodeGenerator::emitLoadArrowFunctionLexicalEnvironment):
(JSC::BytecodeGenerator::emitNewFunctionExpressionCommon): Deleted.
(JSC::BytecodeGenerator::emitNewFunction): Deleted.

• bytecompiler/BytecodeGenerator.h:

(JSC::BytecodeGenerator::makeFunction):

• bytecompiler/NodesCodegen.cpp:

(JSC::FunctionNode::emitBytecode): Deleted.

• inspector/agents/InspectorRuntimeAgent.cpp:

(Inspector::InspectorRuntimeAgent::parse):

• jit/JIT.cpp:

(JSC::JIT::privateCompileMainPass): Deleted.

• jit/JIT.h:
• jit/JITOpcodes.cpp:

(JSC::JIT::emitNewFuncCommon): Deleted.
(JSC::JIT::emit_op_new_async_func): Deleted.
(JSC::JIT::emitNewFuncExprCommon): Deleted.
(JSC::JIT::emit_op_new_async_func_exp): Deleted.

• jit/JITOperations.cpp:
• jit/JITOperations.h:
• jsc.cpp:

(runInteractive):
(printUsageStatement): Deleted.

• llint/LLIntSlowPaths.cpp:

(JSC::LLInt::LLINT_SLOW_PATH_DECL): Deleted.

• llint/LLIntSlowPaths.h:
• llint/LowLevelInterpreter.asm:
• parser/ASTBuilder.h:

(JSC::ASTBuilder::createAsyncFunctionBody): Deleted.

• parser/Keywords.table:
• parser/Parser.cpp:

(JSC::Parser<LexerType>::Parser):
(JSC::Parser<LexerType>::parseInner):
(JSC::Parser<LexerType>::isArrowFunctionParameters):
(JSC::Parser<LexerType>::parseStatementListItem):
(JSC::Parser<LexerType>::parseStatement):
(JSC::Parser<LexerType>::parseFunctionParameters):
(JSC::Parser<LexerType>::parseFunctionInfo):
(JSC::Parser<LexerType>::parseClass):
(JSC::Parser<LexerType>::parseImportClauseItem):
(JSC::Parser<LexerType>::parseImportDeclaration):
(JSC::Parser<LexerType>::parseExportDeclaration):
(JSC::Parser<LexerType>::parseAssignmentExpression):
(JSC::Parser<LexerType>::parseProperty):
(JSC::Parser<LexerType>::parsePropertyMethod):
(JSC::Parser<LexerType>::parsePrimaryExpression):
(JSC::Parser<LexerType>::parseMemberExpression):
(JSC::Parser<LexerType>::parseArrowFunctionExpression):
(JSC::Parser<LexerType>::printUnexpectedTokenText):
(JSC::Parser<LexerType>::parseAsyncFunctionSourceElements): Deleted.
(JSC::Parser<LexerType>::parseVariableDeclarationList): Deleted.
(JSC::Parser<LexerType>::parseDestructuringPattern): Deleted.
(JSC::Parser<LexerType>::parseFunctionDeclarationStatement): Deleted.
(JSC::Parser<LexerType>::parseFormalParameters): Deleted.
(JSC::stringForFunctionMode): Deleted.
(JSC::Parser<LexerType>::parseAsyncFunctionDeclaration): Deleted.
(JSC::Parser<LexerType>::parseExpressionOrLabelStatement): Deleted.
(JSC::Parser<LexerType>::parseAwaitExpression): Deleted.
(JSC::Parser<LexerType>::parseAsyncFunctionExpression): Deleted.
(JSC::Parser<LexerType>::parseUnaryExpression): Deleted.

• parser/Parser.h:

(JSC::Scope::Scope):
(JSC::Parser::ExpressionErrorClassifier::propagateExpressionErrorClass):
(JSC::Parser::closestParentOrdinaryFunctionNonLexicalScope):
(JSC::Parser::pushScope):
(JSC::Parser::popScopeInternal):
(JSC::Parser::matchSpecIdentifier):
(JSC::parse):
(JSC::Scope::setSourceParseMode): Deleted.
(JSC::Scope::isAsyncFunction): Deleted.
(JSC::Scope::isAsyncFunctionBoundary): Deleted.
(JSC::Scope::isModule): Deleted.
(JSC::Scope::setIsFunction): Deleted.
(JSC::Scope::setIsAsyncArrowFunction): Deleted.
(JSC::Scope::setIsAsyncFunction): Deleted.
(JSC::Scope::setIsAsyncFunctionBody): Deleted.
(JSC::Scope::setIsAsyncArrowFunctionBody): Deleted.
(JSC::Parser::ExpressionErrorClassifier::forceClassifyExpressionError): Deleted.
(JSC::Parser::ExpressionErrorClassifier::indicatesPossibleAsyncArrowFunction): Deleted.
(JSC::Parser::forceClassifyExpressionError): Deleted.
(JSC::Parser::declarationTypeToVariableKind): Deleted.
(JSC::Parser::upperScope): Deleted.
(JSC::Parser::isDisallowedIdentifierAwait): Deleted.
(JSC::Parser::disallowedIdentifierAwaitReason): Deleted.

• parser/ParserModes.h:

(JSC::isFunctionParseMode):
(JSC::isModuleParseMode):
(JSC::isProgramParseMode):
(JSC::SourceParseModeSet::SourceParseModeSet): Deleted.
(JSC::SourceParseModeSet::contains): Deleted.
(JSC::SourceParseModeSet::mergeSourceParseModes): Deleted.
(JSC::isAsyncFunctionParseMode): Deleted.
(JSC::isAsyncArrowFunctionParseMode): Deleted.
(JSC::isAsyncFunctionWrapperParseMode): Deleted.
(JSC::isAsyncFunctionBodyParseMode): Deleted.
(JSC::constructAbilityForParseMode): Deleted.

• parser/ParserTokens.h:
• parser/SourceCodeKey.h:

(JSC::SourceCodeKey::SourceCodeKey):
(JSC::SourceCodeKey::operator==):
(JSC::SourceCodeKey::runtimeFlags): Deleted.

• parser/SyntaxChecker.h:

(JSC::SyntaxChecker::createAsyncFunctionBody): Deleted.

• runtime/AsyncFunctionConstructor.cpp: Removed.

(JSC::AsyncFunctionConstructor::AsyncFunctionConstructor): Deleted.
(JSC::AsyncFunctionConstructor::finishCreation): Deleted.
(JSC::callAsyncFunctionConstructor): Deleted.
(JSC::constructAsyncFunctionConstructor): Deleted.
(JSC::AsyncFunctionConstructor::getCallData): Deleted.
(JSC::AsyncFunctionConstructor::getConstructData): Deleted.

• runtime/AsyncFunctionConstructor.h: Removed.

(JSC::AsyncFunctionConstructor::create): Deleted.
(JSC::AsyncFunctionConstructor::createStructure): Deleted.

• runtime/AsyncFunctionPrototype.cpp: Removed.

(JSC::AsyncFunctionPrototype::AsyncFunctionPrototype): Deleted.
(JSC::AsyncFunctionPrototype::finishCreation): Deleted.

• runtime/AsyncFunctionPrototype.h: Removed.

(JSC::AsyncFunctionPrototype::create): Deleted.
(JSC::AsyncFunctionPrototype::createStructure): Deleted.

• runtime/CodeCache.cpp:

(JSC::CodeCache::getGlobalCodeBlock):
(JSC::CodeCache::getProgramCodeBlock):
(JSC::CodeCache::getEvalCodeBlock):
(JSC::CodeCache::getModuleProgramCodeBlock):
(JSC::CodeCache::getFunctionExecutableFromGlobalCode):

• runtime/CodeCache.h:
• runtime/CommonIdentifiers.h:
• runtime/Completion.cpp:

(JSC::checkSyntax):
(JSC::checkModuleSyntax):

• runtime/Completion.h:
• runtime/Executable.cpp:

(JSC::ScriptExecutable::newCodeBlockFor):
(JSC::ProgramExecutable::checkSyntax):

• runtime/Executable.h:
• runtime/FunctionConstructor.cpp:

(JSC::constructFunctionSkippingEvalEnabledCheck):

• runtime/FunctionConstructor.h:
• runtime/JSAsyncFunction.cpp: Removed.

(JSC::JSAsyncFunction::JSAsyncFunction): Deleted.
(JSC::JSAsyncFunction::createImpl): Deleted.
(JSC::JSAsyncFunction::create): Deleted.
(JSC::JSAsyncFunction::createWithInvalidatedReallocationWatchpoint): Deleted.

• runtime/JSAsyncFunction.h: Removed.

(JSC::JSAsyncFunction::allocationSize): Deleted.
(JSC::JSAsyncFunction::createStructure): Deleted.

• runtime/JSFunction.cpp:

(JSC::JSFunction::getOwnPropertySlot):

• runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::createProgramCodeBlock):
(JSC::JSGlobalObject::createEvalCodeBlock):
(JSC::JSGlobalObject::createModuleProgramCodeBlock):
(JSC::JSGlobalObject::init): Deleted.

• runtime/JSGlobalObject.h:

(JSC::JSGlobalObject::asyncFunctionPrototype): Deleted.
(JSC::JSGlobalObject::asyncFunctionStructure): Deleted.

• runtime/ModuleLoaderObject.cpp:

(JSC::moduleLoaderObjectParseModule):

• runtime/RuntimeFlags.h:

(JSC::RuntimeFlags::operator==): Deleted.
(JSC::RuntimeFlags::operator!=): Deleted.

• tests/stress/async-await-basic.js: Removed.

(shouldBe): Deleted.
(shouldBeAsync): Deleted.
(shouldThrow): Deleted.
(shouldThrowAsync): Deleted.
(shouldThrowSyntaxError): Deleted.
(let.AsyncFunction.async): Deleted.
(async.asyncFunctionForProto): Deleted.
(Object.getPrototypeOf.async): Deleted.
(Object.getPrototypeOf.async.method): Deleted.
(async): Deleted.
(async.method): Deleted.
(async.asyncNonConstructorDecl): Deleted.
(shouldThrow.new.async): Deleted.
(shouldThrow.new.async.nonConstructor): Deleted.
(async.asyncDecl): Deleted.
(async.f): Deleted.
(MyError): Deleted.
(async.asyncDeclThrower): Deleted.
(shouldThrowAsync.async): Deleted.
(resolveLater): Deleted.
(rejectLater): Deleted.
(async.resumeAfterNormal): Deleted.
(O.async.resumeAfterNormal): Deleted.
(resumeAfterNormalArrow.async): Deleted.
(async.resumeAfterThrow): Deleted.
(O.async.resumeAfterThrow): Deleted.
(resumeAfterThrowArrow.async): Deleted.
(catch): Deleted.

• tests/stress/async-await-module-reserved-word.js: Removed.

(shouldThrow): Deleted.
(SyntaxError.Canstring_appeared_hereawait.checkModuleSyntaxError.String.raw.await): Deleted.
(checkModuleSyntaxError.String.raw.await): Deleted.
(checkModuleSyntaxError.String.raw.async.await): Deleted.
(SyntaxError.Cannot.declare.named): Deleted.

• tests/stress/async-await-mozilla.js: Removed.

(shouldBe): Deleted.
(shouldBeAsync): Deleted.
(shouldThrow): Deleted.
(shouldThrowAsync): Deleted.
(assert): Deleted.
(shouldThrowSyntaxError): Deleted.
(mozSemantics.async.empty): Deleted.
(mozSemantics.async.simpleReturn): Deleted.
(mozSemantics.async.simpleAwait): Deleted.
(mozSemantics.async.simpleAwaitAsync): Deleted.
(mozSemantics.async.returnOtherAsync): Deleted.
(mozSemantics.async.simpleThrower): Deleted.
(mozSemantics.async.delegatedThrower): Deleted.
(mozSemantics.async.tryCatch): Deleted.
(mozSemantics.async.tryCatchThrow): Deleted.
(mozSemantics.async.wellFinally): Deleted.
(mozSemantics.async.finallyMayFail): Deleted.
(mozSemantics.async.embedded.async.inner): Deleted.
(mozSemantics.async.embedded): Deleted.
(mozSemantics.async.fib): Deleted.
(mozSemantics.async.isOdd.async.isEven): Deleted.
(mozSemantics.async.isOdd): Deleted.
(mozSemantics.hardcoreFib.async.fib2): Deleted.
(mozSemantics.namedAsyncExpr.async.simple): Deleted.
(mozSemantics.async.executionOrder.async.first): Deleted.
(mozSemantics.async.executionOrder.async.second): Deleted.
(mozSemantics.async.executionOrder.async.third): Deleted.
(mozSemantics.async.executionOrder): Deleted.
(mozSemantics.async.miscellaneous): Deleted.
(mozSemantics.thrower): Deleted.
(mozSemantics.async.defaultArgs): Deleted.
(mozSemantics.shouldThrow): Deleted.
(mozSemantics): Deleted.
(mozMethods.X): Deleted.
(mozMethods.X.prototype.async.getValue): Deleted.
(mozMethods.X.prototype.setValue): Deleted.
(mozMethods.X.prototype.async.increment): Deleted.
(mozMethods.X.prototype.async.getBaseClassName): Deleted.
(mozMethods.X.async.getStaticValue): Deleted.
(mozMethods.Y.prototype.async.getBaseClassName): Deleted.
(mozMethods.Y): Deleted.
(mozFunctionNameInferrence.async.test): Deleted.
(mozSyntaxErrors): Deleted.

• tests/stress/async-await-reserved-word.js: Removed.

(assert): Deleted.
(shouldThrowSyntaxError): Deleted.
(AsyncFunction.async): Deleted.

• tests/stress/async_arrow_functions_lexical_arguments_binding.js: Removed.

(shouldBe): Deleted.
(shouldBeAsync): Deleted.
(shouldThrowAsync): Deleted.
(noArgumentsArrow2.async): Deleted.

• tests/stress/async_arrow_functions_lexical_new.target_binding.js: Removed.

(shouldBe): Deleted.
(shouldBeAsync): Deleted.
(shouldThrowAsync): Deleted.
(C1): Deleted.
(C2): Deleted.
(shouldThrowAsync.async): Deleted.

• tests/stress/async_arrow_functions_lexical_super_binding.js: Removed.

(shouldBe): Deleted.
(shouldBeAsync): Deleted.
(BaseClass.prototype.baseClassValue): Deleted.
(BaseClass.prototype.get property): Deleted.
(BaseClass): Deleted.
(ChildClass.prototype.asyncSuperProp): Deleted.
(ChildClass.prototype.asyncSuperProp2): Deleted.
(ChildClass): Deleted.
(ChildClass2): Deleted.

• tests/stress/async_arrow_functions_lexical_this_binding.js: Removed.

(shouldBe): Deleted.
(shouldBeAsync): Deleted.
(d.y): Deleted.

Source/WebKit/mac:

• WebView/WebPreferencesPrivate.h:

Source/WebKit/win:

• Interfaces/IWebPreferencesPrivate.idl:

Source/WebKit2:

• UIProcess/API/C/WKPreferencesRefPrivate.h:
• UIProcess/API/Cocoa/WKPreferencesPrivate.h:

Location:

trunk/Source

Files:

• JavaScriptCore/API/JSScriptRef.cpp (modified) (1 diff)
• JavaScriptCore/CMakeLists.txt (modified) (3 diffs)
• JavaScriptCore/ChangeLog (modified) (1 diff)
• JavaScriptCore/DerivedSources.make (modified) (1 diff)
• JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj (modified) (11 diffs)
• JavaScriptCore/builtins/AsyncFunctionPrototype.js (deleted)
• JavaScriptCore/builtins/BuiltinExecutables.cpp (modified) (1 diff)
• JavaScriptCore/bytecode/BytecodeList.json (modified) (1 diff)
• JavaScriptCore/bytecode/BytecodeUseDef.h (modified) (3 diffs)
• JavaScriptCore/bytecode/CodeBlock.cpp (modified) (2 diffs)
• JavaScriptCore/bytecode/UnlinkedCodeBlock.h (modified) (1 diff)
• JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp (modified) (8 diffs)
• JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h (modified) (4 diffs)
• JavaScriptCore/bytecompiler/BytecodeGenerator.cpp (modified) (12 diffs)
• JavaScriptCore/bytecompiler/BytecodeGenerator.h (modified) (2 diffs)
• JavaScriptCore/bytecompiler/NodesCodegen.cpp (modified) (1 diff)
• JavaScriptCore/inspector/agents/InspectorRuntimeAgent.cpp (modified) (2 diffs)
• JavaScriptCore/jit/JIT.cpp (modified) (1 diff)
• JavaScriptCore/jit/JIT.h (modified) (1 diff)
• JavaScriptCore/jit/JITOpcodes.cpp (modified) (4 diffs)
• JavaScriptCore/jit/JITOperations.cpp (modified) (2 diffs)
• JavaScriptCore/jit/JITOperations.h (modified) (1 diff)
• JavaScriptCore/jsc.cpp (modified) (2 diffs)
• JavaScriptCore/llint/LLIntSlowPaths.cpp (modified) (3 diffs)
• JavaScriptCore/llint/LLIntSlowPaths.h (modified) (1 diff)
• JavaScriptCore/llint/LowLevelInterpreter.asm (modified) (3 diffs)
• JavaScriptCore/parser/ASTBuilder.h (modified) (1 diff)
• JavaScriptCore/parser/Keywords.table (modified) (1 diff)
• JavaScriptCore/parser/Parser.cpp (modified) (61 diffs)
• JavaScriptCore/parser/Parser.h (modified) (32 diffs)
• JavaScriptCore/parser/ParserModes.h (modified) (2 diffs)
• JavaScriptCore/parser/ParserTokens.h (modified) (1 diff)
• JavaScriptCore/parser/SourceCodeKey.h (modified) (5 diffs)
• JavaScriptCore/parser/SyntaxChecker.h (modified) (1 diff)
• JavaScriptCore/runtime/AsyncFunctionConstructor.cpp (deleted)
• JavaScriptCore/runtime/AsyncFunctionConstructor.h (deleted)
• JavaScriptCore/runtime/AsyncFunctionPrototype.cpp (deleted)
• JavaScriptCore/runtime/AsyncFunctionPrototype.h (deleted)
• JavaScriptCore/runtime/CodeCache.cpp (modified) (5 diffs)
• JavaScriptCore/runtime/CodeCache.h (modified) (3 diffs)
• JavaScriptCore/runtime/CommonIdentifiers.h (modified) (2 diffs)
• JavaScriptCore/runtime/Completion.cpp (modified) (3 diffs)
• JavaScriptCore/runtime/Completion.h (modified) (1 diff)
• JavaScriptCore/runtime/Executable.cpp (modified) (2 diffs)
• JavaScriptCore/runtime/Executable.h (modified) (1 diff)
• JavaScriptCore/runtime/FunctionConstructor.cpp (modified) (1 diff)
• JavaScriptCore/runtime/FunctionConstructor.h (modified) (1 diff)
• JavaScriptCore/runtime/JSAsyncFunction.cpp (deleted)
• JavaScriptCore/runtime/JSAsyncFunction.h (deleted)
• JavaScriptCore/runtime/JSFunction.cpp (modified) (1 diff)
• JavaScriptCore/runtime/JSGlobalObject.cpp (modified) (7 diffs)
• JavaScriptCore/runtime/JSGlobalObject.h (modified) (5 diffs)
• JavaScriptCore/runtime/ModuleLoaderObject.cpp (modified) (1 diff)
• JavaScriptCore/runtime/RuntimeFlags.h (modified) (2 diffs)
• JavaScriptCore/tests/stress/async-await-basic.js (deleted)
• JavaScriptCore/tests/stress/async-await-module-reserved-word.js (deleted)
• JavaScriptCore/tests/stress/async-await-mozilla.js (deleted)
• JavaScriptCore/tests/stress/async-await-reserved-word.js (deleted)
• JavaScriptCore/tests/stress/async_arrow_functions_lexical_arguments_binding.js (deleted)
• JavaScriptCore/tests/stress/async_arrow_functions_lexical_new.target_binding.js (deleted)
• JavaScriptCore/tests/stress/async_arrow_functions_lexical_super_binding.js (deleted)
• JavaScriptCore/tests/stress/async_arrow_functions_lexical_this_binding.js (deleted)
• WebKit/mac/ChangeLog (modified) (1 diff)
• WebKit/mac/WebView/WebPreferencesPrivate.h (modified) (1 diff)
• WebKit/win/ChangeLog (modified) (1 diff)
• WebKit/win/Interfaces/IWebPreferencesPrivate.idl (modified) (1 diff)
• WebKit2/ChangeLog (modified) (1 diff)
• WebKit2/UIProcess/API/C/WKPreferencesRefPrivate.h (modified) (1 diff)
• WebKit2/UIProcess/API/Cocoa/WKPreferencesPrivate.h (modified) (1 diff)

trunk/Source/JavaScriptCore/API/JSScriptRef.cpp

@@ -76 +76 @@
 {
     return !!JSC::parse<JSC::ProgramNode>(
-        vm, RuntimeFlags(), source, Identifier(), JSParserBuiltinMode::NotBuiltin,
+        vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded,
         error);

trunk/Source/JavaScriptCore/CMakeLists.txt

@@ -609 +609 @@
     runtime/ArrayIteratorPrototype.cpp
     runtime/ArrayPrototype.cpp
-    runtime/AsyncFunctionConstructor.cpp
-    runtime/AsyncFunctionPrototype.cpp
     runtime/BasicBlockLocation.cpp
     runtime/BooleanConstructor.cpp
@@ -685 +683 @@
     runtime/JSArrayBufferView.cpp
     runtime/JSArrayIterator.cpp
-    runtime/JSAsyncFunction.cpp
     runtime/JSBoundFunction.cpp
     runtime/JSBoundSlotBaseFunction.cpp
@@ -1214 +1211 @@
     ${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

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2016-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        Unreviewed, roll out r201481, r201523: 0.3% regression in Octane code-load
+        https://bugs.webkit.org/show_bug.cgi?id=158249
+
+        * API/JSScriptRef.cpp:
+        (parseScript):
+        * CMakeLists.txt:
+        * DerivedSources.make:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * builtins/AsyncFunctionPrototype.js: Removed.
+        (asyncFunctionResume): Deleted.
+        * builtins/BuiltinExecutables.cpp:
+        (JSC::BuiltinExecutables::createExecutable):
+        * bytecode/BytecodeList.json:
+        * bytecode/BytecodeUseDef.h:
+        (JSC::computeUsesForBytecodeOffset): Deleted.
+        (JSC::computeDefsForBytecodeOffset): Deleted.
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::finishCreation):
+        (JSC::CodeBlock::dumpBytecode): Deleted.
+        * bytecode/UnlinkedCodeBlock.h:
+        (JSC::UnlinkedCodeBlock::isArrowFunction):
+        (JSC::UnlinkedCodeBlock::isOrdinaryArrowFunction): Deleted.
+        (JSC::UnlinkedCodeBlock::isAsyncArrowFunction): Deleted.
+        * bytecode/UnlinkedFunctionExecutable.cpp:
+        (JSC::generateUnlinkedFunctionCodeBlock):
+        (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):
+        (JSC::UnlinkedFunctionExecutable::fromGlobalCode):
+        (JSC::UnlinkedFunctionExecutable::unlinkedCodeBlockFor):
+        * bytecode/UnlinkedFunctionExecutable.h:
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::BytecodeGenerator):
+        (JSC::BytecodeGenerator::emitNewArrowFunctionExpression):
+        (JSC::BytecodeGenerator::emitNewMethodDefinition):
+        (JSC::BytecodeGenerator::emitLoadArrowFunctionLexicalEnvironment):
+        (JSC::BytecodeGenerator::emitNewFunctionExpressionCommon): Deleted.
+        (JSC::BytecodeGenerator::emitNewFunction): Deleted.
+        * bytecompiler/BytecodeGenerator.h:
+        (JSC::BytecodeGenerator::makeFunction):
+        * bytecompiler/NodesCodegen.cpp:
+        (JSC::FunctionNode::emitBytecode): Deleted.
+        * inspector/agents/InspectorRuntimeAgent.cpp:
+        (Inspector::InspectorRuntimeAgent::parse):
+        * jit/JIT.cpp:
+        (JSC::JIT::privateCompileMainPass): Deleted.
+        * jit/JIT.h:
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::emitNewFuncCommon): Deleted.
+        (JSC::JIT::emit_op_new_async_func): Deleted.
+        (JSC::JIT::emitNewFuncExprCommon): Deleted.
+        (JSC::JIT::emit_op_new_async_func_exp): Deleted.
+        * jit/JITOperations.cpp:
+        * jit/JITOperations.h:
+        * jsc.cpp:
+        (runInteractive):
+        (printUsageStatement): Deleted.
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL): Deleted.
+        * llint/LLIntSlowPaths.h:
+        * llint/LowLevelInterpreter.asm:
+        * parser/ASTBuilder.h:
+        (JSC::ASTBuilder::createAsyncFunctionBody): Deleted.
+        * parser/Keywords.table:
+        * parser/Parser.cpp:
+        (JSC::Parser<LexerType>::Parser):
+        (JSC::Parser<LexerType>::parseInner):
+        (JSC::Parser<LexerType>::isArrowFunctionParameters):
+        (JSC::Parser<LexerType>::parseStatementListItem):
+        (JSC::Parser<LexerType>::parseStatement):
+        (JSC::Parser<LexerType>::parseFunctionParameters):
+        (JSC::Parser<LexerType>::parseFunctionInfo):
+        (JSC::Parser<LexerType>::parseClass):
+        (JSC::Parser<LexerType>::parseImportClauseItem):
+        (JSC::Parser<LexerType>::parseImportDeclaration):
+        (JSC::Parser<LexerType>::parseExportDeclaration):
+        (JSC::Parser<LexerType>::parseAssignmentExpression):
+        (JSC::Parser<LexerType>::parseProperty):
+        (JSC::Parser<LexerType>::parsePropertyMethod):
+        (JSC::Parser<LexerType>::parsePrimaryExpression):
+        (JSC::Parser<LexerType>::parseMemberExpression):
+        (JSC::Parser<LexerType>::parseArrowFunctionExpression):
+        (JSC::Parser<LexerType>::printUnexpectedTokenText):
+        (JSC::Parser<LexerType>::parseAsyncFunctionSourceElements): Deleted.
+        (JSC::Parser<LexerType>::parseVariableDeclarationList): Deleted.
+        (JSC::Parser<LexerType>::parseDestructuringPattern): Deleted.
+        (JSC::Parser<LexerType>::parseFunctionDeclarationStatement): Deleted.
+        (JSC::Parser<LexerType>::parseFormalParameters): Deleted.
+        (JSC::stringForFunctionMode): Deleted.
+        (JSC::Parser<LexerType>::parseAsyncFunctionDeclaration): Deleted.
+        (JSC::Parser<LexerType>::parseExpressionOrLabelStatement): Deleted.
+        (JSC::Parser<LexerType>::parseAwaitExpression): Deleted.
+        (JSC::Parser<LexerType>::parseAsyncFunctionExpression): Deleted.
+        (JSC::Parser<LexerType>::parseUnaryExpression): Deleted.
+        * parser/Parser.h:
+        (JSC::Scope::Scope):
+        (JSC::Parser::ExpressionErrorClassifier::propagateExpressionErrorClass):
+        (JSC::Parser::closestParentOrdinaryFunctionNonLexicalScope):
+        (JSC::Parser::pushScope):
+        (JSC::Parser::popScopeInternal):
+        (JSC::Parser::matchSpecIdentifier):
+        (JSC::parse):
+        (JSC::Scope::setSourceParseMode): Deleted.
+        (JSC::Scope::isAsyncFunction): Deleted.
+        (JSC::Scope::isAsyncFunctionBoundary): Deleted.
+        (JSC::Scope::isModule): Deleted.
+        (JSC::Scope::setIsFunction): Deleted.
+        (JSC::Scope::setIsAsyncArrowFunction): Deleted.
+        (JSC::Scope::setIsAsyncFunction): Deleted.
+        (JSC::Scope::setIsAsyncFunctionBody): Deleted.
+        (JSC::Scope::setIsAsyncArrowFunctionBody): Deleted.
+        (JSC::Parser::ExpressionErrorClassifier::forceClassifyExpressionError): Deleted.
+        (JSC::Parser::ExpressionErrorClassifier::indicatesPossibleAsyncArrowFunction): Deleted.
+        (JSC::Parser::forceClassifyExpressionError): Deleted.
+        (JSC::Parser::declarationTypeToVariableKind): Deleted.
+        (JSC::Parser::upperScope): Deleted.
+        (JSC::Parser::isDisallowedIdentifierAwait): Deleted.
+        (JSC::Parser::disallowedIdentifierAwaitReason): Deleted.
+        * parser/ParserModes.h:
+        (JSC::isFunctionParseMode):
+        (JSC::isModuleParseMode):
+        (JSC::isProgramParseMode):
+        (JSC::SourceParseModeSet::SourceParseModeSet): Deleted.
+        (JSC::SourceParseModeSet::contains): Deleted.
+        (JSC::SourceParseModeSet::mergeSourceParseModes): Deleted.
+        (JSC::isAsyncFunctionParseMode): Deleted.
+        (JSC::isAsyncArrowFunctionParseMode): Deleted.
+        (JSC::isAsyncFunctionWrapperParseMode): Deleted.
+        (JSC::isAsyncFunctionBodyParseMode): Deleted.
+        (JSC::constructAbilityForParseMode): Deleted.
+        * parser/ParserTokens.h:
+        * parser/SourceCodeKey.h:
+        (JSC::SourceCodeKey::SourceCodeKey):
+        (JSC::SourceCodeKey::operator==):
+        (JSC::SourceCodeKey::runtimeFlags): Deleted.
+        * parser/SyntaxChecker.h:
+        (JSC::SyntaxChecker::createAsyncFunctionBody): Deleted.
+        * runtime/AsyncFunctionConstructor.cpp: Removed.
+        (JSC::AsyncFunctionConstructor::AsyncFunctionConstructor): Deleted.
+        (JSC::AsyncFunctionConstructor::finishCreation): Deleted.
+        (JSC::callAsyncFunctionConstructor): Deleted.
+        (JSC::constructAsyncFunctionConstructor): Deleted.
+        (JSC::AsyncFunctionConstructor::getCallData): Deleted.
+        (JSC::AsyncFunctionConstructor::getConstructData): Deleted.
+        * runtime/AsyncFunctionConstructor.h: Removed.
+        (JSC::AsyncFunctionConstructor::create): Deleted.
+        (JSC::AsyncFunctionConstructor::createStructure): Deleted.
+        * runtime/AsyncFunctionPrototype.cpp: Removed.
+        (JSC::AsyncFunctionPrototype::AsyncFunctionPrototype): Deleted.
+        (JSC::AsyncFunctionPrototype::finishCreation): Deleted.
+        * runtime/AsyncFunctionPrototype.h: Removed.
+        (JSC::AsyncFunctionPrototype::create): Deleted.
+        (JSC::AsyncFunctionPrototype::createStructure): Deleted.
+        * runtime/CodeCache.cpp:
+        (JSC::CodeCache::getGlobalCodeBlock):
+        (JSC::CodeCache::getProgramCodeBlock):
+        (JSC::CodeCache::getEvalCodeBlock):
+        (JSC::CodeCache::getModuleProgramCodeBlock):
+        (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
+        * runtime/CodeCache.h:
+        * runtime/CommonIdentifiers.h:
+        * runtime/Completion.cpp:
+        (JSC::checkSyntax):
+        (JSC::checkModuleSyntax):
+        * runtime/Completion.h:
+        * runtime/Executable.cpp:
+        (JSC::ScriptExecutable::newCodeBlockFor):
+        (JSC::ProgramExecutable::checkSyntax):
+        * runtime/Executable.h:
+        * runtime/FunctionConstructor.cpp:
+        (JSC::constructFunctionSkippingEvalEnabledCheck):
+        * runtime/FunctionConstructor.h:
+        * runtime/JSAsyncFunction.cpp: Removed.
+        (JSC::JSAsyncFunction::JSAsyncFunction): Deleted.
+        (JSC::JSAsyncFunction::createImpl): Deleted.
+        (JSC::JSAsyncFunction::create): Deleted.
+        (JSC::JSAsyncFunction::createWithInvalidatedReallocationWatchpoint): Deleted.
+        * runtime/JSAsyncFunction.h: Removed.
+        (JSC::JSAsyncFunction::allocationSize): Deleted.
+        (JSC::JSAsyncFunction::createStructure): Deleted.
+        * runtime/JSFunction.cpp:
+        (JSC::JSFunction::getOwnPropertySlot):
+        * runtime/JSGlobalObject.cpp:
+        (JSC::JSGlobalObject::createProgramCodeBlock):
+        (JSC::JSGlobalObject::createEvalCodeBlock):
+        (JSC::JSGlobalObject::createModuleProgramCodeBlock):
+        (JSC::JSGlobalObject::init): Deleted.
+        * runtime/JSGlobalObject.h:
+        (JSC::JSGlobalObject::asyncFunctionPrototype): Deleted.
+        (JSC::JSGlobalObject::asyncFunctionStructure): Deleted.
+        * runtime/ModuleLoaderObject.cpp:
+        (JSC::moduleLoaderObjectParseModule):
+        * runtime/RuntimeFlags.h:
+        (JSC::RuntimeFlags::operator==): Deleted.
+        (JSC::RuntimeFlags::operator!=): Deleted.
+        * tests/stress/async-await-basic.js: Removed.
+        (shouldBe): Deleted.
+        (shouldBeAsync): Deleted.
+        (shouldThrow): Deleted.
+        (shouldThrowAsync): Deleted.
+        (shouldThrowSyntaxError): Deleted.
+        (let.AsyncFunction.async): Deleted.
+        (async.asyncFunctionForProto): Deleted.
+        (Object.getPrototypeOf.async): Deleted.
+        (Object.getPrototypeOf.async.method): Deleted.
+        (async): Deleted.
+        (async.method): Deleted.
+        (async.asyncNonConstructorDecl): Deleted.
+        (shouldThrow.new.async): Deleted.
+        (shouldThrow.new.async.nonConstructor): Deleted.
+        (async.asyncDecl): Deleted.
+        (async.f): Deleted.
+        (MyError): Deleted.
+        (async.asyncDeclThrower): Deleted.
+        (shouldThrowAsync.async): Deleted.
+        (resolveLater): Deleted.
+        (rejectLater): Deleted.
+        (async.resumeAfterNormal): Deleted.
+        (O.async.resumeAfterNormal): Deleted.
+        (resumeAfterNormalArrow.async): Deleted.
+        (async.resumeAfterThrow): Deleted.
+        (O.async.resumeAfterThrow): Deleted.
+        (resumeAfterThrowArrow.async): Deleted.
+        (catch): Deleted.
+        * tests/stress/async-await-module-reserved-word.js: Removed.
+        (shouldThrow): Deleted.
+        (SyntaxError.Canstring_appeared_hereawait.checkModuleSyntaxError.String.raw.await): Deleted.
+        (checkModuleSyntaxError.String.raw.await): Deleted.
+        (checkModuleSyntaxError.String.raw.async.await): Deleted.
+        (SyntaxError.Cannot.declare.named): Deleted.
+        * tests/stress/async-await-mozilla.js: Removed.
+        (shouldBe): Deleted.
+        (shouldBeAsync): Deleted.
+        (shouldThrow): Deleted.
+        (shouldThrowAsync): Deleted.
+        (assert): Deleted.
+        (shouldThrowSyntaxError): Deleted.
+        (mozSemantics.async.empty): Deleted.
+        (mozSemantics.async.simpleReturn): Deleted.
+        (mozSemantics.async.simpleAwait): Deleted.
+        (mozSemantics.async.simpleAwaitAsync): Deleted.
+        (mozSemantics.async.returnOtherAsync): Deleted.
+        (mozSemantics.async.simpleThrower): Deleted.
+        (mozSemantics.async.delegatedThrower): Deleted.
+        (mozSemantics.async.tryCatch): Deleted.
+        (mozSemantics.async.tryCatchThrow): Deleted.
+        (mozSemantics.async.wellFinally): Deleted.
+        (mozSemantics.async.finallyMayFail): Deleted.
+        (mozSemantics.async.embedded.async.inner): Deleted.
+        (mozSemantics.async.embedded): Deleted.
+        (mozSemantics.async.fib): Deleted.
+        (mozSemantics.async.isOdd.async.isEven): Deleted.
+        (mozSemantics.async.isOdd): Deleted.
+        (mozSemantics.hardcoreFib.async.fib2): Deleted.
+        (mozSemantics.namedAsyncExpr.async.simple): Deleted.
+        (mozSemantics.async.executionOrder.async.first): Deleted.
+        (mozSemantics.async.executionOrder.async.second): Deleted.
+        (mozSemantics.async.executionOrder.async.third): Deleted.
+        (mozSemantics.async.executionOrder): Deleted.
+        (mozSemantics.async.miscellaneous): Deleted.
+        (mozSemantics.thrower): Deleted.
+        (mozSemantics.async.defaultArgs): Deleted.
+        (mozSemantics.shouldThrow): Deleted.
+        (mozSemantics): Deleted.
+        (mozMethods.X): Deleted.
+        (mozMethods.X.prototype.async.getValue): Deleted.
+        (mozMethods.X.prototype.setValue): Deleted.
+        (mozMethods.X.prototype.async.increment): Deleted.
+        (mozMethods.X.prototype.async.getBaseClassName): Deleted.
+        (mozMethods.X.async.getStaticValue): Deleted.
+        (mozMethods.Y.prototype.async.getBaseClassName): Deleted.
+        (mozMethods.Y): Deleted.
+        (mozFunctionNameInferrence.async.test): Deleted.
+        (mozSyntaxErrors): Deleted.
+        * tests/stress/async-await-reserved-word.js: Removed.
+        (assert): Deleted.
+        (shouldThrowSyntaxError): Deleted.
+        (AsyncFunction.async): Deleted.
+        * tests/stress/async_arrow_functions_lexical_arguments_binding.js: Removed.
+        (shouldBe): Deleted.
+        (shouldBeAsync): Deleted.
+        (shouldThrowAsync): Deleted.
+        (noArgumentsArrow2.async): Deleted.
+        * tests/stress/async_arrow_functions_lexical_new.target_binding.js: Removed.
+        (shouldBe): Deleted.
+        (shouldBeAsync): Deleted.
+        (shouldThrowAsync): Deleted.
+        (C1): Deleted.
+        (C2): Deleted.
+        (shouldThrowAsync.async): Deleted.
+        * tests/stress/async_arrow_functions_lexical_super_binding.js: Removed.
+        (shouldBe): Deleted.
+        (shouldBeAsync): Deleted.
+        (BaseClass.prototype.baseClassValue): Deleted.
+        (BaseClass.prototype.get property): Deleted.
+        (BaseClass): Deleted.
+        (ChildClass.prototype.asyncSuperProp): Deleted.
+        (ChildClass.prototype.asyncSuperProp2): Deleted.
+        (ChildClass): Deleted.
+        (ChildClass2): Deleted.
+        * tests/stress/async_arrow_functions_lexical_this_binding.js: Removed.
+        (shouldBe): Deleted.
+        (shouldBeAsync): Deleted.
+        (d.y): Deleted.
+
 2016-05-31  Commit Queue  <commit-queue@webkit.org>
 

trunk/Source/JavaScriptCore/DerivedSources.make

@@ -85 +85 @@
     $(JavaScriptCore)/builtins/ArrayIteratorPrototype.js \
     $(JavaScriptCore)/builtins/ArrayPrototype.js \
-    $(JavaScriptCore)/builtins/AsyncFunctionPrototype.js \
     $(JavaScriptCore)/builtins/DatePrototype.js \
     $(JavaScriptCore)/builtins/FunctionPrototype.js \

trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

@@ -1180 +1180 @@
                 5370B4F51BF26202005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5370B4F31BF25EA2005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.cpp */; };
                 5370B4F61BF26205005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 5370B4F41BF25EA2005C40FC /* AdaptiveInferredPropertyValueWatchpointBase.h */; };
-                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 */; };
                 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, ); }; };
@@ -3330 +3324 @@
                 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>"; };
                 5D5D8AD00E0D0EBE00F9C692 /* libedit.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libedit.dylib; path = /usr/lib/libedit.dylib; sourceTree = "<absolute>"; };
                 5DAFD6CB146B686300FBEFB4 /* JSC.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = JSC.xcconfig; sourceTree = "<group>"; };
@@ -5534 +5521 @@
                                 F692A84E0255597D01FF60F7 /* ArrayPrototype.h */,
                                 0FB7F38A15ED8E3800F167B2 /* ArrayStorage.h */,
-                                5BD3A0611CAE325700F84BA3 /* AsyncFunctionConstructor.cpp */,
-                                5BD3A0621CAE325700F84BA3 /* AsyncFunctionConstructor.h */,
-                                5BD3A0631CAE325700F84BA3 /* AsyncFunctionPrototype.cpp */,
-                                5BD3A0641CAE325700F84BA3 /* AsyncFunctionPrototype.h */,
                                 52678F8C1A031009006A306D /* BasicBlockLocation.cpp */,
                                 52678F8D1A031009006A306D /* BasicBlockLocation.h */,
@@ -5714 +5697 @@
                                 A7BDAEC417F4EA1400F6140C /* JSArrayIterator.cpp */,
                                 A7BDAEC517F4EA1400F6140C /* JSArrayIterator.h */,
-                                5BD3A0651CAE325700F84BA3 /* JSAsyncFunction.cpp */,
-                                5BD3A06D1CAE35BF00F84BA3 /* JSAsyncFunction.h */,
                                 86FA9E8F142BBB2D001773B7 /* JSBoundFunction.cpp */,
                                 86FA9E90142BBB2E001773B7 /* JSBoundFunction.h */,
@@ -6869 +6850 @@
                         isa = PBXGroup;
                         children = (
-                                5BF474881CB1C5DB0002BAD7 /* AsyncFunctionPrototype.js */,
                                 A7D801A01880D66E0026C39B /* ArrayPrototype.js */,
                                 7CF9BC581B65D9A3009DB1EF /* ArrayConstructor.js */,
@@ -7187 +7167 @@
                                 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 */,
@@ -7545 +7524 @@
                                 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 */,
@@ -8089 +8067 @@
                                 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 */,
@@ -8656 +8633 @@
                                 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 */,
@@ -9270 +9246 @@
                                 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 */,
@@ -9405 +9380 @@
                                 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 */,

trunk/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp

@@ -80 +80 @@
     RefPtr<SourceProvider> sourceOverride = isParsingDefaultConstructor ? source.provider() : nullptr;
     std::unique_ptr<ProgramNode> program = parse<ProgramNode>(
-        &vm, RuntimeFlags(), source, Identifier(), builtinMode,
+        &vm, source, Identifier(), builtinMode,
         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded, error,
         &positionBeforeLastNewline, constructorKind);

trunk/Source/JavaScriptCore/bytecode/BytecodeList.json

@@ -100 +100 @@
             { "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_set_function_name", "length" : 3 },
             { "name" : "op_call", "length" : 9 },

trunk/Source/JavaScriptCore/bytecode/BytecodeUseDef.h

@@ -150 +150 @@
     case op_get_enumerable_length:
     case op_new_func_exp:
-    case op_new_async_func_exp:
     case op_new_generator_func_exp:
     case op_to_index_string:
@@ -181 +180 @@
     case op_unsigned:
     case op_new_func:
-    case op_new_async_func:
     case op_new_generator_func:
     case op_get_parent_scope:
@@ -381 +379 @@
     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:

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -1413 +1413 @@
             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_func_exp: {
             int r0 = (++it)->u.operand;
@@ -2334 +2318 @@
 
     // Perform bytecode liveness analysis to determine which locals are live and should be resumed when executing op_resume.
-    if (unlinkedCodeBlock->parseMode() == SourceParseMode::GeneratorBodyMode || isAsyncFunctionBodyParseMode(unlinkedCodeBlock->parseMode())) {
+    if (unlinkedCodeBlock->parseMode() == SourceParseMode::GeneratorBodyMode) {
         if (size_t count = mergePointBytecodeOffsets.size()) {
             createRareDataIfNecessary();

trunk/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h

@@ -119 +119 @@
     bool usesEval() const { return m_usesEval; }
     SourceParseMode parseMode() const { return m_parseMode; }
-    bool isArrowFunction() const { return isOrdinaryArrowFunction() || isAsyncArrowFunction(); }
-    bool isOrdinaryArrowFunction() const { return m_parseMode == SourceParseMode::ArrowFunctionMode; }
-    bool isAsyncArrowFunction() const { return m_parseMode == SourceParseMode::AsyncArrowFunctionMode; }
+    bool isArrowFunction() const { return m_parseMode == SourceParseMode::ArrowFunctionMode; }
     DerivedContextType derivedContextType() const { return static_cast<DerivedContextType>(m_derivedContextType); }
     EvalContextType evalContextType() const { return static_cast<EvalContextType>(m_evalContextType); }

trunk/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp

@@ -49 +49 @@
 
 static UnlinkedFunctionCodeBlock* generateUnlinkedFunctionCodeBlock(
-    VM& vm, const RuntimeFlags& runtimeFlags, UnlinkedFunctionExecutable* executable, const SourceCode& source,
+    VM& vm, UnlinkedFunctionExecutable* executable, const SourceCode& source,
     CodeSpecializationKind kind, DebuggerMode debuggerMode,
     UnlinkedFunctionKind functionKind, ParserError& error, SourceParseMode parseMode)
@@ -57 +57 @@
     ASSERT(isFunctionParseMode(executable->parseMode()));
     std::unique_ptr<FunctionNode> function = parse<FunctionNode>(
-        &vm, runtimeFlags, source, executable->name(), builtinMode, strictMode, executable->parseMode(), executable->superBinding(), error, nullptr);
+        &vm, source, executable->name(), builtinMode, strictMode, executable->parseMode(), executable->superBinding(), error, nullptr);
 
     if (!function) {
@@ -92 +92 @@
     , m_parameterCount(node->parameterCount())
     , m_features(0)
-    , m_sourceParseMode(node->parseMode())
     , m_isInStrictContext(node->isInStrictContext())
     , m_hasCapturedVariables(false)
@@ -101 +100 @@
     , m_superBinding(static_cast<unsigned>(node->superBinding()))
     , m_derivedContextType(static_cast<unsigned>(derivedContextType))
+    , m_sourceParseMode(static_cast<unsigned>(node->parseMode()))
     , m_name(node->ident())
     , m_ecmaName(node->ecmaName())
@@ -113 +113 @@
     ASSERT(m_superBinding == static_cast<unsigned>(node->superBinding()));
     ASSERT(m_derivedContextType == static_cast<unsigned>(derivedContextType));
+    ASSERT(m_sourceParseMode == static_cast<unsigned>(node->parseMode()));
 
     m_parentScopeTDZVariables.swap(parentScopeTDZVariables);
@@ -175 +176 @@
     VM& vm = exec.vm();
     CodeCache* codeCache = vm.codeCache();
-    UnlinkedFunctionExecutable* executable = codeCache->getFunctionExecutableFromGlobalCode(vm, exec.lexicalGlobalObject()->runtimeFlags(), name, source, error);
+    UnlinkedFunctionExecutable* executable = codeCache->getFunctionExecutableFromGlobalCode(vm, name, source, error);
 
     auto& globalObject = *exec.lexicalGlobalObject();
@@ -190 +191 @@
 
 UnlinkedFunctionCodeBlock* UnlinkedFunctionExecutable::unlinkedCodeBlockFor(
-    VM& vm, const RuntimeFlags& runtimeFlags, const SourceCode& source, CodeSpecializationKind specializationKind, 
+    VM& vm, const SourceCode& source, CodeSpecializationKind specializationKind, 
     DebuggerMode debuggerMode, ParserError& error, SourceParseMode parseMode)
 {
@@ -205 +206 @@
 
     UnlinkedFunctionCodeBlock* result = generateUnlinkedFunctionCodeBlock(
-        vm, runtimeFlags, this, source, specializationKind, debuggerMode,
+        vm, this, source, specializationKind, debuggerMode, 
         isBuiltinFunction() ? UnlinkedBuiltinFunction : UnlinkedNormalFunction, 
         error, parseMode);

trunk/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h

@@ -51 +51 @@
 class FunctionExecutable;
 class ParserError;
-class RuntimeFlags;
 class SourceCode;
 class SourceProvider;
@@ -103 +102 @@
 
     UnlinkedFunctionCodeBlock* unlinkedCodeBlockFor(
-        VM&, const RuntimeFlags&, const SourceCode&, CodeSpecializationKind, DebuggerMode,
+        VM&, const SourceCode&, CodeSpecializationKind, DebuggerMode,
         ParserError&, SourceParseMode);
 
@@ -159 +158 @@
     unsigned m_parameterCount;
     CodeFeatures m_features;
-    SourceParseMode m_sourceParseMode;
     unsigned m_isInStrictContext : 1;
     unsigned m_hasCapturedVariables : 1;
@@ -168 +166 @@
     unsigned m_superBinding : 1;
     unsigned m_derivedContextType: 2;
+    unsigned m_sourceParseMode : 4; // SourceParseMode
 
     WriteBarrier<UnlinkedFunctionCodeBlock> m_unlinkedCodeBlockForCall;

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

@@ -33 +33 @@
 
 #include "BuiltinExecutables.h"
-#include "BuiltinNames.h"
 #include "BytecodeLivenessAnalysis.h"
 #include "Interpreter.h"
@@ -249 +248 @@
     bool needsArguments = (functionNode->usesArguments() || codeBlock->usesEval() || (functionNode->usesArrowFunction() && !codeBlock->isArrowFunction() && isArgumentsUsedInInnerArrowFunction()));
 
-    // Generator and AsyncFunction never provides "arguments". "arguments" reference will be resolved in an upper generator function scope.
-    if (parseMode == SourceParseMode::GeneratorBodyMode || isAsyncFunctionBodyParseMode(parseMode))
+    // Generator never provides "arguments". "arguments" reference will be resolved in an upper generator function scope.
+    if (parseMode == SourceParseMode::GeneratorBodyMode)
         needsArguments = false;
 
-    if ((parseMode == SourceParseMode::GeneratorWrapperFunctionMode || isAsyncFunctionWrapperParseMode(parseMode)) && needsArguments) {
+    if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode && needsArguments) {
         // Generator does not provide "arguments". Instead, wrapping GeneratorFunction provides "arguments".
         // This is because arguments of a generator should be evaluated before starting it.
@@ -300 +299 @@
 
     // Before emitting a scope creation, emit a generator prologue that contains jump based on a generator's state.
-    if (parseMode == SourceParseMode::GeneratorBodyMode || isAsyncFunctionBodyParseMode(parseMode)) {
+    if (parseMode == SourceParseMode::GeneratorBodyMode) {
         m_generatorRegister = &m_parameters[1];
 
@@ -315 +314 @@
     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());
@@ -541 +538 @@
     }
 
-    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.
@@ -596 +568 @@
     // We need load |super| & |this| for arrow function before initializeDefaultParameterValuesAndSetupFunctionScopeStack
     // if we have default parameter expression. Because |super| & |this| values can be used there
-    //
-    // Also load here for AsyncArrowFunctions, as they may refer to |super| in their formal parameter expressions as well.
-    if ((SourceParseMode::ArrowFunctionMode == parseMode || parseMode == SourceParseMode::AsyncArrowFunctionMode) && !isSimpleParameterList) {
+    if (SourceParseMode::ArrowFunctionMode == parseMode && !isSimpleParameterList) {
         if (functionNode->usesThis() || functionNode->usesSuperProperty())
             emitLoadThisFromArrowFunctionLexicalEnvironment();
@@ -617 +587 @@
     // because a function's default parameter ExpressionNodes will use temporary registers.
     pushTDZVariables(*parentScopeTDZVariables, TDZCheckOptimization::DoNotOptimize);
-
-    TryData* tryFormalParametersData = nullptr;
-    if (isAsyncFunctionWrapperParseMode(parseMode) && !isSimpleParameterList) {
-        RefPtr<Label> tryFormalParametersStart = emitLabel(newLabel().get());
-        tryFormalParametersData = pushTry(tryFormalParametersStart.get());
-    }
-
     initializeDefaultParameterValuesAndSetupFunctionScopeStack(parameters, isSimpleParameterList, functionNode, functionSymbolTable, symbolTableConstantIndex, captures, shouldCreateArgumentsVariableInParameterScope);
-
-    if (isAsyncFunctionWrapperParseMode(parseMode) && !isSimpleParameterList) {
-        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());
-    }
-
+    
     // If we don't have  default parameter expression, then 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
-    //
-    // For AsyncArrowFunctionBody functions, the lexical environment may have been loaded by the wrapper function,
-    // but may need to be loaded separately if it's used again in the function body.
-    // FIXME: only require loading the lexical context once per async arrow function.
-    if ((SourceParseMode::ArrowFunctionMode == parseMode && isSimpleParameterList) || SourceParseMode::AsyncArrowFunctionBodyMode == parseMode) {
+    if (SourceParseMode::ArrowFunctionMode == parseMode && isSimpleParameterList) {
         if (functionNode->usesThis() || functionNode->usesSuperProperty())
             emitLoadThisFromArrowFunctionLexicalEnvironment();
@@ -2955 +2887 @@
         opcodeID = op_new_generator_func_exp;
         break;
-
-    case SourceParseMode::AsyncFunctionMode:
-    case SourceParseMode::AsyncMethodMode:
-    case SourceParseMode::AsyncArrowFunctionMode:
-        opcodeID = op_new_async_func_exp;
-        break;
-
     default:
         break;
@@ -2980 +2905 @@
 RegisterID* BytecodeGenerator::emitNewArrowFunctionExpression(RegisterID* dst, ArrowFuncExprNode* func)
 {
-    ASSERT(func->metadata()->parseMode() == SourceParseMode::ArrowFunctionMode || func->metadata()->parseMode() == SourceParseMode::AsyncArrowFunctionMode);
+    ASSERT(func->metadata()->parseMode() == SourceParseMode::ArrowFunctionMode);
     emitNewFunctionExpressionCommon(dst, func->metadata());
     return dst;
@@ -2990 +2915 @@
         || func->metadata()->parseMode() == SourceParseMode::GetterMode
         || func->metadata()->parseMode() == SourceParseMode::SetterMode
-        || func->metadata()->parseMode() == SourceParseMode::MethodMode
-        || func->metadata()->parseMode() == SourceParseMode::AsyncMethodMode);
+        || func->metadata()->parseMode() == SourceParseMode::MethodMode);
     emitNewFunctionExpressionCommon(dst, func->metadata());
     return dst;
@@ -3018 +2942 @@
     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);
@@ -4308 +4230 @@
 RegisterID* BytecodeGenerator::emitLoadArrowFunctionLexicalEnvironment(const Identifier& identifier)
 {
-    ASSERT(m_codeBlock->isArrowFunction() || parseMode() == SourceParseMode::AsyncArrowFunctionBodyMode || m_codeBlock->isArrowFunctionContext() || constructorKind() == ConstructorKind::Derived || m_codeType == EvalCode);
+    ASSERT(m_codeBlock->isArrowFunction() || m_codeBlock->isArrowFunctionContext() || constructorKind() == ConstructorKind::Derived || m_codeType == EvalCode);
 
     return emitResolveScope(nullptr, variable(identifier, ThisResolutionType::Scoped));

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

@@ -823 +823 @@
             DerivedContextType newDerivedContextType = DerivedContextType::None;
 
-            if (metadata->parseMode() == SourceParseMode::ArrowFunctionMode || metadata->parseMode() == SourceParseMode::AsyncArrowFunctionMode) {
+            if (metadata->parseMode() == SourceParseMode::ArrowFunctionMode) {
                 if (constructorKind() == ConstructorKind::Derived || isDerivedConstructorContext())
                     newDerivedContextType = DerivedContextType::DerivedConstructorContext;
@@ -837 +837 @@
             SourceParseMode parseMode = metadata->parseMode();
             ConstructAbility constructAbility = ConstructAbility::CanConstruct;
-            if (parseMode == SourceParseMode::GetterMode || parseMode == SourceParseMode::SetterMode || parseMode == SourceParseMode::ArrowFunctionMode || parseMode == SourceParseMode::GeneratorWrapperFunctionMode || isAsyncFunctionParseMode(parseMode))
+            if (parseMode == SourceParseMode::GetterMode || parseMode == SourceParseMode::SetterMode || parseMode == SourceParseMode::ArrowFunctionMode || parseMode == SourceParseMode::GeneratorWrapperFunctionMode)
                 constructAbility = ConstructAbility::CannotConstruct;
             else if (parseMode == SourceParseMode::MethodMode && metadata->constructorKind() == ConstructorKind::None)

trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

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

trunk/Source/JavaScriptCore/inspector/agents/InspectorRuntimeAgent.cpp

@@ -42 +42 @@
 #include "JSLock.h"
 #include "ParserError.h"
-#include "RuntimeFlags.h"
 #include "ScriptDebugServer.h"
 #include "SourceCode.h"
@@ -92 +91 @@
 
     ParserError error;
-    checkSyntax(m_vm, RuntimeFlags(), JSC::makeSource(expression), error);
+    checkSyntax(m_vm, JSC::makeSource(expression), error);
 
     switch (error.syntaxErrorType()) {

trunk/Source/JavaScriptCore/jit/JIT.cpp

@@ -284 +284 @@
         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_object)
         DEFINE_OP(op_new_regexp)

trunk/Source/JavaScriptCore/jit/JIT.h

@@ -554 +554 @@
         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_object(Instruction*);
         void emit_op_new_regexp(Instruction*);

trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

@@ -972 +972 @@
     if (opcodeID == op_new_func)
         callOperation(operationNewFunction, dst, regT0, funcExec);
-    else if (opcodeID == op_new_async_func)
-        callOperation(operationNewAsyncFunction, dst, regT0, funcExec);
     else {
         ASSERT(opcodeID == op_new_generator_func);
@@ -986 +984 @@
 
 void JIT::emit_op_new_generator_func(Instruction* currentInstruction)
-{
-    emitNewFuncCommon(currentInstruction);
-}
-
-void JIT::emit_op_new_async_func(Instruction* currentInstruction)
 {
     emitNewFuncCommon(currentInstruction);
@@ -1016 +1009 @@
     if (opcodeID == op_new_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);
@@ -1032 +1023 @@
 
 void JIT::emit_op_new_generator_func_exp(Instruction* currentInstruction)
-{
-    emitNewFuncExprCommon(currentInstruction);
-}
-
-void JIT::emit_op_new_async_func_exp(Instruction* currentInstruction)
 {
     emitNewFuncExprCommon(currentInstruction);

trunk/Source/JavaScriptCore/jit/JITOperations.cpp

@@ -47 +47 @@
 #include "JITExceptions.h"
 #include "JITToDFGDeferredCompilationCallback.h"
-#include "JSAsyncFunction.h"
 #include "JSCInlines.h"
 #include "JSGeneratorFunction.h"
@@ -1102 +1101 @@
 {
     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);
 }
 

trunk/Source/JavaScriptCore/jit/JITOperations.h

@@ -346 +346 @@
 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;

trunk/Source/JavaScriptCore/jsc.cpp

@@ -2098 +2098 @@
             source = source + line;
             source = source + '\n';
-            checkSyntax(globalObject->vm(), globalObject->runtimeFlags(), makeSource(source, interpreterName), error);
+            checkSyntax(globalObject->vm(), makeSource(source, interpreterName), error);
             if (!line[0])
                 break;
@@ -2161 +2161 @@
     fprintf(stderr, "  --dumpOptions              Dumps all non-default JSC VM options before continuing\n");
     fprintf(stderr, "  --<jsc VM option>=<value>  Sets the specified JSC VM option\n");
-
     fprintf(stderr, "\n");
 

trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp

@@ -41 +41 @@
 #include "JIT.h"
 #include "JITExceptions.h"
-#include "JSAsyncFunction.h"
 #include "JSLexicalEnvironment.h"
 #include "JSCInlines.h"
@@ -1077 +1076 @@
 }
 
-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)
 {
@@ -1119 +1107 @@
 
     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));
 }
 

trunk/Source/JavaScriptCore/llint/LLIntSlowPaths.h

@@ -101 +101 @@
 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);

trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

@@ -1241 +1241 @@
 
 
-_llint_op_new_async_func:
-    traceExecution()
-    callSlowPath(_llint_slow_path_new_async_func)
-    dispatch(4)
-
-
 _llint_op_new_generator_func:
     traceExecution()
@@ -1502 +1496 @@
     dispatch(0)
 
+
 _llint_op_new_func_exp:
     traceExecution()
@@ -1510 +1505 @@
     traceExecution()
     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)
 

trunk/Source/JavaScriptCore/parser/ASTBuilder.h

@@ -381 +381 @@
     }
 
-    ExpressionNode* createAsyncFunctionBody(const JSTokenLocation& location, const ParserFunctionInfo<ASTBuilder>& functionInfo, SourceParseMode parseMode)
-    {
-        if (parseMode == SourceParseMode::AsyncArrowFunctionBodyMode) {
-            SourceCode source = m_sourceCode->subExpression(functionInfo.startOffset, functionInfo.body->isArrowFunctionBodyExpression() ? functionInfo.endOffset - 1 : functionInfo.endOffset, functionInfo.startLine, functionInfo.parametersStartColumn);
-            FuncExprNode* result = new (m_parserArena) FuncExprNode(location, *functionInfo.name, functionInfo.body, source);
-            functionInfo.body->setLoc(functionInfo.startLine, functionInfo.endLine, location.startOffset, location.lineStartOffset);
-            return result;
-        }
-        return createFunctionExpr(location, functionInfo);
-    }
-
     ExpressionNode* createMethodDefinition(const JSTokenLocation& location, const ParserFunctionInfo<ASTBuilder>& functionInfo)
     {

trunk/Source/JavaScriptCore/parser/Keywords.table

@@ -8 +8 @@
 
 # Keywords.
-await           AWAIT
 break           BREAK
 case            CASE

trunk/Source/JavaScriptCore/parser/Parser.cpp

@@ -196 +196 @@
 
 template <typename LexerType>
-Parser<LexerType>::Parser(VM* vm, RuntimeFlags runtimeFlags, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding, ConstructorKind defaultConstructorKind, DerivedContextType derivedContextType, bool isEvalContext, EvalContextType evalContextType)
+Parser<LexerType>::Parser(VM* vm, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding, ConstructorKind defaultConstructorKind, 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())
@@ -254 +253 @@
     SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Body);
 
-    bool isArrowFunctionBodyExpression = parseMode == SourceParseMode::AsyncArrowFunctionBodyMode && !match(OPENBRACE);
+    bool isArrowFunctionBodyExpression = false;
     if (m_lexer->isReparsingFunction()) {
         ParserFunctionInfo<ASTBuilder> functionInfo;
-        if (SourceParseModeSet(SourceParseMode::GeneratorBodyMode).contains(parseMode) || isAsyncFunctionBodyParseMode(parseMode))
+        if (parseMode == SourceParseMode::GeneratorBodyMode)
             m_parameters = createGeneratorParameters(context);
         else
             m_parameters = parseFunctionParameters(context, parseMode, functionInfo);
 
-        if (SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(parseMode) && !hasError()) {
+        if (parseMode == SourceParseMode::ArrowFunctionMode && !hasError()) {
             // The only way we could have an error wile reparsing is if we run out of stack space.
             RELEASE_ASSERT(match(ARROWFUNCTION));
@@ -279 +278 @@
     // The only way we can error this early is if we reparse a function and we run out of stack space.
     if (!hasError()) {
-        if (isAsyncFunctionWrapperParseMode(parseMode))
-            sourceElements = parseAsyncFunctionSourceElements(context, parseMode, isArrowFunctionBodyExpression, CheckForStrictMode);
-        else if (isArrowFunctionBodyExpression)
+        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);
+        }
     }
 
@@ -308 +307 @@
         varDeclarations.markVariableAsCaptured(entry);
 
-    if (SourceParseModeSet(SourceParseMode::GeneratorWrapperFunctionMode).contains(parseMode) || isAsyncFunctionWrapperParseMode(parseMode)) {
+    if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode) {
         if (scope->usedVariablesContains(m_vm->propertyNames->arguments.impl()))
             context.propagateArgumentsUse();
@@ -353 +352 @@
 bool Parser<LexerType>::isArrowFunctionParameters()
 {
-    if (match(OPENPAREN)) {
-        SavePoint saveArrowFunctionPoint = createSavePoint();
-        next();
-        bool isArrowFunction = false;
+    bool isOpenParen = match(OPENPAREN);
+    bool isIdent = match(IDENT);
+    
+    if (!isOpenParen && !isIdent)
+        return false;
+
+    bool isArrowFunction = false;
+    SavePoint saveArrowFunctionPoint = createSavePoint();
+        
+    if (isIdent) {
+        next();
+        isArrowFunction = match(ARROWFUNCTION);
+    } else {
+        RELEASE_ASSERT(isOpenParen);
+        next();
         if (match(CLOSEPAREN)) {
             next();
@@ -368 +378 @@
             unsigned parametersCount = 0;
             isArrowFunction = parseFormalParameters(syntaxChecker, syntaxChecker.createFormalParameterList(), parametersCount) && consume(CLOSEPAREN) && match(ARROWFUNCTION);
-
+                
             popScope(fakeScope, syntaxChecker.NeedsFreeVariableInfo);
         }
-        restoreSavePoint(saveArrowFunctionPoint);
-        return isArrowFunction;
-    }
-
-    if (matchSpecIdentifier()) {
-        SavePoint saveArrowFunctionPoint = createSavePoint();
-        next();
-        bool isArrowFunction = match(ARROWFUNCTION);
-        restoreSavePoint(saveArrowFunctionPoint);
-        return isArrowFunction;
-    }
-
-    return false;
+    }
+        
+    restoreSavePoint(saveArrowFunctionPoint);
+        
+    return isArrowFunction;
 }
 
@@ -528 +530 @@
 
 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;
-    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 = isArrowFunctionBodyExpression ? tokenLocation().endOffset : m_token.m_data.offset;
-    info.parametersStartColumn = startColumn;
-
-    auto functionExpr = context.createAsyncFunctionBody(startLocation, info, innerParseMode);
-    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)
 {
@@ -581 +538 @@
     TreeStatement result = 0;
     bool shouldSetEndOffset = true;
-
     switch (m_token.m_type) {
     case CONSTTOKEN:
@@ -596 +552 @@
             // 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(AWAIT)) && !match(OPENBRACE) && !match(OPENBRACKET))
+            if (!(match(IDENT) || match(LET) || match(YIELD)) && !match(OPENBRACE) && !match(OPENBRACKET))
                 shouldParseVariableDeclaration = false;
             restoreSavePoint(savePoint);
@@ -616 +572 @@
         break;
     case IDENT:
-        // FIXME: This branch contributes to a 1% octane code-load regression.
-        // https://bugs.webkit.org/show_bug.cgi?id=158211
-        if (UNLIKELY(*m_token.m_data.ident == m_vm->propertyNames->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();
-                next();
-                if (UNLIKELY(match(FUNCTION) && !m_lexer->prevTerminator())) {
-                    result = parseAsyncFunctionDeclaration(context);
-                    break;
-                }
-                restoreSavePoint(savePoint);
-            }
-        }
-        FALLTHROUGH;
-    case AWAIT:
     case YIELD: {
         // This is a convenient place to notice labeled statements
@@ -741 +680 @@
             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());
@@ -1064 +1002 @@
                         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);
                 }
@@ -1133 +1070 @@
         }
         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();
@@ -1682 +1618 @@
         break;
     case FUNCTION: {
-        const bool isAsync = false;
-        result = parseFunctionDeclarationStatement(context, isAsync, parentAllowsFunctionDeclarationAsStatement);
+        if (!strictMode()) {
+            failIfFalse(parentAllowsFunctionDeclarationAsStatement, "Function declarations are only allowed inside block statements or at the top level of a program");
+            if (currentScope()->isFunction()) {
+                // Any function declaration that isn't in a block is a syntax error unless it's
+                // in an if/else statement. If it's in an if/else statement, we will magically
+                // treat it as if the if/else statement is inside a block statement.
+                // to the very top like a "var". For example:
+                // function a() {
+                //     if (cond) function foo() { }
+                // }
+                // will be rewritten as:
+                // function a() {
+                //     if (cond) { function foo() { } }
+                // }
+                AutoPopScopeRef blockScope(this, pushScope());
+                blockScope->setIsLexicalScope();
+                blockScope->preventVarDeclarations();
+                JSTokenLocation location(tokenLocation());
+                int start = tokenLine();
+
+                TreeStatement function = parseFunctionDeclaration(context);
+                propagateError();
+                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 = parseFunctionDeclaration(context);
+            }
+        } else
+            failWithMessage("Function declarations are only allowed inside blocks or switch statements in strict mode");
         break;
     }
@@ -1735 +1706 @@
         return 0;
     case IDENT:
-        // FIXME: This branch contributes to a 1% octane code-load regression.
-        // https://bugs.webkit.org/show_bug.cgi?id=158211
-        if (UNLIKELY(*m_token.m_data.ident == m_vm->propertyNames->async)) {
-            if (m_runtimeFlags.isAsyncAwaitEnabled()) {
-                SavePoint savePoint = createSavePoint();
-                next();
-                if (match(FUNCTION) && !m_lexer->prevTerminator()) {
-                    const bool isAsync = true;
-                    result = parseFunctionDeclarationStatement(context, isAsync, parentAllowsFunctionDeclarationAsStatement);
-                    break;
-                }
-                restoreSavePoint(savePoint);
-            }
-        }
-        FALLTHROUGH;
-    case AWAIT:
     case YIELD: {
         bool allowFunctionDeclarationAsStatement = false;
@@ -1776 +1731 @@
 
 template <typename LexerType>
-template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclarationStatement(TreeBuilder& context, bool isAsync, bool parentAllowsFunctionDeclarationAsStatement)
-{
-    semanticFailIfTrue(strictMode(), "Function declarations are only allowed inside blocks or switch statements in strict mode");
-    failIfFalse(parentAllowsFunctionDeclarationAsStatement, "Function declarations are only allowed inside block statements or at the top level of a program");
-    if (!currentScope()->isFunction()) {
-        // 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;
-        if (isAsync)
-            return parseAsyncFunctionDeclaration(context);
-        return parseFunctionDeclaration(context);
-    }
-
-    // Any function declaration that isn't in a block is a syntax error unless it's
-    // in an if/else statement. If it's in an if/else statement, we will magically
-    // treat it as if the if/else statement is inside a block statement.
-    // to the very top like a "var". For example:
-    // function a() {
-    //     if (cond) function foo() { }
-    // }
-    // will be rewritten as:
-    // function a() {
-    //     if (cond) { function foo() { } }
-    // }
-    AutoPopScopeRef blockScope(this, pushScope());
-    blockScope->setIsLexicalScope();
-    blockScope->preventVarDeclarations();
-    JSTokenLocation location(tokenLocation());
-    int start = tokenLine();
-
-    TreeStatement function = 0;
-    if (!isAsync)
-        function = parseFunctionDeclaration(context);
-    else
-        function = parseAsyncFunctionDeclaration(context);
-    propagateError();
-    failIfFalse(function, "Expected valid function statement after 'function' keyword");
-    TreeSourceElements sourceElements = context.createSourceElements();
-    context.appendStatement(sourceElements, function);
-    TreeStatement result = context.createBlockStatement(location, sourceElements, start, m_lastTokenEndPosition.line, currentScope()->finalizeLexicalEnvironment(), currentScope()->takeFunctionDeclarations());
-    popScope(blockScope, TreeBuilder::NeedsFreeVariableInfo);
-    return result;
-}
-
-template <typename LexerType>
 template <class TreeBuilder> bool Parser<LexerType>::parseFormalParameters(TreeBuilder& context, TreeFormalParameterList list, unsigned& parameterCount)
 {
@@ -1845 +1753 @@
             next();
             failIfFalse(matchSpecIdentifier(), "Rest parameter '...' should be followed by a variable identifier");
-            semanticFailIfTrue(!m_parserState.allowAwait && match(AWAIT), "Can't use 'await' as a parameter name in an async function");
             declareRestOrNormalParameter(*m_token.m_data.ident, &duplicateParameter);
             propagateError();
@@ -1911 +1818 @@
     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:
@@ -1931 +1830 @@
 template <typename LexerType> template <class TreeBuilder, class FunctionInfoType> typename TreeBuilder::FormalParameterList Parser<LexerType>::parseFunctionParameters(TreeBuilder& context, SourceParseMode mode, FunctionInfoType& functionInfo)
 {
-    ASSERT(!(SourceParseModeSet(SourceParseMode::ProgramMode, SourceParseMode::ModuleAnalyzeMode, SourceParseMode::ModuleEvaluateMode).contains(mode)));
+    RELEASE_ASSERT(mode != SourceParseMode::ProgramMode && mode != SourceParseMode::ModuleAnalyzeMode && mode != SourceParseMode::ModuleEvaluateMode);
     TreeFormalParameterList parameterList = context.createFormalParameterList();
     SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Parameters);
     
-    if (SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(mode)) {
-        if (!matchSpecIdentifier() && !match(OPENPAREN)) {
+    if (mode == SourceParseMode::ArrowFunctionMode) {
+        if (!match(IDENT) && !match(OPENPAREN)) {
             semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
             failWithMessage("Expected an arrow function input parameter");
@@ -2027 +1926 @@
     RELEASE_ASSERT(isFunctionParseMode(mode));
 
-    bool isDisallowedAwaitFunctionName = isDisallowedIdentifierAwait(m_token);
-    const char* isDisallowedAwaitFunctionNameReason = isDisallowedAwaitFunctionName ? disallowedIdentifierAwaitReason() : nullptr;
-
+    bool upperScopeIsGenerator = currentScope()->isGenerator();
     AutoPopScopeRef functionScope(this, pushScope());
     functionScope->setSourceParseMode(mode);
@@ -2068 +1965 @@
             
             FunctionBodyType functionBodyType;
-            if (SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(mode))
+            if (mode == SourceParseMode::ArrowFunctionMode)
                 functionBodyType = cachedInfo->isBodyArrowExpression ?  ArrowFunctionBodyExpression : ArrowFunctionBodyBlock;
             else
@@ -2111 +2008 @@
     SyntaxChecker syntaxChecker(const_cast<VM*>(m_vm), m_lexer.get());
 
-    if (SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(mode)) {
+    if (mode == SourceParseMode::ArrowFunctionMode) {
         startLocation = tokenLocation();
         functionInfo.startLine = tokenLine();
         startColumn = tokenColumn();
+
         parametersStart = m_token.m_location.startOffset;
         functionInfo.startOffset = parametersStart;
@@ -2121 +2019 @@
         if (loadCachedFunction())
             return true;
-        {
-            SetForScope<bool> overrideAllowAwait(m_parserState.allowAwait, !isAsyncFunctionParseMode(mode));
-            parseFunctionParameters(syntaxChecker, mode, functionInfo);
-        }
-
+        parseFunctionParameters(syntaxChecker, mode, functionInfo);
         propagateError();
 
@@ -2155 +2049 @@
         //     function * BindingIdentifier[Yield]opt ( FormalParameters[Yield] ) { GeneratorBody }
         //
-        // The name of FunctionExpression and AsyncFunctionExpression can accept "yield" even in the context of generator.
-        bool upperScopeIsGenerator = false;
-        if (!(functionDefinitionType == FunctionDefinitionType::Expression && SourceParseModeSet(SourceParseMode::NormalFunctionMode, SourceParseMode::AsyncFunctionMode).contains(mode)))
-            upperScopeIsGenerator = upperScope(1)->isGenerator();
+        // The name of FunctionExpression can accept "yield" even in the context of generator.
+        if (functionDefinitionType == FunctionDefinitionType::Expression && mode == SourceParseMode::NormalFunctionMode)
+            upperScopeIsGenerator = false;
 
         if (matchSpecIdentifier(upperScopeIsGenerator)) {
-            bool allowsAwait = functionDefinitionType == FunctionDefinitionType::Declaration || mode != SourceParseMode::AsyncFunctionMode;
             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)) {
-                semanticFailIfTrue(mode == SourceParseMode::NormalFunctionMode, "Function statements must have a name");
-                semanticFailIfTrue(mode == SourceParseMode::AsyncFunctionMode, "Async function statements must have a name");
-            }
+            if (match(OPENPAREN) && mode == SourceParseMode::NormalFunctionMode)
+                semanticFail("Function statements must have a name");
             semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
             failDueToUnexpectedToken();
@@ -2192 +2077 @@
         if (loadCachedFunction())
             return true;
-        {
-            SetForScope<bool> overrideAllowAwait(m_parserState.allowAwait, !isAsyncFunctionParseMode(mode));
-            parseFunctionParameters(syntaxChecker, mode, functionInfo);
-            propagateError();
-        }
+        parseFunctionParameters(syntaxChecker, mode, functionInfo);
+        propagateError();
         
         matchOrFail(OPENBRACE, "Expected an opening '{' at the start of a ", stringForFunctionMode(mode), " body");
@@ -2240 +2122 @@
     };
 
-    if (UNLIKELY((SourceParseModeSet(SourceParseMode::GeneratorWrapperFunctionMode).contains(mode)) || isAsyncFunctionWrapperParseMode(mode))) {
+    if (mode == SourceParseMode::GeneratorWrapperFunctionMode) {
         AutoPopScopeRef generatorBodyScope(this, pushScope());
-        SourceParseMode innerParseMode = SourceParseMode::GeneratorBodyMode;
-        if (isAsyncFunctionWrapperParseMode(mode)) {
-            innerParseMode = mode == SourceParseMode::AsyncArrowFunctionMode
-                ? SourceParseMode::AsyncArrowFunctionBodyMode
-                : SourceParseMode::AsyncFunctionBodyMode;
-        }
-        generatorBodyScope->setSourceParseMode(innerParseMode);
+        generatorBodyScope->setSourceParseMode(SourceParseMode::GeneratorBodyMode);
         generatorBodyScope->setConstructorKind(ConstructorKind::None);
         generatorBodyScope->setExpectedSuperBinding(expectedSuperBinding);
@@ -2266 +2142 @@
     context.setEndOffset(functionInfo.body, m_lexer->currentOffset());
     if (functionScope->strictMode() && functionInfo.name) {
-        RELEASE_ASSERT((SourceParseModeSet(SourceParseMode::NormalFunctionMode, SourceParseMode::MethodMode, SourceParseMode::ArrowFunctionMode, SourceParseMode::GeneratorBodyMode, SourceParseMode::GeneratorWrapperFunctionMode).contains(mode)) || isAsyncFunctionWrapperParseMode(mode));
+        RELEASE_ASSERT(mode == SourceParseMode::NormalFunctionMode || mode == SourceParseMode::MethodMode || mode == SourceParseMode::ArrowFunctionMode || mode == SourceParseMode::GeneratorBodyMode || mode == SourceParseMode::GeneratorWrapperFunctionMode);
         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");
@@ -2353 +2229 @@
 
 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)
 {
@@ -2479 +2326 @@
         bool isSetter = false;
         bool isGenerator = false;
-        bool isAsyncMethod = false;
         if (consume(TIMES))
             isGenerator = true;
-
-parseMethod:
         switch (m_token.m_type) {
         namedKeyword:
@@ -2492 +2336 @@
             break;
         case IDENT:
-        case AWAIT:
             ident = m_token.m_data.ident;
             ASSERT(ident);
             next();
-            if (!isGenerator && !isAsyncMethod && (matchIdentifierOrKeyword() || match(STRING) || match(DOUBLE) || match(INTEGER) || match(OPENBRACKET))) {
+            if (!isGenerator && (matchIdentifierOrKeyword() || match(STRING) || match(DOUBLE) || match(INTEGER) || match(OPENBRACKET))) {
                 isGetter = *ident == propertyNames.get;
                 isSetter = *ident == propertyNames.set;
-                if (UNLIKELY(!isAsyncMethod && *ident == propertyNames.async && !m_lexer->prevTerminator())) {
-                    if (m_runtimeFlags.isAsyncAwaitEnabled()) {
-                        isAsyncMethod = true;
-                        goto parseMethod;
-                    }
-                }
             }
             break;
@@ -2536 +2373 @@
             bool isConstructor = !isStaticMethod && *ident == propertyNames.constructor;
             SourceParseMode parseMode = SourceParseMode::MethodMode;
-            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) {
+            if (isGenerator) {
                 isConstructor = false;
                 parseMode = SourceParseMode::GeneratorWrapperFunctionMode;
@@ -2624 +2456 @@
             return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
         }
-        // FIXME: This branch contributes to a 1% octane code-load regression.
-        // https://bugs.webkit.org/show_bug.cgi?id=158211
-        if (UNLIKELY(match(AWAIT)))
-            semanticFailIfTrue(isDisallowedIdentifierAwait(m_token), "Can't use 'await' as a label ", disallowedIdentifierAwaitReason());
         const Identifier* ident = m_token.m_data.ident;
         JSTextPosition end = tokenEndPosition();
@@ -2824 +2652 @@
         next();
 
-        failIfFalse(matchSpecIdentifier(), "Expected a variable name for the import declaration");
+        matchOrFail(IDENT, "Expected a variable name for the import declaration");
         localNameToken = m_token;
         localName = m_token.m_data.ident;
@@ -2846 +2674 @@
         if (matchContextualKeyword(m_vm->propertyNames->as)) {
             next();
-            failIfFalse(matchSpecIdentifier(), "Expected a variable name for the import declaration");
+            matchOrFail(IDENT, "Expected a variable name for the import declaration");
             localNameToken = m_token;
             localName = m_token.m_data.ident;
@@ -2857 +2685 @@
         // ImportedDefaultBinding :
         // ImportedBinding
-        ASSERT(matchSpecIdentifier());
+        ASSERT(match(IDENT));
         localNameToken = m_token;
         localName = m_token.m_data.ident;
@@ -2866 +2694 @@
     }
 
-    semanticFailIfTrue(localNameToken.m_type == AWAIT, "Cannot use 'await' as an imported binding name");
     semanticFailIfTrue(localNameToken.m_type & KeywordTokenFlag, "Cannot use keyword as imported binding name");
     DeclarationResultMask declarationResult = declareVariable(localName, DeclarationType::ConstDeclaration, (specifierType == ImportSpecifierType::NamespaceImport) ? DeclarationImportType::ImportedNamespace : DeclarationImportType::Imported);
@@ -2897 +2724 @@
 
     bool isFinishedParsingImport = false;
-    if (matchSpecIdentifier()) {
+    if (match(IDENT)) {
         // ImportedDefaultBinding :
         // ImportedBinding
@@ -3007 +2834 @@
         bool isFunctionOrClassDeclaration = false;
         const Identifier* localName = nullptr;
-        bool isAsyncFunctionExport = false;
         SavePoint savePoint = createSavePoint();
-
-        if (UNLIKELY(matchContextualKeyword(m_vm->propertyNames->async))) {
-            if (m_runtimeFlags.isAsyncAwaitEnabled()) {
-                next();
-                if (UNLIKELY(match(FUNCTION) && !m_lexer->prevTerminator()))
-                    isAsyncFunctionExport = true;
-                else
-                    restoreSavePoint(savePoint);
-            }
-        }
 
         bool startsWithFunction = match(FUNCTION);
@@ -3037 +2853 @@
                 DepthManager statementDepth(&m_statementDepth);
                 m_statementDepth = 1;
-                if (UNLIKELY(isAsyncFunctionExport)) {
-                    ASSERT(m_runtimeFlags.isAsyncAwaitEnabled());
-                    result = parseAsyncFunctionDeclaration(context);
-                } else
-                    result = parseFunctionDeclaration(context);
+                result = parseFunctionDeclaration(context);
             } else {
                 ASSERT(match(CLASSTOKEN));
@@ -3056 +2868 @@
             // 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");
 
@@ -3163 +2973 @@
 
         default:
-            if (UNLIKELY(matchContextualKeyword(m_vm->propertyNames->async))) {
-                if (m_runtimeFlags.isAsyncAwaitEnabled()) {
-                    next();
-                    semanticFailIfFalse(match(FUNCTION) && !m_lexer->prevTerminator(), "Expected 'function' keyword following 'async' keyword with no preceding line terminator");
-                    result = parseAsyncFunctionDeclaration(context, ExportType::Exported);
-                    break;
-                }
-            }
-
             failWithMessage("Expected either a declaration or a variable statement");
             break;
@@ -3236 +3037 @@
     
     failIfStackOverflow();
-
-    if (match(YIELD) && !isYIELDMaskedAsIDENT(currentScope()->isGenerator()))
-        return parseYieldExpression(context);
-
     JSTextPosition start = tokenStartPosition();
     JSTokenLocation location(tokenLocation());
@@ -3246 +3043 @@
     bool maybeAssignmentPattern = match(OPENBRACE) || match(OPENBRACKET);
     bool wasOpenParen = match(OPENPAREN);
-    // Do not use matchSpecIdentifier() here since it is slower than isIdentifierOrKeyword.
-    // Whether spec identifier is will be validated by isArrowFunctionParameters().
-    bool wasIdentifierOrKeyword = isIdentifierOrKeyword(m_token);
-    bool maybeValidArrowFunctionStart = wasOpenParen || wasIdentifierOrKeyword;
+    bool isValidArrowFunctionStart = match(OPENPAREN) || match(IDENT);
     SavePoint savePoint = createSavePoint();
     size_t usedVariablesSize = 0;
-
-    // FIXME: This branch contributes to a 1% octane code-load regression.
-    // https://bugs.webkit.org/show_bug.cgi?id=158211
-    if (wasOpenParen || (wasIdentifierOrKeyword && m_runtimeFlags.isAsyncAwaitEnabled() && UNLIKELY(*m_token.m_data.ident == m_vm->propertyNames->async))) {
+    if (wasOpenParen) {
         usedVariablesSize = currentScope()->currentUsedVariablesSize();
         currentScope()->pushUsedVariableSet();
     }
 
+    if (match(YIELD) && !isYIELDMaskedAsIDENT(currentScope()->isGenerator()))
+        return parseYieldExpression(context);
+
     TreeExpression lhs = parseConditionalExpression(context);
 
-    if (maybeValidArrowFunctionStart && !match(EOFTOK)) {
+    if (isValidArrowFunctionStart && !match(EOFTOK)) {
         bool isArrowFunctionToken = match(ARROWFUNCTION);
         if (!lhs || isArrowFunctionToken) {
             SavePointWithError errorRestorationSavePoint = createSavePointForError();
             restoreSavePoint(savePoint);
-            bool isAsyncArrow = false;
-            if (UNLIKELY(classifier.indicatesPossibleAsyncArrowFunction())) {
-                ASSERT(m_runtimeFlags.isAsyncAwaitEnabled());
-                ASSERT(matchContextualKeyword(m_vm->propertyNames->async));
-                next();
-                isAsyncArrow = !m_lexer->prevTerminator();
-            }
             if (isArrowFunctionParameters()) {
-                if (wasOpenParen || isAsyncArrow)
+                if (wasOpenParen)
                     currentScope()->revertToPreviousUsedVariables(usedVariablesSize);
-                return parseArrowFunctionExpression(context, isAsyncArrow);
+                return parseArrowFunctionExpression(context);
             }
             restoreSavePointWithError(errorRestorationSavePoint);
@@ -3396 +3183 @@
         return context.createYield(location);
     }
-    return context.createYield(location, argument, delegate, divotStart, argumentStart, lastTokenEndPosition());
-}
-
-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());
 }
@@ -3502 +3272 @@
     bool isGenerator = false;
     bool isClassProperty = false;
-    bool isAsyncMethod = false;
     if (consume(TIMES))
         isGenerator = true;
-
-parseProperty:
     switch (m_token.m_type) {
     namedProperty:
     case IDENT:
-    case AWAIT:
         wasIdent = true;
         FALLTHROUGH;
@@ -3516 +3282 @@
         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 || *ident == m_vm->propertyNames->async)))
+        if (complete || (wasIdent && !isGenerator && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set)))
             nextExpectIdentifier(LexerFlagsIgnoreReservedWords);
         else
             nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
 
-        if (!isGenerator && !isAsyncMethod && match(COLON)) {
+        if (!isGenerator && match(COLON)) {
             next();
             TreeExpression node = parseAssignmentExpressionOrPropagateErrorClass(context);
@@ -3530 +3296 @@
 
         if (match(OPENPAREN)) {
-            auto method = parsePropertyMethod(context, ident, isGenerator, isAsyncMethod);
+            auto method = parsePropertyMethod(context, ident, isGenerator);
             propagateError();
             return context.createProperty(ident, method, PropertyNode::Constant, PropertyNode::KnownDirect, complete, SuperBinding::Needed, isClassProperty);
         }
-
-        failIfTrue(isGenerator || isAsyncMethod, "Expected a parenthesis for argument list");
+        failIfTrue(isGenerator, "Expected a parenthesis for argument list");
 
         failIfFalse(wasIdent, "Expected an identifier as property name");
@@ -3557 +3322 @@
         else if (*ident == m_vm->propertyNames->set)
             type = PropertyNode::Setter;
-        else if (UNLIKELY(m_runtimeFlags.isAsyncAwaitEnabled() && !isGenerator && !isAsyncMethod && *ident == m_vm->propertyNames->async)) {
-            isAsyncMethod = true;
-            failIfTrue(m_lexer->prevTerminator(), "Expected a property name following keyword 'async'");
-            goto parseProperty;
-        } else
+        else
             failWithMessage("Expected a ':' following the property name '", ident->impl(), "'");
         return parseGetterSetter(context, complete, type, getterOrSetterStartOffset, ConstructorKind::None, isClassProperty);
@@ -3572 +3333 @@
         if (match(OPENPAREN)) {
             const Identifier& ident = m_parserArena.identifierArena().makeNumericIdentifier(const_cast<VM*>(m_vm), propertyName);
-            auto method = parsePropertyMethod(context, &ident, isGenerator, isAsyncMethod);
+            auto method = parsePropertyMethod(context, &ident, isGenerator);
             propagateError();
             return context.createProperty(&ident, method, PropertyNode::Constant, PropertyNode::Unknown, complete, SuperBinding::Needed, isClassProperty);
         }
-        failIfTrue(isGenerator || isAsyncMethod, "Expected a parenthesis for argument list");
+        failIfTrue(isGenerator, "Expected a parenthesis for argument list");
 
         consumeOrFail(COLON, "Expected ':' after property name");
@@ -3591 +3352 @@
 
         if (match(OPENPAREN)) {
-            auto method = parsePropertyMethod(context, &m_vm->propertyNames->nullIdentifier, isGenerator, isAsyncMethod);
+            auto method = parsePropertyMethod(context, &m_vm->propertyNames->nullIdentifier, isGenerator);
             propagateError();
             return context.createProperty(propertyName, method, static_cast<PropertyNode::Type>(PropertyNode::Constant | PropertyNode::Computed), PropertyNode::KnownDirect, complete, SuperBinding::Needed, isClassProperty);
         }
-        failIfTrue(isGenerator || isAsyncMethod, "Expected a parenthesis for argument list");
+        failIfTrue(isGenerator, "Expected a parenthesis for argument list");
 
         consumeOrFail(COLON, "Expected ':' after property name");
@@ -3610 +3371 @@
 
 template <typename LexerType>
-template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator, bool isAsync)
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator)
 {
     JSTokenLocation methodLocation(tokenLocation());
     unsigned methodStart = tokenStart();
     ParserFunctionInfo<TreeBuilder> methodInfo;
-    SourceParseMode parseMode = isGenerator ? SourceParseMode::GeneratorWrapperFunctionMode : isAsync ? SourceParseMode::AsyncMethodMode : SourceParseMode::MethodMode;
+    SourceParseMode parseMode = isGenerator ? SourceParseMode::GeneratorWrapperFunctionMode : SourceParseMode::MethodMode;
     failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, parseMode, false, ConstructorKind::None, SuperBinding::Needed, methodStart, methodInfo, FunctionDefinitionType::Method)), "Cannot parse this method");
     methodInfo.name = methodName;
@@ -3873 +3634 @@
 
 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)
 {
@@ -3976 +3723 @@
         return context.createThisExpr(location);
     }
-    case AWAIT:
     case IDENT: {
     identifierExpression:
@@ -3983 +3729 @@
         JSTokenLocation location(tokenLocation());
         next();
-        // FIXME: This branch contributes to a 1% octane code-load regression.
-        // https://bugs.webkit.org/show_bug.cgi?id=158211
-        if (UNLIKELY(match(FUNCTION) && !m_lexer->prevTerminator() && *ident == m_vm->propertyNames->async)) {
-            if (m_runtimeFlags.isAsyncAwaitEnabled())
-                return parseAsyncFunctionExpression(context);
-        }
+        if (UNLIKELY(match(ARROWFUNCTION)))
+            return 0;
         currentScope()->useVariable(ident, m_vm->propertyNames->eval == *ident);
         m_parserState.lastIdentifier = ident;
@@ -4164 +3906 @@
     }
 
-    bool baseIsAsyncKeyword = false;
     if (baseIsSuper) {
         ScopeRef closestOrdinaryFunctionScope = closestParentOrdinaryFunctionNonLexicalScope();
@@ -4182 +3923 @@
             }
         }
-    } else if (!baseIsNewTarget) {
-        // FIXME: This branch contributes to a 1% octane code-load regression.
-        // https://bugs.webkit.org/show_bug.cgi?id=158211
-        const bool isAsync = matchContextualKeyword(m_vm->propertyNames->async);
+    } else if (!baseIsNewTarget)
         base = parsePrimaryExpression(context);
-        failIfFalse(base, "Cannot parse base expression");
-        if (UNLIKELY(m_runtimeFlags.isAsyncAwaitEnabled() && isAsync && context.isResolve(base) && !m_lexer->prevTerminator())) {
-            if (matchSpecIdentifier()) {
-                // AsyncArrowFunction
-                forceClassifyExpressionError(ErrorIndicatesAsyncArrowFunction);
-                return 0;
-            }
-            baseIsAsyncKeyword = true;
-        }
-    }
 
     failIfFalse(base, "Cannot parse base expression");
-
     while (true) {
         location = tokenLocation();
@@ -4232 +3959 @@
                 JSTextPosition expressionEnd = lastTokenEndPosition();
                 TreeArguments arguments = parseArguments(context);
-                if (UNLIKELY(baseIsAsyncKeyword && (!arguments || match(ARROWFUNCTION))))
-                    forceClassifyExpressionError(ErrorIndicatesAsyncArrowFunction);
                 failIfFalse(arguments, "Cannot parse call arguments");
                 if (baseIsSuper) {
@@ -4292 +4017 @@
 
 template <typename LexerType>
-template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrowFunctionExpression(TreeBuilder& context, bool isAsync)
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrowFunctionExpression(TreeBuilder& context)
 {
     JSTokenLocation location;
@@ -4300 +4025 @@
     ParserFunctionInfo<TreeBuilder> info;
     info.name = &m_vm->propertyNames->nullIdentifier;
-    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");
+    failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SourceParseMode::ArrowFunctionMode, true, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, info, FunctionDefinitionType::Expression)), "Cannot parse arrow function expression");
 
     return context.createArrowFunctionExpr(location, info);
@@ -4346 +4069 @@
     bool requiresLExpr = false;
     unsigned lastOperator = 0;
-
-    // FIXME: This branch contributes to a 1% octane code-load regression.
-    // https://bugs.webkit.org/show_bug.cgi?id=158211
-    if (UNLIKELY(match(AWAIT))) {
-        if (m_runtimeFlags.isAsyncAwaitEnabled() && currentFunctionScope()->isAsyncFunction())
-            return parseAwaitExpression(context);
-    }
-
     while (isUnaryOp(m_token.m_type)) {
         if (strictMode()) {
@@ -4534 +4249 @@
         out.print("Invalid private name '", getToken(), "'");
         return;
-
+            
     case IDENT:
         out.print("Unexpected identifier '", getToken(), "'");

trunk/Source/JavaScriptCore/parser/Parser.h

@@ -34 +34 @@
 #include "ParserFunctionInfo.h"
 #include "ParserTokens.h"
-#include "RuntimeFlags.h"
 #include "SourceProvider.h"
 #include "SourceProviderCache.h"
@@ -155 +154 @@
 
 public:
-    Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode, bool isArrowFunction, bool isAsyncFunction)
+    Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode, bool isArrowFunction)
         : m_vm(vm)
         , m_shadowsArguments(false)
@@ -170 +169 @@
         , m_isArrowFunction(isArrowFunction)
         , m_isArrowFunctionBoundary(false)
-        , m_isAsyncFunction(isAsyncFunction)
-        , m_isAsyncFunctionBoundary(false)
         , m_isLexicalScope(false)
         , m_isFunctionBoundary(false)
@@ -259 +256 @@
     {
         switch (mode) {
-        case SourceParseMode::AsyncArrowFunctionBodyMode:
-            setIsAsyncArrowFunctionBody();
-            break;
-
-        case SourceParseMode::AsyncFunctionBodyMode:
-            setIsAsyncFunctionBody();
-            break;
-
         case SourceParseMode::GeneratorBodyMode:
             setIsGenerator();
@@ -286 +275 @@
             break;
 
-        case SourceParseMode::AsyncFunctionMode:
-        case SourceParseMode::AsyncMethodMode:
-            setIsAsyncFunction();
-            break;
-
-        case SourceParseMode::AsyncArrowFunctionMode:
-            setIsAsyncArrowFunction();
-            break;
-
         case SourceParseMode::ProgramMode:
             break;
@@ -309 +289 @@
     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; }
@@ -338 +316 @@
         ASSERT(m_moduleScopeData);
         return *m_moduleScopeData;
-    }
-
-    bool isModule() const
-    {
-        return !!m_moduleScopeData;
     }
 
@@ -727 +700 @@
         m_isArrowFunctionBoundary = false;
         m_isArrowFunction = false;
-        m_isAsyncFunctionBoundary = false;
-        m_isAsyncFunction = false;
     }
 
@@ -750 +721 @@
         m_isArrowFunctionBoundary = true;
         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;
     }
 
@@ -799 +742 @@
     bool m_isArrowFunction;
     bool m_isArrowFunctionBoundary;
-    bool m_isAsyncFunction;
-    bool m_isAsyncFunctionBoundary;
     bool m_isLexicalScope;
     bool m_isFunctionBoundary;
@@ -874 +815 @@
 
 public:
-    Parser(VM*, RuntimeFlags, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode, SuperBinding, ConstructorKind defaultConstructorKind = ConstructorKind::None, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None);
+    Parser(VM*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode, SuperBinding, ConstructorKind defaultConstructorKind = ConstructorKind::None, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None);
     ~Parser();
 
@@ -963 +904 @@
 
     enum ExpressionErrorClass {
-        ErrorIndicatesNothing = 0,
-        ErrorIndicatesPattern,
-        ErrorIndicatesAsyncArrowFunction
+        ErrorIndicatesNothing,
+        ErrorIndicatesPattern
     };
 
@@ -989 +929 @@
         }
 
-        void forceClassifyExpressionError(ExpressionErrorClass classification)
-        {
-            m_class = classification;
-        }
-
         void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
         {
@@ -1003 +938 @@
         void propagateExpressionErrorClass()
         {
-            if (m_previous)
+            if (m_previous && m_class != ErrorIndicatesNothing)
                 m_previous->m_class = m_class;
         }
 
         bool indicatesPossiblePattern() const { return m_class == ErrorIndicatesPattern; }
-        bool indicatesPossibleAsyncArrowFunction() const { return m_class == ErrorIndicatesAsyncArrowFunction; }
+
     private:
         ExpressionErrorClass m_class;
@@ -1019 +954 @@
         if (m_expressionErrorClassifier)
             m_expressionErrorClassifier->classifyExpressionError(classification);
-    }
-
-    ALWAYS_INLINE void forceClassifyExpressionError(ExpressionErrorClass classification)
-    {
-        if (m_expressionErrorClassifier)
-            m_expressionErrorClassifier->forceClassifyExpressionError(classification);
     }
 
@@ -1048 +977 @@
     }
 
-    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)
     {
@@ -1073 +989 @@
     ALWAYS_INLINE bool isEvalOrArguments(const Identifier* ident) { return isEvalOrArgumentsIdentifier(m_vm, ident); }
 
-    ScopeRef upperScope(unsigned n)
-    {
-        ASSERT(m_scopeStack.size() >= (1 + n));
-        return ScopeRef(&m_scopeStack, m_scopeStack.size() - 1 - n);
-    }
-
     ScopeRef currentScope()
     {
@@ -1123 +1033 @@
         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() || m_scopeStack[i].isAsyncFunctionBoundary()))
+        while (i && (!m_scopeStack[i].isFunctionBoundary() || m_scopeStack[i].isGeneratorBoundary() || m_scopeStack[i].isArrowFunctionBoundary()))
             i--;
         // When reaching the top level scope (it can be non ordinary function scope), we return it.
@@ -1135 +1045 @@
         bool isGenerator = false;
         bool isArrowFunction = false;
-        bool isAsyncFunction = false;
         if (!m_scopeStack.isEmpty()) {
             isStrict = m_scopeStack.last().strictMode();
@@ -1141 +1050 @@
             isGenerator = m_scopeStack.last().isGenerator();
             isArrowFunction = m_scopeStack.last().isArrowFunction();
-            isAsyncFunction = m_scopeStack.last().isAsyncFunction();
-        }
-        m_scopeStack.constructAndAppend(m_vm, isFunction, isGenerator, isStrict, isArrowFunction, isAsyncFunction);
+        }
+        m_scopeStack.constructAndAppend(m_vm, isFunction, isGenerator, isStrict, isArrowFunction);
         return currentScope();
     }
@@ -1155 +1063 @@
         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());
@@ -1452 +1360 @@
     ALWAYS_INLINE bool matchSpecIdentifier(bool inGenerator)
     {
-        return match(IDENT) || match(AWAIT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(inGenerator);
-    }
-
-    // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors
+        return match(IDENT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(inGenerator);
+    }
+
     ALWAYS_INLINE bool matchSpecIdentifier()
     {
-        return match(IDENT) || match(AWAIT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(currentScope()->isGenerator());
+        return matchSpecIdentifier(currentScope()->isGenerator());
     }
 
     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);
@@ -1469 +1375 @@
     template <class TreeBuilder> TreeStatement parseClassDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
     template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
-    template <class TreeBuilder> TreeStatement parseFunctionDeclarationStatement(TreeBuilder&, bool isAsync, bool parentAllowsFunctionDeclarationAsStatement);
-    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&);
@@ -1497 +1401 @@
     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&);
@@ -1504 +1407 @@
     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, bool isAsyncMethod);
+    template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator);
     template <class TreeBuilder> TreeProperty parseGetterSetter(TreeBuilder&, bool strict, PropertyNode::Type, unsigned getterOrSetterStartOffset, ConstructorKind, bool isClassProperty);
     template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, SyntaxChecker&, const JSTokenLocation&, int, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind, SuperBinding, FunctionBodyType, unsigned, SourceParseMode);
@@ -1515 +1417 @@
     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&, bool isAsync);
+    template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&);
     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&);
@@ -1573 +1475 @@
     }
 
-    bool isDisallowedIdentifierAwait(const JSToken& token)
-    {
-        return token.m_type == AWAIT && (!m_parserState.allowAwait || currentScope()->isAsyncFunctionBoundary() || currentScope()->isModule());
-    }
-
-    const char* disallowedIdentifierAwaitReason()
-    {
-        if (!m_parserState.allowAwait || currentScope()->isAsyncFunctionBoundary())
-            return "in an async function";
-        if (currentScope()->isModule())
-            return "in a module";
-        RELEASE_ASSERT_NOT_REACHED();
-        return nullptr;
-    }
-
     enum class FunctionParsePhase { Parameters, Body };
     struct ParserState {
@@ -1596 +1483 @@
         const Identifier* lastIdentifier { nullptr };
         const Identifier* lastFunctionName { nullptr };
-        bool allowAwait { true };
     };
 
@@ -1707 +1593 @@
     String m_errorMessage;
     JSToken m_token;
-    RuntimeFlags m_runtimeFlags;
     bool m_allowsIn;
     JSTextPosition m_lastTokenEndPosition;
@@ -1840 +1725 @@
 template <class ParsedNode>
 std::unique_ptr<ParsedNode> parse(
-    VM* vm, RuntimeFlags runtimeFlags, const SourceCode& source,
+    VM* vm, const SourceCode& source,
     const Identifier& name, JSParserBuiltinMode builtinMode,
     JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding,
@@ -1848 +1733 @@
     ASSERT(!source.provider()->source().isNull());
     if (source.provider()->source().is8Bit()) {
-        Parser<Lexer<LChar>> parser(vm, runtimeFlags, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
+        Parser<Lexer<LChar>> parser(vm, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
         std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
         if (positionBeforeLastNewline)
@@ -1859 +1744 @@
     }
     ASSERT_WITH_MESSAGE(defaultConstructorKind == ConstructorKind::None, "BuiltinExecutables::createDefaultConstructor should always use a 8-bit string");
-    Parser<Lexer<UChar>> parser(vm, runtimeFlags, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
+    Parser<Lexer<UChar>> parser(vm, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
     std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
     if (positionBeforeLastNewline)

trunk/Source/JavaScriptCore/parser/ParserModes.h

@@ -28 +28 @@
 #define ParserModes_h
 
-#include "ConstructAbility.h"
 #include "Identifier.h"
 
@@ -44 +43 @@
 enum class FunctionMode { FunctionExpression, FunctionDeclaration, MethodDefinition };
 
-// When you add a new source parse mode, do not forget to ensure that the predicates defined in this
-// file work with the newly added mode.
-enum class SourceParseMode : uint16_t {
-    NormalFunctionMode            = 0b0000000000000001,
-    GeneratorBodyMode             = 0b0000000000000010,
-    GeneratorWrapperFunctionMode  = 0b0000000000000100,
-    GetterMode                    = 0b0000000000001000,
-    SetterMode                    = 0b0000000000010000,
-    MethodMode                    = 0b0000000000100000,
-    ArrowFunctionMode             = 0b0000000001000000,
-    AsyncFunctionBodyMode         = 0b0000000010000000,
-    AsyncArrowFunctionBodyMode    = 0b0000000100000000,
-    AsyncFunctionMode             = 0b0000001000000000,
-    AsyncMethodMode               = 0b0000010000000000,
-    AsyncArrowFunctionMode        = 0b0000100000000000,
-    ProgramMode                   = 0b0001000000000000,
-    ModuleAnalyzeMode             = 0b0010000000000000,
-    ModuleEvaluateMode            = 0b0100000000000000,
+enum class SourceParseMode : uint8_t {
+    NormalFunctionMode,
+    GeneratorBodyMode,
+    GeneratorWrapperFunctionMode,
+    GetterMode,
+    SetterMode,
+    MethodMode,
+    ArrowFunctionMode,
+    ProgramMode,
+    ModuleAnalyzeMode,
+    ModuleEvaluateMode
 };
 
-class SourceParseModeSet {
-public:
-    template<typename... Modes>
-    SourceParseModeSet(Modes... args)
-        : m_mask(mergeSourceParseModes(args...))
-    {
+inline bool isFunctionParseMode(SourceParseMode parseMode)
+{
+    switch (parseMode) {
+    case SourceParseMode::NormalFunctionMode:
+    case SourceParseMode::GeneratorBodyMode:
+    case SourceParseMode::GeneratorWrapperFunctionMode:
+    case SourceParseMode::GetterMode:
+    case SourceParseMode::SetterMode:
+    case SourceParseMode::MethodMode:
+    case SourceParseMode::ArrowFunctionMode:
+        return true;
+
+    case SourceParseMode::ProgramMode:
+    case SourceParseMode::ModuleAnalyzeMode:
+    case SourceParseMode::ModuleEvaluateMode:
+        return false;
     }
-
-    ALWAYS_INLINE bool contains(SourceParseMode mode)
-    {
-        return static_cast<unsigned>(mode) & m_mask;
-    }
-
-private:
-    ALWAYS_INLINE static unsigned mergeSourceParseModes(SourceParseMode mode)
-    {
-        return static_cast<unsigned>(mode);
-    }
-
-    template<typename... Rest>
-    ALWAYS_INLINE static unsigned mergeSourceParseModes(SourceParseMode mode, Rest... rest)
-    {
-        return static_cast<unsigned>(mode) | mergeSourceParseModes(rest...);
-    }
-
-    const unsigned m_mask;
-};
-
-ALWAYS_INLINE bool isFunctionParseMode(SourceParseMode parseMode)
-{
-    return SourceParseModeSet(
-        SourceParseMode::NormalFunctionMode,
-        SourceParseMode::GeneratorBodyMode,
-        SourceParseMode::GeneratorWrapperFunctionMode,
-        SourceParseMode::GetterMode,
-        SourceParseMode::SetterMode,
-        SourceParseMode::MethodMode,
-        SourceParseMode::ArrowFunctionMode,
-        SourceParseMode::AsyncFunctionBodyMode,
-        SourceParseMode::AsyncFunctionMode,
-        SourceParseMode::AsyncMethodMode,
-        SourceParseMode::AsyncArrowFunctionMode,
-        SourceParseMode::AsyncArrowFunctionBodyMode).contains(parseMode);
+    RELEASE_ASSERT_NOT_REACHED();
+    return false;
 }
 
-ALWAYS_INLINE bool isAsyncFunctionParseMode(SourceParseMode parseMode)
+inline bool isModuleParseMode(SourceParseMode parseMode)
 {
-    return SourceParseModeSet(
-        SourceParseMode::AsyncFunctionBodyMode,
-        SourceParseMode::AsyncFunctionMode,
-        SourceParseMode::AsyncMethodMode,
-        SourceParseMode::AsyncArrowFunctionMode,
-        SourceParseMode::AsyncArrowFunctionBodyMode).contains(parseMode);
+    switch (parseMode) {
+    case SourceParseMode::ModuleAnalyzeMode:
+    case SourceParseMode::ModuleEvaluateMode:
+        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::ProgramMode:
+        return false;
+    }
+    RELEASE_ASSERT_NOT_REACHED();
+    return false;
 }
 
-ALWAYS_INLINE bool isAsyncArrowFunctionParseMode(SourceParseMode parseMode)
+inline bool isProgramParseMode(SourceParseMode parseMode)
 {
-    return SourceParseModeSet(
-        SourceParseMode::AsyncArrowFunctionMode,
-        SourceParseMode::AsyncArrowFunctionBodyMode).contains(parseMode);
-}
+    switch (parseMode) {
+    case SourceParseMode::ProgramMode:
+        return true;
 
-ALWAYS_INLINE bool isAsyncFunctionWrapperParseMode(SourceParseMode parseMode)
-{
-    return SourceParseModeSet(
-        SourceParseMode::AsyncArrowFunctionMode,
-        SourceParseMode::AsyncFunctionMode,
-        SourceParseMode::AsyncMethodMode).contains(parseMode);
-}
-
-ALWAYS_INLINE bool isAsyncFunctionBodyParseMode(SourceParseMode parseMode)
-{
-    return SourceParseModeSet(
-        SourceParseMode::AsyncFunctionBodyMode,
-        SourceParseMode::AsyncArrowFunctionBodyMode).contains(parseMode);
-}
-
-ALWAYS_INLINE bool isModuleParseMode(SourceParseMode parseMode)
-{
-    return SourceParseModeSet(
-        SourceParseMode::ModuleAnalyzeMode,
-        SourceParseMode::ModuleEvaluateMode).contains(parseMode);
-}
-
-ALWAYS_INLINE bool isProgramParseMode(SourceParseMode parseMode)
-{
-    return SourceParseModeSet(SourceParseMode::ProgramMode).contains(parseMode);
-}
-
-ALWAYS_INLINE ConstructAbility constructAbilityForParseMode(SourceParseMode parseMode)
-{
-    if (parseMode == SourceParseMode::NormalFunctionMode)
-        return ConstructAbility::CanConstruct;
-    return ConstructAbility::CannotConstruct;
+    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:
+        return false;
+    }
+    RELEASE_ASSERT_NOT_REACHED();
+    return false;
 }
 

trunk/Source/JavaScriptCore/parser/ParserTokens.h

@@ -83 +83 @@
     EXTENDS,
     SUPER,
-    AWAIT,
     OPENBRACE = 0,
     CLOSEBRACE,

trunk/Source/JavaScriptCore/parser/SourceCodeKey.h

@@ -29 +29 @@
 
 #include "ParserModes.h"
-#include "RuntimeFlags.h"
 #include "SourceCode.h"
 #include <wtf/HashTraits.h>
@@ -68 +67 @@
     }
 
-    SourceCodeKey(const SourceCode& sourceCode, const RuntimeFlags& runtimeFlags, const String& name, SourceCodeType codeType, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DerivedContextType derivedContextType, EvalContextType evalContextType, bool isArrowFunctionContext)
+    SourceCodeKey(const SourceCode& sourceCode, const String& name, SourceCodeType codeType, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DerivedContextType derivedContextType, EvalContextType evalContextType, bool isArrowFunctionContext)
         : m_sourceCode(sourceCode)
         , m_name(name)
         , m_flags(codeType, builtinMode, strictMode, derivedContextType, evalContextType, isArrowFunctionContext)
         , m_hash(sourceCode.hash())
-        , m_runtimeFlags(runtimeFlags)
     {
     }
@@ -94 +92 @@
     StringView string() const { return m_sourceCode.view(); }
 
-    const RuntimeFlags& runtimeFlags() const { return m_runtimeFlags; }
-
     bool operator==(const SourceCodeKey& other) const
     {
@@ -102 +98 @@
             && m_flags == other.m_flags
             && m_name == other.m_name
-            && string() == other.string()
-            && m_runtimeFlags == other.runtimeFlags();
+            && string() == other.string();
     }
 
@@ -122 +117 @@
     SourceCodeFlags m_flags;
     unsigned m_hash;
-    RuntimeFlags m_runtimeFlags;
 };
 

trunk/Source/JavaScriptCore/parser/SyntaxChecker.h

@@ -185 +185 @@
     ClassExpression createClassExpr(const JSTokenLocation&, const ParserClassInfo<SyntaxChecker>&, VariableEnvironment&, ExpressionType, ExpressionType, PropertyList, PropertyList) { return ClassExpr; }
     ExpressionType createFunctionExpr(const JSTokenLocation&, const ParserFunctionInfo<SyntaxChecker>&) { return FunctionExpr; }
-    ExpressionType createAsyncFunctionBody(const JSTokenLocation&, const ParserFunctionInfo<SyntaxChecker>&) { return FunctionExpr; }
     int createFunctionMetadata(const JSTokenLocation&, const JSTokenLocation&, int, int, bool, int, int, int, ConstructorKind, SuperBinding, unsigned, SourceParseMode, bool, InnerArrowFunctionCodeFeatures = NoInnerArrowFunctionFeatures) { return FunctionBodyResult; }
     ExpressionType createArrowFunctionExpr(const JSTokenLocation&, const ParserFunctionInfo<SyntaxChecker>&) { return FunctionExpr; }

trunk/Source/JavaScriptCore/runtime/CodeCache.cpp

@@ -82 +82 @@
 
 template <class UnlinkedCodeBlockType, class ExecutableType>
-UnlinkedCodeBlockType* CodeCache::getGlobalCodeBlock(VM& vm, const RuntimeFlags& runtimeFlags, ExecutableType* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
+UnlinkedCodeBlockType* CodeCache::getGlobalCodeBlock(VM& vm, ExecutableType* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
 {
     DerivedContextType derivedContextType = executable->derivedContextType();
     bool isArrowFunctionContext = executable->isArrowFunctionContext();
-    SourceCodeKey key(source, runtimeFlags, String(), CacheTypes<UnlinkedCodeBlockType>::codeType, builtinMode, strictMode, derivedContextType, evalContextType, isArrowFunctionContext);
+    SourceCodeKey key(source, String(), CacheTypes<UnlinkedCodeBlockType>::codeType, builtinMode, strictMode, derivedContextType, evalContextType, isArrowFunctionContext);
     SourceCodeValue* cache = m_sourceCode.findCacheAndUpdateAge(key);
     // FIXME: We should do something smart for TDZ instead of just disabling caching.
@@ -105 +105 @@
     typedef typename CacheTypes<UnlinkedCodeBlockType>::RootNode RootNode;
     std::unique_ptr<RootNode> rootNode = parse<RootNode>(
-        &vm, runtimeFlags, source, Identifier(), builtinMode, strictMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, derivedContextType, evalContextType);
+        &vm, source, Identifier(), builtinMode, strictMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, derivedContextType, evalContextType);
     if (!rootNode)
         return nullptr;
@@ -134 +134 @@
 }
 
-UnlinkedProgramCodeBlock* CodeCache::getProgramCodeBlock(VM& vm, const RuntimeFlags& runtimeFlags, ProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ParserError& error)
+UnlinkedProgramCodeBlock* CodeCache::getProgramCodeBlock(VM& vm, ProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ParserError& error)
 {
     VariableEnvironment emptyParentTDZVariables;
-    return getGlobalCodeBlock<UnlinkedProgramCodeBlock>(vm, runtimeFlags, executable, source, builtinMode, strictMode, debuggerMode, error, EvalContextType::None, &emptyParentTDZVariables);
-}
-
-UnlinkedEvalCodeBlock* CodeCache::getEvalCodeBlock(VM& vm, const RuntimeFlags& runtimeFlags, EvalExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
-{
-    return getGlobalCodeBlock<UnlinkedEvalCodeBlock>(vm, runtimeFlags, executable, source, builtinMode, strictMode, debuggerMode, error, evalContextType, variablesUnderTDZ);
-}
-
-UnlinkedModuleProgramCodeBlock* CodeCache::getModuleProgramCodeBlock(VM& vm, const RuntimeFlags& runtimeFlags, ModuleProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, DebuggerMode debuggerMode, ParserError& error)
+    return getGlobalCodeBlock<UnlinkedProgramCodeBlock>(vm, executable, source, builtinMode, strictMode, debuggerMode, error, EvalContextType::None, &emptyParentTDZVariables);
+}
+
+UnlinkedEvalCodeBlock* CodeCache::getEvalCodeBlock(VM& vm, EvalExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ParserError& error, EvalContextType evalContextType, const VariableEnvironment* variablesUnderTDZ)
+{
+    return getGlobalCodeBlock<UnlinkedEvalCodeBlock>(vm, executable, source, builtinMode, strictMode, debuggerMode, error, evalContextType, variablesUnderTDZ);
+}
+
+UnlinkedModuleProgramCodeBlock* CodeCache::getModuleProgramCodeBlock(VM& vm, ModuleProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, DebuggerMode debuggerMode, ParserError& error)
 {
     VariableEnvironment emptyParentTDZVariables;
-    return getGlobalCodeBlock<UnlinkedModuleProgramCodeBlock>(vm, runtimeFlags, executable, source, builtinMode, JSParserStrictMode::Strict, debuggerMode, error, EvalContextType::None, &emptyParentTDZVariables);
+    return getGlobalCodeBlock<UnlinkedModuleProgramCodeBlock>(vm, executable, source, builtinMode, JSParserStrictMode::Strict, debuggerMode, 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 RuntimeFlags& runtimeFlags, const Identifier& name, const SourceCode& source, ParserError& error)
+UnlinkedFunctionExecutable* CodeCache::getFunctionExecutableFromGlobalCode(VM& vm, const Identifier& name, const SourceCode& source, ParserError& error)
 {
     bool isArrowFunctionContext = false;
     SourceCodeKey key(
-        source, runtimeFlags, name.string(), SourceCodeType::FunctionType,
+        source, name.string(), SourceCodeType::FunctionType,
         JSParserBuiltinMode::NotBuiltin,
         JSParserStrictMode::NotStrict,
@@ -172 +172 @@
     JSTextPosition positionBeforeLastNewline;
     std::unique_ptr<ProgramNode> program = parse<ProgramNode>(
-        &vm, runtimeFlags, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
+        &vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded,
         error, &positionBeforeLastNewline);
@@ -202 +202 @@
     // The Function constructor only has access to global variables, so no variables will be under TDZ.
     VariableEnvironment emptyTDZVariables;
-
-    ConstructAbility constructAbility = constructAbilityForParseMode(metadata->parseMode());
-    UnlinkedFunctionExecutable* functionExecutable = UnlinkedFunctionExecutable::create(&vm, source, metadata, UnlinkedNormalFunction, constructAbility, emptyTDZVariables, DerivedContextType::None);
+    UnlinkedFunctionExecutable* functionExecutable = UnlinkedFunctionExecutable::create(&vm, source, metadata, UnlinkedNormalFunction, ConstructAbility::CanConstruct, emptyTDZVariables, DerivedContextType::None);
 
     functionExecutable->setSourceURLDirective(source.provider()->sourceURL());

trunk/Source/JavaScriptCore/runtime/CodeCache.h

@@ -50 +50 @@
 class UnlinkedProgramCodeBlock;
 class VM;
-class RuntimeFlags;
 class VariableEnvironment;
 
@@ -189 +188 @@
     ~CodeCache();
 
-    UnlinkedProgramCodeBlock* getProgramCodeBlock(VM&, const RuntimeFlags&, ProgramExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ParserError&);
-    UnlinkedEvalCodeBlock* getEvalCodeBlock(VM&, const RuntimeFlags&, EvalExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ParserError&, EvalContextType, const VariableEnvironment*);
-    UnlinkedModuleProgramCodeBlock* getModuleProgramCodeBlock(VM&, const RuntimeFlags&, ModuleProgramExecutable*, const SourceCode&, JSParserBuiltinMode, DebuggerMode, ParserError&);
-    UnlinkedFunctionExecutable* getFunctionExecutableFromGlobalCode(VM&, const RuntimeFlags&, const Identifier&, const SourceCode&, ParserError&);
+    UnlinkedProgramCodeBlock* getProgramCodeBlock(VM&, ProgramExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ParserError&);
+    UnlinkedEvalCodeBlock* getEvalCodeBlock(VM&, EvalExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ParserError&, EvalContextType, const VariableEnvironment*);
+    UnlinkedModuleProgramCodeBlock* getModuleProgramCodeBlock(VM&, ModuleProgramExecutable*, const SourceCode&, JSParserBuiltinMode, DebuggerMode, ParserError&);
+    UnlinkedFunctionExecutable* getFunctionExecutableFromGlobalCode(VM&, const Identifier&, const SourceCode&, ParserError&);
 
     void clear()
@@ -201 +200 @@
 private:
     template <class UnlinkedCodeBlockType, class ExecutableType> 
-    UnlinkedCodeBlockType* getGlobalCodeBlock(VM&, const RuntimeFlags&, ExecutableType*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ParserError&, EvalContextType, const VariableEnvironment*);
+    UnlinkedCodeBlockType* getGlobalCodeBlock(VM&, ExecutableType*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ParserError&, EvalContextType, const VariableEnvironment*);
 
     CodeCacheMap m_sourceCode;

trunk/Source/JavaScriptCore/runtime/CommonIdentifiers.h

@@ -107 +107 @@
     macro(as) \
     macro(assign) \
-    macro(async) \
     macro(back) \
     macro(bind) \
@@ -268 +267 @@
 
 #define JSC_COMMON_IDENTIFIERS_EACH_KEYWORD(macro) \
-    macro(await) \
     macro(break) \
     macro(case) \

trunk/Source/JavaScriptCore/runtime/Completion.cpp

@@ -40 +40 @@
 #include "ModuleLoaderObject.h"
 #include "Parser.h"
-#include "RuntimeFlags.h"
 #include "ScriptProfilingScope.h"
 #include <wtf/WTFThreadData.h>
@@ -62 +61 @@
 }
     
-bool checkSyntax(VM& vm, const RuntimeFlags& runtimeFlags, const SourceCode& source, ParserError& error)
+bool checkSyntax(VM& vm, const SourceCode& source, ParserError& error)
 {
     JSLockHolder lock(vm);
     RELEASE_ASSERT(vm.atomicStringTable() == wtfThreadData().atomicStringTable());
     return !!parse<ProgramNode>(
-        &vm, runtimeFlags, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
+        &vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded, error);
 }
@@ -77 +76 @@
     RELEASE_ASSERT(vm.atomicStringTable() == wtfThreadData().atomicStringTable());
     std::unique_ptr<ModuleProgramNode> moduleProgramNode = parse<ModuleProgramNode>(
-        &vm, exec->lexicalGlobalObject()->runtimeFlags(), source, Identifier(), JSParserBuiltinMode::NotBuiltin,
+        &vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
         JSParserStrictMode::Strict, SourceParseMode::ModuleAnalyzeMode, SuperBinding::NotNeeded, error);
     if (!moduleProgramNode)

trunk/Source/JavaScriptCore/runtime/Completion.h

@@ -34 +34 @@
 class JSObject;
 class ParserError;
-class RuntimeFlags;
 class SourceCode;
 class VM;
 class JSInternalPromise;
 
-JS_EXPORT_PRIVATE bool checkSyntax(VM&, const RuntimeFlags&, const SourceCode&, ParserError&);
+JS_EXPORT_PRIVATE bool checkSyntax(VM&, const SourceCode&, ParserError&);
 JS_EXPORT_PRIVATE bool checkSyntax(ExecState*, const SourceCode&, JSValue* exception = 0);
 JS_EXPORT_PRIVATE bool checkModuleSyntax(ExecState*, const SourceCode&, ParserError&);

trunk/Source/JavaScriptCore/runtime/Executable.cpp

@@ -315 +315 @@
     UnlinkedFunctionCodeBlock* unlinkedCodeBlock = 
         executable->m_unlinkedExecutable->unlinkedCodeBlockFor(
-            *vm, globalObject->runtimeFlags(), executable->m_source, kind, debuggerMode, error, 
+            *vm, executable->m_source, kind, debuggerMode, error, 
             executable->parseMode());
     recordParse(
@@ -570 +570 @@
     JSGlobalObject* lexicalGlobalObject = exec->lexicalGlobalObject();
     std::unique_ptr<ProgramNode> programNode = parse<ProgramNode>(
-        vm, lexicalGlobalObject->runtimeFlags(), m_source, Identifier(), JSParserBuiltinMode::NotBuiltin, 
+        vm, m_source, Identifier(), JSParserBuiltinMode::NotBuiltin, 
         JSParserStrictMode::NotStrict, SourceParseMode::ProgramMode, SuperBinding::NotNeeded, error);
     if (programNode)

trunk/Source/JavaScriptCore/runtime/Executable.h

@@ -653 +653 @@
     bool isClass() const { return !classSource().isNull(); }
     bool isArrowFunction() const { return parseMode() == SourceParseMode::ArrowFunctionMode; }
-    bool isAsyncFunction() const { return isAsyncFunctionParseMode(parseMode()); }
     bool isGetter() const { return parseMode() == SourceParseMode::GetterMode; }
     bool isSetter() const { return parseMode() == SourceParseMode::SetterMode; }

trunk/Source/JavaScriptCore/runtime/FunctionConstructor.cpp

@@ -96 +96 @@
     String program;
     if (args.isEmpty())
-        program = makeString("{", functionConstructionMode == FunctionConstructionMode::Async ? "async function " : "function ", functionConstructionMode == FunctionConstructionMode::Generator ? "*" : "", functionName.string(), "() {\n\n}}");
+        program = makeString("{function ", functionConstructionMode == FunctionConstructionMode::Generator ? "*" : "", functionName.string(), "() {\n\n}}");
     else if (args.size() == 1)
-        program = makeString("{", functionConstructionMode == FunctionConstructionMode::Async ? "async function " : "function ", functionConstructionMode == FunctionConstructionMode::Generator ? "*" : "", functionName.string(), "() {\n", args.at(0).toString(exec)->value(exec), "\n}}");
+        program = makeString("{function ", functionConstructionMode == FunctionConstructionMode::Generator ? "*" : "", functionName.string(), "() {\n", args.at(0).toString(exec)->value(exec), "\n}}");
     else {
         StringBuilder builder;
-        if (functionConstructionMode == FunctionConstructionMode::Async)
-            builder.appendLiteral("{async function ");
-        else {
-            builder.appendLiteral("{function ");
-            if (functionConstructionMode == FunctionConstructionMode::Generator)
-                builder.append('*');
-        }
+        builder.appendLiteral("{function ");
+        if (functionConstructionMode == FunctionConstructionMode::Generator)
+            builder.append('*');
         builder.append(functionName.string());
         builder.append('(');

trunk/Source/JavaScriptCore/runtime/FunctionConstructor.h

@@ -60 +60 @@
     Function,
     Generator,
-    Async
 };
 

trunk/Source/JavaScriptCore/runtime/JSFunction.cpp

@@ -352 +352 @@
         return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
 
-    if (propertyName == exec->propertyNames().prototype && !thisObject->jsExecutable()->isArrowFunction() && !thisObject->jsExecutable()->isAsyncFunction()) {
+    if (propertyName == exec->propertyNames().prototype && !thisObject->jsExecutable()->isArrowFunction()) {
         VM& vm = exec->vm();
         unsigned attributes;

trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp

@@ -34 +34 @@
 #include "ArrayIteratorPrototype.h"
 #include "ArrayPrototype.h"
-#include "AsyncFunctionConstructor.h"
-#include "AsyncFunctionPrototype.h"
 #include "BooleanConstructor.h"
 #include "BooleanPrototype.h"
@@ -67 +65 @@
 #include "JSArrayBufferPrototype.h"
 #include "JSArrayIterator.h"
-#include "JSAsyncFunction.h"
 #include "JSBoundFunction.h"
 #include "JSBoundSlotBaseFunction.h"
@@ -616 +613 @@
         });
 
-    m_asyncFunctionPrototype.set(vm, this, AsyncFunctionPrototype::create(vm, AsyncFunctionPrototype::createStructure(vm, this, m_functionPrototype.get())));
-    AsyncFunctionConstructor* asyncFunctionConstructor = AsyncFunctionConstructor::create(vm, AsyncFunctionConstructor::createStructure(vm, this, functionConstructor), m_asyncFunctionPrototype.get());
-    m_asyncFunctionPrototype->putDirectWithoutTransition(vm, vm.propertyNames->constructor, asyncFunctionConstructor, DontEnum | ReadOnly);
-    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());
@@ -773 +765 @@
         GlobalPropertyInfo(vm.propertyNames->builtinNames().thisTimeValuePrivateName(), privateFuncThisTimeValue, DontEnum | DontDelete | ReadOnly),
         GlobalPropertyInfo(vm.propertyNames->builtinNames().thisNumberValuePrivateName(), privateFuncThisNumberValue, 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),
@@ -1227 +1217 @@
     DebuggerMode debuggerMode = hasInteractiveDebugger() ? DebuggerOn : DebuggerOff;
     UnlinkedProgramCodeBlock* unlinkedCodeBlock = vm().codeCache()->getProgramCodeBlock(
-        vm(), runtimeFlags(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode, 
+        vm(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode, 
         debuggerMode, error);
 
@@ -1249 +1239 @@
     
     UnlinkedEvalCodeBlock* unlinkedCodeBlock = vm().codeCache()->getEvalCodeBlock(
-        vm(), runtimeFlags(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode, debuggerMode, error, evalContextType, variablesUnderTDZ);
+        vm(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode, debuggerMode, error, evalContextType, variablesUnderTDZ);
 
     if (hasDebugger())
@@ -1267 +1257 @@
     DebuggerMode debuggerMode = hasInteractiveDebugger() ? DebuggerOn : DebuggerOff;
     UnlinkedModuleProgramCodeBlock* unlinkedCodeBlock = vm().codeCache()->getModuleProgramCodeBlock(
-        vm(), runtimeFlags(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, debuggerMode, error);
+        vm(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, debuggerMode, error);
 
     if (hasDebugger())

trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h

@@ -57 +57 @@
 
 class ArrayPrototype;
-class AsyncFunctionPrototype;
 class BooleanPrototype;
 class ConsoleClient;
@@ -258 +257 @@
     WriteBarrier<FunctionPrototype> m_functionPrototype;
     WriteBarrier<ArrayPrototype> m_arrayPrototype;
-    WriteBarrier<AsyncFunctionPrototype> m_asyncFunctionPrototype;
     WriteBarrier<RegExpPrototype> m_regExpPrototype;
     WriteBarrier<IteratorPrototype> m_iteratorPrototype;
@@ -300 +298 @@
     WriteBarrier<Structure> m_privateNameStructure;
     WriteBarrier<Structure> m_regExpStructure;
-    WriteBarrier<Structure> m_asyncFunctionStructure;
     WriteBarrier<Structure> m_generatorFunctionStructure;
     WriteBarrier<Structure> m_dollarVMStructure;
@@ -505 +502 @@
     FunctionPrototype* functionPrototype() const { return m_functionPrototype.get(); }
     ArrayPrototype* arrayPrototype() const { return m_arrayPrototype.get(); }
-    AsyncFunctionPrototype* asyncFunctionPrototype() const { return m_asyncFunctionPrototype.get(); }
     JSObject* booleanPrototype() const { return m_booleanObjectStructure.prototype(this); }
     StringPrototype* stringPrototype() const { return m_stringPrototype.get(); }
@@ -574 +570 @@
     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(this); }

trunk/Source/JavaScriptCore/runtime/ModuleLoaderObject.cpp

@@ -276 +276 @@
     ParserError error;
     std::unique_ptr<ModuleProgramNode> moduleProgramNode = parse<ModuleProgramNode>(
-        &vm, exec->vmEntryGlobalObject()->runtimeFlags(), sourceCode, Identifier(), JSParserBuiltinMode::NotBuiltin,
+        &vm, sourceCode, Identifier(), JSParserBuiltinMode::NotBuiltin,
         JSParserStrictMode::Strict, SourceParseMode::ModuleAnalyzeMode, SuperBinding::NotNeeded, error);
 

trunk/Source/JavaScriptCore/runtime/RuntimeFlags.h

@@ -31 +31 @@
 namespace JSC {
 
-// macro(name, flagName, isEnabledFlag)
-#define JSC_RUNTIME_FLAG(macro) \
-    macro(AsyncAwaitEnabled, true)
+// macro(name, isEnabledFlag)
+#define JSC_RUNTIME_FLAG(macro)
 
 class RuntimeFlags {
@@ -92 +91 @@
     }
 
-    bool operator==(const RuntimeFlags& other) const
-    {
-        return m_flags == other.m_flags;
-    }
-
-    bool operator!=(const RuntimeFlags& other) const
-    {
-        return m_flags != other.m_flags;
-    }
-
 private:
     unsigned m_flags;

trunk/Source/WebKit/mac/ChangeLog

@@ +1 @@
+2016-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        Unreviewed, roll out r201481, r201523: 0.3% regression in Octane code-load
+        https://bugs.webkit.org/show_bug.cgi?id=158249
+
+        * WebView/WebPreferencesPrivate.h:
+
 2016-05-27  Chris Dumez  <cdumez@apple.com>
 

trunk/Source/WebKit/mac/WebView/WebPreferencesPrivate.h

@@ -54 +54 @@
 
 typedef enum {
-    WebKitJavaScriptRuntimeFlagsAsyncAwaitEnabled = 1u << 0,
     WebKitJavaScriptRuntimeFlagsAllEnabled = 0
 } WebKitJavaScriptRuntimeFlags;

trunk/Source/WebKit/win/ChangeLog

@@ +1 @@
+2016-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        Unreviewed, roll out r201481, r201523: 0.3% regression in Octane code-load
+        https://bugs.webkit.org/show_bug.cgi?id=158249
+
+        * Interfaces/IWebPreferencesPrivate.idl:
+
 2016-05-27  Caitlin Potter  <caitp@igalia.com>
 

trunk/Source/WebKit/win/Interfaces/IWebPreferencesPrivate.idl

@@ -33 +33 @@
 
 typedef enum WebKitJavaScriptRuntimeFlags {
-    WebKitJavaScriptRuntimeFlagsAsyncAwaitEnabled = 1, // 1u << 0
     WebKitJavaScriptRuntimeFlagsAllEnabled = 0
 } WebKitJavaScriptRuntimeFlags;

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2016-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
+
+        Unreviewed, roll out r201481, r201523: 0.3% regression in Octane code-load
+        https://bugs.webkit.org/show_bug.cgi?id=158249
+
+        * UIProcess/API/C/WKPreferencesRefPrivate.h:
+        * UIProcess/API/Cocoa/WKPreferencesPrivate.h:
+
 2016-05-31  Beth Dakin  <bdakin@apple.com>
 

trunk/Source/WebKit2/UIProcess/API/C/WKPreferencesRefPrivate.h

@@ -51 +51 @@
 
 enum WKJavaScriptRuntimeFlags {
-    kWKJavaScriptRuntimeFlagsAsyncAwaitEnabled = 1 << 0,
     kWKJavaScriptRuntimeFlagsAllEnabled = 0
 };

trunk/Source/WebKit2/UIProcess/API/Cocoa/WKPreferencesPrivate.h

@@ -44 +44 @@
 
 typedef NS_OPTIONS(NSUInteger, _WKJavaScriptRuntimeFlags) {
-    _WKJavaScriptRuntimeFlagsAsyncAwaitEnabled = 1 << 0,
     _WKJavaScriptRuntimeFlagsAllEnabled = 0
 } WK_ENUM_AVAILABLE(10_11, 9_0);