test262: test262/test/language/global-code/new.target-arrow.js
[WebKit-https.git] / Source / JavaScriptCore / parser / Parser.cpp
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2006-2010, 2013, 2016 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #include "config.h"
24 #include "Parser.h"
25
26 #include "ASTBuilder.h"
27 #include "DebuggerParseData.h"
28 #include "JSCInlines.h"
29 #include "VM.h"
30 #include <utility>
31 #include <wtf/SetForScope.h>
32 #include <wtf/StringPrintStream.h>
33
34 #define updateErrorMessage(shouldPrintToken, ...) do {\
35     propagateError(); \
36     logError(shouldPrintToken, __VA_ARGS__); \
37 } while (0)
38
39 #define propagateError() do { if (UNLIKELY(hasError())) return 0; } while (0)
40 #define internalFailWithMessage(shouldPrintToken, ...) do { updateErrorMessage(shouldPrintToken, __VA_ARGS__); return 0; } while (0)
41 #define handleErrorToken() do { if (m_token.m_type == EOFTOK || m_token.m_type & ErrorTokenFlag) { failDueToUnexpectedToken(); } } while (0)
42 #define failWithMessage(...) do { { handleErrorToken(); updateErrorMessage(true, __VA_ARGS__); } return 0; } while (0)
43 #define failWithStackOverflow() do { updateErrorMessage(false, "Stack exhausted"); m_hasStackOverflow = true; return 0; } while (0)
44 #define failIfFalse(cond, ...) do { if (!(cond)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
45 #define failIfTrue(cond, ...) do { if (cond) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
46 #define failIfTrueIfStrict(cond, ...) do { if ((cond) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)
47 #define failIfFalseIfStrict(cond, ...) do { if ((!(cond)) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)
48 #define consumeOrFail(tokenType, ...) do { if (!consume(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
49 #define consumeOrFailWithFlags(tokenType, flags, ...) do { if (!consume(tokenType, flags)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
50 #define matchOrFail(tokenType, ...) do { if (!match(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
51 #define failIfStackOverflow() do { if (UNLIKELY(!canRecurse())) failWithStackOverflow(); } while (0)
52 #define semanticFail(...) do { internalFailWithMessage(false, __VA_ARGS__); } while (0)
53 #define semanticFailIfTrue(cond, ...) do { if (cond) internalFailWithMessage(false, __VA_ARGS__); } while (0)
54 #define semanticFailIfFalse(cond, ...) do { if (!(cond)) internalFailWithMessage(false, __VA_ARGS__); } while (0)
55 #define regexFail(failure) do { setErrorMessage(failure); return 0; } while (0)
56 #define failDueToUnexpectedToken() do {\
57         logError(true);\
58     return 0;\
59 } while (0)
60
61 #define handleProductionOrFail(token, tokenString, operation, production) do {\
62     consumeOrFail(token, "Expected '", tokenString, "' to ", operation, " a ", production);\
63 } while (0)
64
65 #define handleProductionOrFail2(token, tokenString, operation, production) do {\
66     consumeOrFail(token, "Expected '", tokenString, "' to ", operation, " an ", production);\
67 } while (0)
68
69 #define semanticFailureDueToKeyword(...) do { \
70     if (strictMode() && m_token.m_type == RESERVED_IF_STRICT) \
71         semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__, " in strict mode"); \
72     if (m_token.m_type == RESERVED || m_token.m_type == RESERVED_IF_STRICT) \
73         semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__); \
74     if (m_token.m_type & KeywordTokenFlag) \
75         semanticFail("Cannot use the keyword '", getToken(), "' as a ", __VA_ARGS__); \
76     if (isDisallowedIdentifierAwait(m_token)) \
77         semanticFail("Can't use 'await' as a ", __VA_ARGS__, " ", disallowedIdentifierAwaitReason()); \
78 } while (0)
79
80 using namespace std;
81
82 namespace JSC {
83
84 template <typename LexerType>
85 void Parser<LexerType>::logError(bool)
86 {
87     if (hasError())
88         return;
89     StringPrintStream stream;
90     printUnexpectedTokenText(stream);
91     setErrorMessage(stream.toStringWithLatin1Fallback());
92 }
93
94 template <typename LexerType> template <typename... Args>
95 void Parser<LexerType>::logError(bool shouldPrintToken, Args&&... args)
96 {
97     if (hasError())
98         return;
99     StringPrintStream stream;
100     if (shouldPrintToken) {
101         printUnexpectedTokenText(stream);
102         stream.print(". ");
103     }
104     stream.print(std::forward<Args>(args)..., ".");
105     setErrorMessage(stream.toStringWithLatin1Fallback());
106 }
107
108 template <typename LexerType>
109 Parser<LexerType>::Parser(VM* vm, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, SourceParseMode parseMode, SuperBinding superBinding, ConstructorKind defaultConstructorKind, DerivedContextType derivedContextType, bool isEvalContext, EvalContextType evalContextType, DebuggerParseData* debuggerParseData)
110     : m_vm(vm)
111     , m_source(&source)
112     , m_hasStackOverflow(false)
113     , m_allowsIn(true)
114     , m_syntaxAlreadyValidated(source.provider()->isValid())
115     , m_statementDepth(0)
116     , m_sourceElements(0)
117     , m_parsingBuiltin(builtinMode == JSParserBuiltinMode::Builtin)
118     , m_scriptMode(scriptMode)
119     , m_superBinding(superBinding)
120     , m_defaultConstructorKind(defaultConstructorKind)
121     , m_immediateParentAllowsFunctionDeclarationInStatement(false)
122     , m_debuggerParseData(debuggerParseData)
123 {
124     m_lexer = std::make_unique<LexerType>(vm, builtinMode, scriptMode);
125     m_lexer->setCode(source, &m_parserArena);
126     m_token.m_location.line = source.firstLine().oneBasedInt();
127     m_token.m_location.startOffset = source.startOffset();
128     m_token.m_location.endOffset = source.startOffset();
129     m_token.m_location.lineStartOffset = source.startOffset();
130     m_functionCache = vm->addSourceProviderCache(source.provider());
131     m_expressionErrorClassifier = nullptr;
132
133     ScopeRef scope = pushScope();
134     scope->setSourceParseMode(parseMode);
135     scope->setIsEvalContext(isEvalContext);
136     if (isEvalContext)
137         scope->setEvalContextType(evalContextType);
138     
139     if (derivedContextType == DerivedContextType::DerivedConstructorContext) {
140         scope->setConstructorKind(ConstructorKind::Extends);
141         scope->setExpectedSuperBinding(SuperBinding::Needed);
142     }
143     
144     if (derivedContextType == DerivedContextType::DerivedMethodContext)
145         scope->setExpectedSuperBinding(SuperBinding::Needed);
146
147     if (strictMode == JSParserStrictMode::Strict)
148         scope->setStrictMode();
149
150     if (isModuleParseMode(parseMode))
151         m_moduleScopeData = ModuleScopeData::create();
152
153     if (isProgramOrModuleParseMode(parseMode))
154         scope->setIsGlobalCodeScope();
155
156     next();
157 }
158
159 class Scope::MaybeParseAsGeneratorForScope : public SetForScope<bool> {
160 public:
161     MaybeParseAsGeneratorForScope(ScopeRef& scope, bool shouldParseAsGenerator)
162         : SetForScope<bool>(scope->m_isGenerator, shouldParseAsGenerator) { }
163 };
164
165 template <typename LexerType>
166 Parser<LexerType>::~Parser()
167 {
168 }
169
170 template <typename LexerType>
171 String Parser<LexerType>::parseInner(const Identifier& calleeName, SourceParseMode parseMode)
172 {
173     String parseError = String();
174
175     ASTBuilder context(const_cast<VM*>(m_vm), m_parserArena, const_cast<SourceCode*>(m_source));
176     ScopeRef scope = currentScope();
177     scope->setIsLexicalScope();
178     SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Body);
179
180     bool isArrowFunctionBodyExpression = parseMode == SourceParseMode::AsyncArrowFunctionBodyMode && !match(OPENBRACE);
181     if (m_lexer->isReparsingFunction()) {
182         ParserFunctionInfo<ASTBuilder> functionInfo;
183         if (isGeneratorOrAsyncFunctionBodyParseMode(parseMode))
184             m_parameters = createGeneratorParameters(context, functionInfo.parameterCount);
185         else
186             m_parameters = parseFunctionParameters(context, parseMode, functionInfo);
187
188         if (SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(parseMode) && !hasError()) {
189             // The only way we could have an error wile reparsing is if we run out of stack space.
190             RELEASE_ASSERT(match(ARROWFUNCTION));
191             next();
192             isArrowFunctionBodyExpression = !match(OPENBRACE);
193         }
194     }
195
196     if (!calleeName.isNull())
197         scope->declareCallee(&calleeName);
198
199     if (m_lexer->isReparsingFunction())
200         m_statementDepth--;
201
202     SourceElements* sourceElements = nullptr;
203     // The only way we can error this early is if we reparse a function and we run out of stack space.
204     if (!hasError()) {
205         if (isAsyncFunctionWrapperParseMode(parseMode))
206             sourceElements = parseAsyncFunctionSourceElements(context, parseMode, isArrowFunctionBodyExpression, CheckForStrictMode);
207         else if (isArrowFunctionBodyExpression)
208             sourceElements = parseArrowFunctionSingleExpressionBodySourceElements(context);
209         else if (isModuleParseMode(parseMode))
210             sourceElements = parseModuleSourceElements(context, parseMode);
211         else if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode)
212             sourceElements = parseGeneratorFunctionSourceElements(context, calleeName, CheckForStrictMode);
213         else
214             sourceElements = parseSourceElements(context, CheckForStrictMode);
215     }
216
217     bool validEnding = consume(EOFTOK);
218     if (!sourceElements || !validEnding) {
219         if (hasError())
220             parseError = m_errorMessage;
221         else
222             parseError = ASCIILiteral("Parser error");
223     }
224
225     IdentifierSet capturedVariables;
226     UniquedStringImplPtrSet sloppyModeHoistedFunctions;
227     scope->getSloppyModeHoistedFunctions(sloppyModeHoistedFunctions);
228     scope->getCapturedVars(capturedVariables);
229
230     VariableEnvironment& varDeclarations = scope->declaredVariables();
231     for (auto& entry : capturedVariables)
232         varDeclarations.markVariableAsCaptured(entry);
233
234     if (SourceParseModeSet(SourceParseMode::GeneratorWrapperFunctionMode).contains(parseMode) || isAsyncFunctionWrapperParseMode(parseMode)) {
235         if (scope->usedVariablesContains(m_vm->propertyNames->arguments.impl()))
236             context.propagateArgumentsUse();
237     }
238
239     CodeFeatures features = context.features();
240     if (scope->strictMode())
241         features |= StrictModeFeature;
242     if (scope->shadowsArguments())
243         features |= ShadowsArgumentsFeature;
244
245 #ifndef NDEBUG
246     if (m_parsingBuiltin && isProgramParseMode(parseMode)) {
247         VariableEnvironment& lexicalVariables = scope->lexicalVariables();
248         const HashSet<UniquedStringImpl*>& closedVariableCandidates = scope->closedVariableCandidates();
249         for (UniquedStringImpl* candidate : closedVariableCandidates) {
250             if (!lexicalVariables.contains(candidate) && !varDeclarations.contains(candidate) && !candidate->isSymbol()) {
251                 dataLog("Bad global capture in builtin: '", candidate, "'\n");
252                 dataLog(m_source->view());
253                 CRASH();
254             }
255         }
256     }
257 #endif // NDEBUG
258     didFinishParsing(sourceElements, scope->takeFunctionDeclarations(), varDeclarations, WTFMove(sloppyModeHoistedFunctions), features, context.numConstants());
259
260     return parseError;
261 }
262
263 template <typename LexerType>
264 void Parser<LexerType>::didFinishParsing(SourceElements* sourceElements, DeclarationStacks::FunctionStack&& funcStack, 
265     VariableEnvironment& varDeclarations, UniquedStringImplPtrSet&& sloppyModeHoistedFunctions, CodeFeatures features, int numConstants)
266 {
267     m_sourceElements = sourceElements;
268     m_funcDeclarations = WTFMove(funcStack);
269     m_varDeclarations.swap(varDeclarations);
270     m_features = features;
271     m_sloppyModeHoistedFunctions = WTFMove(sloppyModeHoistedFunctions);
272     m_numConstants = numConstants;
273 }
274
275 template <typename LexerType>
276 bool Parser<LexerType>::isArrowFunctionParameters()
277 {
278     if (match(OPENPAREN)) {
279         SavePoint saveArrowFunctionPoint = createSavePoint();
280         next();
281         bool isArrowFunction = false;
282         if (match(CLOSEPAREN)) {
283             next();
284             isArrowFunction = match(ARROWFUNCTION);
285         } else {
286             SyntaxChecker syntaxChecker(const_cast<VM*>(m_vm), m_lexer.get());
287             // We make fake scope, otherwise parseFormalParameters will add variable to current scope that lead to errors
288             AutoPopScopeRef fakeScope(this, pushScope());
289             fakeScope->setSourceParseMode(SourceParseMode::ArrowFunctionMode);
290
291             unsigned parametersCount = 0;
292             bool isArrowFunctionParameterList = true;
293             isArrowFunction = parseFormalParameters(syntaxChecker, syntaxChecker.createFormalParameterList(), isArrowFunctionParameterList, parametersCount) && consume(CLOSEPAREN) && match(ARROWFUNCTION);
294             propagateError();
295             popScope(fakeScope, syntaxChecker.NeedsFreeVariableInfo);
296         }
297         restoreSavePoint(saveArrowFunctionPoint);
298         return isArrowFunction;
299     }
300
301     if (matchSpecIdentifier()) {
302         SavePoint saveArrowFunctionPoint = createSavePoint();
303         next();
304         bool isArrowFunction = match(ARROWFUNCTION);
305         restoreSavePoint(saveArrowFunctionPoint);
306         return isArrowFunction;
307     }
308
309     return false;
310 }
311
312 template <typename LexerType>
313 bool Parser<LexerType>::allowAutomaticSemicolon()
314 {
315     return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator();
316 }
317
318 template <typename LexerType>
319 template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceElements(TreeBuilder& context, SourceElementsMode mode)
320 {
321     const unsigned lengthOfUseStrictLiteral = 12; // "use strict".length
322     TreeSourceElements sourceElements = context.createSourceElements();
323     const Identifier* directive = 0;
324     unsigned directiveLiteralLength = 0;
325     auto savePoint = createSavePoint();
326     bool shouldCheckForUseStrict = mode == CheckForStrictMode;
327     
328     while (TreeStatement statement = parseStatementListItem(context, directive, &directiveLiteralLength)) {
329         if (shouldCheckForUseStrict) {
330             if (directive) {
331                 // "use strict" must be the exact literal without escape sequences or line continuation.
332                 if (directiveLiteralLength == lengthOfUseStrictLiteral && m_vm->propertyNames->useStrictIdentifier == *directive) {
333                     setStrictMode();
334                     shouldCheckForUseStrict = false; // We saw "use strict", there is no need to keep checking for it.
335                     if (!isValidStrictMode()) {
336                         if (m_parserState.lastFunctionName) {
337                             if (m_vm->propertyNames->arguments == *m_parserState.lastFunctionName)
338                                 semanticFail("Cannot name a function 'arguments' in strict mode");
339                             if (m_vm->propertyNames->eval == *m_parserState.lastFunctionName)
340                                 semanticFail("Cannot name a function 'eval' in strict mode");
341                         }
342                         if (hasDeclaredVariable(m_vm->propertyNames->arguments))
343                             semanticFail("Cannot declare a variable named 'arguments' in strict mode");
344                         if (hasDeclaredVariable(m_vm->propertyNames->eval))
345                             semanticFail("Cannot declare a variable named 'eval' in strict mode");
346                         semanticFailIfTrue(currentScope()->hasNonSimpleParameterList(), "'use strict' directive not allowed inside a function with a non-simple parameter list");
347                         semanticFailIfFalse(isValidStrictMode(), "Invalid parameters or function name in strict mode");
348                     }
349                     // Since strict mode is changed, restoring lexer state by calling next() may cause errors.
350                     restoreSavePoint(savePoint);
351                     propagateError();
352                     continue;
353                 }
354
355                 // We saw a directive, but it wasn't "use strict". We reset our state to
356                 // see if the next statement we parse is also a directive.
357                 directive = nullptr;
358             } else {
359                 // We saw a statement that wasn't in the form of a directive. The spec says that "use strict"
360                 // is only allowed as the first statement, or after a sequence of directives before it, but
361                 // not after non-directive statements.
362                 shouldCheckForUseStrict = false;
363             }
364         }
365         context.appendStatement(sourceElements, statement);
366     }
367
368     propagateError();
369     return sourceElements;
370 }
371
372 template <typename LexerType>
373 template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseModuleSourceElements(TreeBuilder& context, SourceParseMode parseMode)
374 {
375     TreeSourceElements sourceElements = context.createSourceElements();
376     SyntaxChecker syntaxChecker(const_cast<VM*>(m_vm), m_lexer.get());
377
378     while (true) {
379         TreeStatement statement = 0;
380         switch (m_token.m_type) {
381         case EXPORT:
382             statement = parseExportDeclaration(context);
383             if (statement)
384                 recordPauseLocation(context.breakpointLocation(statement));
385             break;
386
387         case IMPORT: {
388             SavePoint savePoint = createSavePoint();
389             next();
390             bool isImportDeclaration = !match(OPENPAREN);
391             restoreSavePoint(savePoint);
392             if (isImportDeclaration) {
393                 statement = parseImportDeclaration(context);
394                 if (statement)
395                     recordPauseLocation(context.breakpointLocation(statement));
396                 break;
397             }
398
399             // This is `import("...")` call case.
400             FALLTHROUGH;
401         }
402
403         default: {
404             const Identifier* directive = 0;
405             unsigned directiveLiteralLength = 0;
406             if (parseMode == SourceParseMode::ModuleAnalyzeMode) {
407                 if (!parseStatementListItem(syntaxChecker, directive, &directiveLiteralLength))
408                     goto end;
409                 continue;
410             }
411             statement = parseStatementListItem(context, directive, &directiveLiteralLength);
412             break;
413         }
414         }
415
416         if (!statement)
417             goto end;
418         context.appendStatement(sourceElements, statement);
419     }
420
421 end:
422     propagateError();
423
424     for (const auto& pair : m_moduleScopeData->exportedBindings()) {
425         const auto& uid = pair.key;
426         if (currentScope()->hasDeclaredVariable(uid)) {
427             currentScope()->declaredVariables().markVariableAsExported(uid);
428             continue;
429         }
430
431         if (currentScope()->hasLexicallyDeclaredVariable(uid)) {
432             currentScope()->lexicalVariables().markVariableAsExported(uid);
433             continue;
434         }
435
436         semanticFail("Exported binding '", uid.get(), "' needs to refer to a top-level declared variable");
437     }
438
439     return sourceElements;
440 }
441
442 template <typename LexerType>
443 template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseGeneratorFunctionSourceElements(TreeBuilder& context, const Identifier& name, SourceElementsMode mode)
444 {
445     auto sourceElements = context.createSourceElements();
446
447     unsigned functionKeywordStart = tokenStart();
448     JSTokenLocation startLocation(tokenLocation());
449     JSTextPosition start = tokenStartPosition();
450     unsigned startColumn = tokenColumn();
451     int functionNameStart = m_token.m_location.startOffset;
452     int parametersStart = m_token.m_location.startOffset;
453
454     ParserFunctionInfo<TreeBuilder> info;
455     info.name = &m_vm->propertyNames->nullIdentifier;
456     createGeneratorParameters(context, info.parameterCount);
457     info.startOffset = parametersStart;
458     info.startLine = tokenLine();
459
460     {
461         AutoPopScopeRef generatorBodyScope(this, pushScope());
462         generatorBodyScope->setSourceParseMode(SourceParseMode::GeneratorBodyMode);
463         generatorBodyScope->setConstructorKind(ConstructorKind::None);
464         generatorBodyScope->setExpectedSuperBinding(m_superBinding);
465
466         SyntaxChecker generatorFunctionContext(const_cast<VM*>(m_vm), m_lexer.get());
467         failIfFalse(parseSourceElements(generatorFunctionContext, mode), "Cannot parse the body of a generator");
468         popScope(generatorBodyScope, TreeBuilder::NeedsFreeVariableInfo);
469     }
470     info.body = context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, tokenColumn(), functionKeywordStart, functionNameStart, parametersStart, strictMode(), ConstructorKind::None, m_superBinding, info.parameterCount, SourceParseMode::GeneratorBodyMode, false);
471
472     info.endLine = tokenLine();
473     info.endOffset = m_token.m_data.offset;
474     info.parametersStartColumn = startColumn;
475
476     auto functionExpr = context.createGeneratorFunctionBody(startLocation, info, name);
477     auto statement = context.createExprStatement(startLocation, functionExpr, start, m_lastTokenEndPosition.line);
478     context.appendStatement(sourceElements, statement);
479
480     return sourceElements;
481 }
482
483 template <typename LexerType>
484 template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseAsyncFunctionSourceElements(TreeBuilder& context, SourceParseMode parseMode, bool isArrowFunctionBodyExpression, SourceElementsMode mode)
485 {
486     ASSERT(isAsyncFunctionWrapperParseMode(parseMode));
487     auto sourceElements = context.createSourceElements();
488
489     unsigned functionKeywordStart = tokenStart();
490     JSTokenLocation startLocation(tokenLocation());
491     JSTextPosition start = tokenStartPosition();
492     unsigned startColumn = tokenColumn();
493     int functionNameStart = m_token.m_location.startOffset;
494     int parametersStart = m_token.m_location.startOffset;
495
496     ParserFunctionInfo<TreeBuilder> info;
497     info.name = &m_vm->propertyNames->nullIdentifier;
498     createGeneratorParameters(context, info.parameterCount);
499     info.startOffset = parametersStart;
500     info.startLine = tokenLine();
501     SourceParseMode innerParseMode = parseMode == SourceParseMode::AsyncArrowFunctionMode
502         ? SourceParseMode::AsyncArrowFunctionBodyMode
503         : SourceParseMode::AsyncFunctionBodyMode;
504     {
505         AutoPopScopeRef asyncFunctionBodyScope(this, pushScope());
506         asyncFunctionBodyScope->setSourceParseMode(innerParseMode);
507         SyntaxChecker syntaxChecker(const_cast<VM*>(m_vm), m_lexer.get());
508         if (isArrowFunctionBodyExpression) {
509             if (m_debuggerParseData)
510                 failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(context), "Cannot parse the body of async arrow function");
511             else
512                 failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(syntaxChecker), "Cannot parse the body of async arrow function");
513         } else {
514             if (m_debuggerParseData)
515                 failIfFalse(parseSourceElements(context, mode), "Cannot parse the body of async function");
516             else
517                 failIfFalse(parseSourceElements(syntaxChecker, mode), "Cannot parse the body of async function");
518         }
519         popScope(asyncFunctionBodyScope, TreeBuilder::NeedsFreeVariableInfo);
520     }
521     info.body = context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, tokenColumn(), functionKeywordStart, functionNameStart, parametersStart, strictMode(), ConstructorKind::None, m_superBinding, info.parameterCount, innerParseMode, isArrowFunctionBodyExpression);
522
523     info.endLine = tokenLine();
524     info.endOffset = isArrowFunctionBodyExpression ? tokenLocation().endOffset : m_token.m_data.offset;
525     info.parametersStartColumn = startColumn;
526
527     auto functionExpr = context.createAsyncFunctionBody(startLocation, info, innerParseMode);
528     auto statement = context.createExprStatement(startLocation, functionExpr, start, m_lastTokenEndPosition.line);
529     context.appendStatement(sourceElements, statement);
530
531     return sourceElements;
532 }
533
534 template <typename LexerType>
535 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatementListItem(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength)
536 {
537     // The grammar is documented here:
538     // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-statements
539     DepthManager statementDepth(&m_statementDepth);
540     m_statementDepth++;
541     TreeStatement result = 0;
542     bool shouldSetEndOffset = true;
543     bool shouldSetPauseLocation = false;
544
545     switch (m_token.m_type) {
546     case CONSTTOKEN:
547         result = parseVariableDeclaration(context, DeclarationType::ConstDeclaration);
548         shouldSetPauseLocation = true;
549         break;
550     case LET: {
551         bool shouldParseVariableDeclaration = true;
552         if (!strictMode()) {
553             SavePoint savePoint = createSavePoint();
554             next();
555             // Intentionally use `isIdentifierOrAnyContextualKeyword(m_token)` and don't use `matchSpecIdentifier()`.
556             // We would like to fall into parseVariableDeclaration path even if "yield" is not treated as an Identifier.
557             // For example, under a generator context, matchSpecIdentifier() for "yield" returns `false`.
558             // But we would like to enter parseVariableDeclaration and raise an error under the context of parseVariableDeclaration
559             // to raise consistent errors between "var", "const" and "let".
560             if (!isIdentifierOrAnyContextualKeyword(m_token) && !match(OPENBRACE) && !match(OPENBRACKET))
561                 shouldParseVariableDeclaration = false;
562             restoreSavePoint(savePoint);
563         }
564         if (shouldParseVariableDeclaration)
565             result = parseVariableDeclaration(context, DeclarationType::LetDeclaration);
566         else {
567             bool allowFunctionDeclarationAsStatement = true;
568             result = parseExpressionOrLabelStatement(context, allowFunctionDeclarationAsStatement);
569         }
570         shouldSetPauseLocation = !context.shouldSkipPauseLocation(result);
571         break;
572     }
573     case CLASSTOKEN:
574         result = parseClassDeclaration(context);
575         break;
576     case FUNCTION:
577         result = parseFunctionDeclaration(context);
578         break;
579     case ASYNC: {
580         // Eagerly parse as AsyncFunctionDeclaration. This is the uncommon case,
581         // but could be mistakenly parsed as an AsyncFunctionExpression.
582         SavePoint savePoint = createSavePoint();
583         next();
584         if (UNLIKELY(match(FUNCTION) && !m_lexer->prevTerminator())) {
585             result = parseAsyncFunctionDeclaration(context);
586             break;
587         }
588         restoreSavePoint(savePoint);
589         FALLTHROUGH;
590     }
591     case IDENT:
592     case AWAIT:
593     case YIELD: {
594         // This is a convenient place to notice labeled statements
595         // (even though we also parse them as normal statements)
596         // because we allow the following type of code in sloppy mode:
597         // ``` function foo() { label: function bar() { } } ```
598         bool allowFunctionDeclarationAsStatement = true;
599         result = parseExpressionOrLabelStatement(context, allowFunctionDeclarationAsStatement);
600         shouldSetPauseLocation = !context.shouldSkipPauseLocation(result);
601         break;
602     }
603     default:
604         m_statementDepth--; // parseStatement() increments the depth.
605         result = parseStatement(context, directive, directiveLiteralLength);
606         shouldSetEndOffset = false;
607         break;
608     }
609
610     if (result) {
611         if (shouldSetEndOffset)
612             context.setEndOffset(result, m_lastTokenEndPosition.offset);
613         if (shouldSetPauseLocation)
614             recordPauseLocation(context.breakpointLocation(result));
615     }
616
617     return result;
618 }
619
620 template <typename LexerType>
621 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVariableDeclaration(TreeBuilder& context, DeclarationType declarationType, ExportType exportType)
622 {
623     ASSERT(match(VAR) || match(LET) || match(CONSTTOKEN));
624     JSTokenLocation location(tokenLocation());
625     int start = tokenLine();
626     int end = 0;
627     int scratch;
628     TreeDestructuringPattern scratch1 = 0;
629     TreeExpression scratch2 = 0;
630     JSTextPosition scratch3;
631     bool scratchBool;
632     TreeExpression variableDecls = parseVariableDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3, VarDeclarationContext, declarationType, exportType, scratchBool);
633     propagateError();
634     failIfFalse(autoSemiColon(), "Expected ';' after variable declaration");
635     
636     return context.createDeclarationStatement(location, variableDecls, start, end);
637 }
638
639 template <typename LexerType>
640 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDoWhileStatement(TreeBuilder& context)
641 {
642     ASSERT(match(DO));
643     int startLine = tokenLine();
644     next();
645     const Identifier* unused = 0;
646     startLoop();
647     TreeStatement statement = parseStatement(context, unused);
648     endLoop();
649     failIfFalse(statement, "Expected a statement following 'do'");
650     int endLine = tokenLine();
651     JSTokenLocation location(tokenLocation());
652     handleProductionOrFail(WHILE, "while", "end", "do-while loop");
653     handleProductionOrFail(OPENPAREN, "(", "start", "do-while loop condition");
654     semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a do-while loop condition");
655     TreeExpression expr = parseExpression(context);
656     failIfFalse(expr, "Unable to parse do-while loop condition");
657     recordPauseLocation(context.breakpointLocation(expr));
658     handleProductionOrFail(CLOSEPAREN, ")", "end", "do-while loop condition");
659     if (match(SEMICOLON))
660         next(); // Always performs automatic semicolon insertion.
661     return context.createDoWhileStatement(location, statement, expr, startLine, endLine);
662 }
663
664 template <typename LexerType>
665 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWhileStatement(TreeBuilder& context)
666 {
667     ASSERT(match(WHILE));
668     JSTokenLocation location(tokenLocation());
669     int startLine = tokenLine();
670     next();
671     
672     handleProductionOrFail(OPENPAREN, "(", "start", "while loop condition");
673     semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a while loop condition");
674     TreeExpression expr = parseExpression(context);
675     failIfFalse(expr, "Unable to parse while loop condition");
676     recordPauseLocation(context.breakpointLocation(expr));
677     int endLine = tokenLine();
678     handleProductionOrFail(CLOSEPAREN, ")", "end", "while loop condition");
679
680     const Identifier* unused = 0;
681     startLoop();
682     TreeStatement statement = parseStatement(context, unused);
683     endLoop();
684     failIfFalse(statement, "Expected a statement as the body of a while loop");
685     return context.createWhileStatement(location, expr, statement, startLine, endLine);
686 }
687
688 template <typename LexerType>
689 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVariableDeclarationList(TreeBuilder& context, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext declarationListContext, DeclarationType declarationType, ExportType exportType, bool& forLoopConstDoesNotHaveInitializer)
690 {
691     ASSERT(declarationType == DeclarationType::LetDeclaration || declarationType == DeclarationType::VarDeclaration || declarationType == DeclarationType::ConstDeclaration);
692     TreeExpression head = 0;
693     TreeExpression tail = 0;
694     const Identifier* lastIdent;
695     JSToken lastIdentToken; 
696     AssignmentContext assignmentContext = assignmentContextFromDeclarationType(declarationType);
697     do {
698         lastIdent = 0;
699         lastPattern = TreeDestructuringPattern(0);
700         JSTokenLocation location(tokenLocation());
701         next();
702         TreeExpression node = 0;
703         declarations++;
704         bool hasInitializer = false;
705         if (matchSpecIdentifier()) {
706             failIfTrue(match(LET) && (declarationType == DeclarationType::LetDeclaration || declarationType == DeclarationType::ConstDeclaration), 
707                 "Can't use 'let' as an identifier name for a LexicalDeclaration");
708             semanticFailIfTrue(isDisallowedIdentifierAwait(m_token), "Can't use 'await' as a ", declarationTypeToVariableKind(declarationType), " ", disallowedIdentifierAwaitReason());
709             JSTextPosition varStart = tokenStartPosition();
710             JSTokenLocation varStartLocation(tokenLocation());
711             identStart = varStart;
712             const Identifier* name = m_token.m_data.ident;
713             lastIdent = name;
714             lastIdentToken = m_token;
715             next();
716             hasInitializer = match(EQUAL);
717             DeclarationResultMask declarationResult = declareVariable(name, declarationType);
718             if (declarationResult != DeclarationResult::Valid) {
719                 failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare a variable named ", name->impl(), " in strict mode");
720                 if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) {
721                     if (declarationType == DeclarationType::LetDeclaration) 
722                         internalFailWithMessage(false, "Cannot declare a let variable twice: '", name->impl(), "'");
723                     if (declarationType == DeclarationType::ConstDeclaration)
724                         internalFailWithMessage(false, "Cannot declare a const variable twice: '", name->impl(), "'");
725                     ASSERT(declarationType == DeclarationType::VarDeclaration);
726                     internalFailWithMessage(false, "Cannot declare a var variable that shadows a let/const/class variable: '", name->impl(), "'");
727                 }
728             }
729             if (exportType == ExportType::Exported) {
730                 semanticFailIfFalse(exportName(*name), "Cannot export a duplicate name '", name->impl(), "'");
731                 m_moduleScopeData->exportBinding(*name);
732             }
733
734             if (hasInitializer) {
735                 JSTextPosition varDivot = tokenStartPosition() + 1;
736                 initStart = tokenStartPosition();
737                 next(TreeBuilder::DontBuildStrings); // consume '='
738                 propagateError();
739                 TreeExpression initializer = parseAssignmentExpression(context);
740                 initEnd = lastTokenEndPosition();
741                 lastInitializer = initializer;
742                 failIfFalse(initializer, "Expected expression as the intializer for the variable '", name->impl(), "'");
743                 
744                 node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEndPosition(), assignmentContext);
745             } else {
746                 if (declarationListContext == ForLoopContext && declarationType == DeclarationType::ConstDeclaration)
747                     forLoopConstDoesNotHaveInitializer = true;
748                 failIfTrue(declarationListContext != ForLoopContext && declarationType == DeclarationType::ConstDeclaration, "const declared variable '", name->impl(), "'", " must have an initializer");
749                 if (declarationType == DeclarationType::VarDeclaration)
750                     node = context.createEmptyVarExpression(varStartLocation, *name);
751                 else
752                     node = context.createEmptyLetExpression(varStartLocation, *name);
753             }
754         } else {
755             lastIdent = 0;
756             auto pattern = parseDestructuringPattern(context, destructuringKindFromDeclarationType(declarationType), exportType, nullptr, nullptr, assignmentContext);
757             failIfFalse(pattern, "Cannot parse this destructuring pattern");
758             hasInitializer = match(EQUAL);
759             failIfTrue(declarationListContext == VarDeclarationContext && !hasInitializer, "Expected an initializer in destructuring variable declaration");
760             lastPattern = pattern;
761             if (hasInitializer) {
762                 next(TreeBuilder::DontBuildStrings); // consume '='
763                 TreeExpression rhs = parseAssignmentExpression(context);
764                 propagateError();
765                 ASSERT(rhs);
766                 node = context.createDestructuringAssignment(location, pattern, rhs);
767                 lastInitializer = rhs;
768             }
769         }
770
771         if (node) {
772             if (!head)
773                 head = node;
774             else if (!tail) {
775                 head = context.createCommaExpr(location, head);
776                 tail = context.appendToCommaExpr(location, head, head, node);
777             } else
778                 tail = context.appendToCommaExpr(location, head, tail, node);
779         }
780     } while (match(COMMA));
781     if (lastIdent)
782         lastPattern = context.createBindingLocation(lastIdentToken.m_location, *lastIdent, lastIdentToken.m_startPosition, lastIdentToken.m_endPosition, assignmentContext);
783
784     return head;
785 }
786
787 template <typename LexerType>
788 bool Parser<LexerType>::declareRestOrNormalParameter(const Identifier& name, const Identifier** duplicateIdentifier)
789 {
790     DeclarationResultMask declarationResult = declareParameter(&name);
791     if ((declarationResult & DeclarationResult::InvalidStrictMode) && strictMode()) {
792         semanticFailIfTrue(isEvalOrArguments(&name), "Cannot destructure to a parameter name '", name.impl(), "' in strict mode");
793         if (m_parserState.lastFunctionName && name == *m_parserState.lastFunctionName)
794             semanticFail("Cannot declare a parameter named '", name.impl(), "' as it shadows the name of a strict mode function");
795         semanticFailureDueToKeyword("parameter name");
796         if (!m_lexer->isReparsingFunction() && hasDeclaredParameter(name))
797             semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode as it has already been declared");
798         semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode");
799     }
800     if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) {
801         // It's not always an error to define a duplicate parameter.
802         // It's only an error when there are default parameter values or destructuring parameters.
803         // We note this value now so we can check it later.
804         if (duplicateIdentifier)
805             *duplicateIdentifier = &name;
806     }
807
808     return true;
809 }
810
811 template <typename LexerType>
812 template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier& name, JSToken token, AssignmentContext bindingContext, const Identifier** duplicateIdentifier)
813 {
814     ASSERT(!name.isNull());
815     
816     ASSERT(name.impl()->isAtomic() || name.impl()->isSymbol());
817
818     switch (kind) {
819     case DestructuringKind::DestructureToVariables: {
820         DeclarationResultMask declarationResult = declareVariable(&name);
821         failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare a variable named '", name.impl(), "' in strict mode");
822         if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration)
823             internalFailWithMessage(false, "Cannot declare a var variable that shadows a let/const/class variable: '", name.impl(), "'");
824         break;
825     }
826
827     case DestructuringKind::DestructureToLet:
828     case DestructuringKind::DestructureToConst:
829     case DestructuringKind::DestructureToCatchParameters: {
830         DeclarationResultMask declarationResult = declareVariable(&name, kind == DestructuringKind::DestructureToConst ? DeclarationType::ConstDeclaration : DeclarationType::LetDeclaration);
831         if (declarationResult != DeclarationResult::Valid) {
832             failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot destructure to a variable named '", name.impl(), "' in strict mode");
833             failIfTrue(declarationResult & DeclarationResult::InvalidDuplicateDeclaration, "Cannot declare a lexical variable twice: '", name.impl(), "'");
834         }
835         break;
836     }
837
838     case DestructuringKind::DestructureToParameters: {
839         declareRestOrNormalParameter(name, duplicateIdentifier);
840         propagateError();
841         break;
842     }
843
844     case DestructuringKind::DestructureToExpressions: {
845         break;
846     }
847     }
848
849     if (exportType == ExportType::Exported) {
850         semanticFailIfFalse(exportName(name), "Cannot export a duplicate name '", name.impl(), "'");
851         m_moduleScopeData->exportBinding(name);
852     }
853     return context.createBindingLocation(token.m_location, name, token.m_startPosition, token.m_endPosition, bindingContext);
854 }
855
856 template <typename LexerType>
857 template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern Parser<LexerType>::createAssignmentElement(TreeBuilder& context, TreeExpression& assignmentTarget, const JSTextPosition& startPosition, const JSTextPosition& endPosition)
858 {
859     return context.createAssignmentElement(assignmentTarget, startPosition, endPosition);
860 }
861
862 template <typename LexerType>
863 template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseArrowFunctionSingleExpressionBodySourceElements(TreeBuilder& context)
864 {
865     ASSERT(!match(OPENBRACE));
866
867     JSTokenLocation location(tokenLocation());
868     JSTextPosition start = tokenStartPosition();
869
870     failIfStackOverflow();
871     TreeExpression expr = parseAssignmentExpression(context);
872     failIfFalse(expr, "Cannot parse the arrow function expression");
873     
874     context.setEndOffset(expr, m_lastTokenEndPosition.offset);
875
876     JSTextPosition end = tokenEndPosition();
877     
878     TreeSourceElements sourceElements = context.createSourceElements();
879     TreeStatement body = context.createReturnStatement(location, expr, start, end);
880     context.setEndOffset(body, m_lastTokenEndPosition.offset);
881     recordPauseLocation(context.breakpointLocation(body));
882     context.appendStatement(sourceElements, body);
883
884     return sourceElements;
885 }
886
887 template <typename LexerType>
888 template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::tryParseDestructuringPatternExpression(TreeBuilder& context, AssignmentContext bindingContext)
889 {
890     return parseDestructuringPattern(context, DestructuringKind::DestructureToExpressions, ExportType::NotExported, nullptr, nullptr, bindingContext);
891 }
892
893 template <typename LexerType>
894 template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseBindingOrAssignmentElement(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth)
895 {
896     if (kind == DestructuringKind::DestructureToExpressions)
897         return parseAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth);
898     return parseDestructuringPattern(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth);
899 }
900
901 template <typename LexerType>
902 template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseAssignmentElement(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth)
903 {
904     TreeDestructuringPattern assignmentTarget = 0;
905
906     if (match(OPENBRACE) || match(OPENBRACKET)) {
907         SavePoint savePoint = createSavePoint();
908         assignmentTarget = parseDestructuringPattern(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth);
909         if (assignmentTarget && !match(DOT) && !match(OPENBRACKET) && !match(OPENPAREN) && !match(BACKQUOTE))
910             return assignmentTarget;
911         restoreSavePoint(savePoint);
912     }
913
914     JSTextPosition startPosition = tokenStartPosition();
915     auto element = parseMemberExpression(context);
916
917     semanticFailIfFalse(element && context.isAssignmentLocation(element), "Invalid destructuring assignment target");
918
919     if (strictMode() && m_parserState.lastIdentifier && context.isResolve(element)) {
920         bool isEvalOrArguments = m_vm->propertyNames->eval == *m_parserState.lastIdentifier || m_vm->propertyNames->arguments == *m_parserState.lastIdentifier;
921         failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", m_parserState.lastIdentifier->impl(), "' in strict mode");
922     }
923
924     return createAssignmentElement(context, element, startPosition, lastTokenEndPosition());
925 }
926
927 static const char* destructuringKindToVariableKindName(DestructuringKind kind)
928 {
929     switch (kind) {
930     case DestructuringKind::DestructureToLet:
931     case DestructuringKind::DestructureToConst:
932         return "lexical variable name";
933     case DestructuringKind::DestructureToVariables:
934         return "variable name";
935     case DestructuringKind::DestructureToParameters:
936         return "parameter name";
937     case DestructuringKind::DestructureToCatchParameters:
938         return "catch parameter name";
939     case DestructuringKind::DestructureToExpressions:
940         return "expression name";
941     }
942     RELEASE_ASSERT_NOT_REACHED();
943     return "invalid";
944 }
945
946 template <typename LexerType>
947 template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseDestructuringPattern(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth)
948 {
949     failIfStackOverflow();
950     int nonLHSCount = m_parserState.nonLHSCount;
951     TreeDestructuringPattern pattern;
952     switch (m_token.m_type) {
953     case OPENBRACKET: {
954         JSTextPosition divotStart = tokenStartPosition();
955         auto arrayPattern = context.createArrayPattern(m_token.m_location);
956         next();
957
958         if (hasDestructuringPattern)
959             *hasDestructuringPattern = true;
960
961         bool restElementWasFound = false;
962
963         do {
964             while (match(COMMA)) {
965                 context.appendArrayPatternSkipEntry(arrayPattern, m_token.m_location);
966                 next();
967             }
968             propagateError();
969
970             if (match(CLOSEBRACKET))
971                 break;
972
973             if (UNLIKELY(match(DOTDOTDOT))) {
974                 JSTokenLocation location = m_token.m_location;
975                 next();
976                 auto innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1);
977                 if (kind == DestructuringKind::DestructureToExpressions && !innerPattern)
978                     return 0;
979                 failIfFalse(innerPattern, "Cannot parse this destructuring pattern");
980                 context.appendArrayPatternRestEntry(arrayPattern, location, innerPattern);
981                 restElementWasFound = true;
982                 break;
983             }
984
985             JSTokenLocation location = m_token.m_location;
986             auto innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1);
987             if (kind == DestructuringKind::DestructureToExpressions && !innerPattern)
988                 return 0;
989             failIfFalse(innerPattern, "Cannot parse this destructuring pattern");
990             TreeExpression defaultValue = parseDefaultValueForDestructuringPattern(context);
991             propagateError();
992             context.appendArrayPatternEntry(arrayPattern, location, innerPattern, defaultValue);
993         } while (consume(COMMA));
994
995         consumeOrFail(CLOSEBRACKET, restElementWasFound ? "Expected a closing ']' following a rest element destructuring pattern" : "Expected either a closing ']' or a ',' following an element destructuring pattern");
996         context.finishArrayPattern(arrayPattern, divotStart, divotStart, lastTokenEndPosition());
997         pattern = arrayPattern;
998         break;
999     }
1000     case OPENBRACE: {
1001         auto objectPattern = context.createObjectPattern(m_token.m_location);
1002         next();
1003
1004         if (hasDestructuringPattern)
1005             *hasDestructuringPattern = true;
1006
1007         bool restElementWasFound = false;
1008
1009         do {
1010             bool wasString = false;
1011
1012             if (match(CLOSEBRACE))
1013                 break;
1014
1015             if (UNLIKELY(match(DOTDOTDOT))) {
1016                 JSTokenLocation location = m_token.m_location;
1017                 next();
1018                 auto innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1);
1019                 if (kind == DestructuringKind::DestructureToExpressions && !innerPattern)
1020                     return 0;
1021                 propagateError();
1022                 context.appendObjectPatternRestEntry(objectPattern, location, innerPattern);
1023                 restElementWasFound = true;
1024                 context.setContainsObjectRestElement(objectPattern, restElementWasFound);
1025                 break;
1026             }
1027
1028             const Identifier* propertyName = nullptr;
1029             TreeExpression propertyExpression = 0;
1030             TreeDestructuringPattern innerPattern = 0;
1031             JSTokenLocation location = m_token.m_location;
1032             if (matchSpecIdentifier()) {
1033                 failIfTrue(match(LET) && (kind == DestructuringKind::DestructureToLet || kind == DestructuringKind::DestructureToConst), "Can't use 'let' as an identifier name for a LexicalDeclaration");
1034                 propertyName = m_token.m_data.ident;
1035                 JSToken identifierToken = m_token;
1036                 next();
1037                 if (consume(COLON))
1038                     innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1);
1039                 else {
1040                     if (kind == DestructuringKind::DestructureToExpressions) {
1041                         bool isEvalOrArguments = m_vm->propertyNames->eval == *propertyName || m_vm->propertyNames->arguments == *propertyName;
1042                         if (isEvalOrArguments && strictMode())
1043                             reclassifyExpressionError(ErrorIndicatesPattern, ErrorIndicatesNothing);
1044                         failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", propertyName->impl(), "' in strict mode");
1045                     }
1046                     semanticFailIfTrue(isDisallowedIdentifierAwait(identifierToken), "Can't use 'await' as a ", destructuringKindToVariableKindName(kind), " ", disallowedIdentifierAwaitReason());
1047                     innerPattern = createBindingPattern(context, kind, exportType, *propertyName, identifierToken, bindingContext, duplicateIdentifier);
1048                 }
1049             } else {
1050                 JSTokenType tokenType = m_token.m_type;
1051                 switch (m_token.m_type) {
1052                 case DOUBLE:
1053                 case INTEGER:
1054                     propertyName = &m_parserArena.identifierArena().makeNumericIdentifier(const_cast<VM*>(m_vm), m_token.m_data.doubleValue);
1055                     break;
1056                 case STRING:
1057                     propertyName = m_token.m_data.ident;
1058                     wasString = true;
1059                     break;
1060                 case OPENBRACKET:
1061                     next();
1062                     propertyExpression = parseAssignmentExpression(context);
1063                     failIfFalse(propertyExpression, "Cannot parse computed property name");
1064                     matchOrFail(CLOSEBRACKET, "Expected ']' to end end a computed property name");
1065                     break;
1066                 default:
1067                     if (m_token.m_type != RESERVED && m_token.m_type != RESERVED_IF_STRICT && !(m_token.m_type & KeywordTokenFlag)) {
1068                         if (kind == DestructuringKind::DestructureToExpressions)
1069                             return 0;
1070                         failWithMessage("Expected a property name");
1071                     }
1072                     propertyName = m_token.m_data.ident;
1073                     break;
1074                 }
1075                 next();
1076                 if (!consume(COLON)) {
1077                     if (kind == DestructuringKind::DestructureToExpressions)
1078                         return 0;
1079                     semanticFailIfTrue(tokenType == RESERVED, "Cannot use abbreviated destructuring syntax for reserved name '", propertyName->impl(), "'");
1080                     semanticFailIfTrue(tokenType == RESERVED_IF_STRICT, "Cannot use abbreviated destructuring syntax for reserved name '", propertyName->impl(), "' in strict mode");
1081                     semanticFailIfTrue(tokenType & KeywordTokenFlag, "Cannot use abbreviated destructuring syntax for keyword '", propertyName->impl(), "'");
1082                     
1083                     failWithMessage("Expected a ':' prior to a named destructuring property");
1084                 }
1085                 innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1);
1086             }
1087             if (kind == DestructuringKind::DestructureToExpressions && !innerPattern)
1088                 return 0;
1089             failIfFalse(innerPattern, "Cannot parse this destructuring pattern");
1090             TreeExpression defaultValue = parseDefaultValueForDestructuringPattern(context);
1091             propagateError();
1092             if (propertyExpression)
1093                 context.appendObjectPatternEntry(objectPattern, location, propertyExpression, innerPattern, defaultValue);
1094             else {
1095                 ASSERT(propertyName);
1096                 context.appendObjectPatternEntry(objectPattern, location, wasString, *propertyName, innerPattern, defaultValue);
1097             }
1098         } while (consume(COMMA));
1099
1100         if (kind == DestructuringKind::DestructureToExpressions && !match(CLOSEBRACE))
1101             return 0;
1102         consumeOrFail(CLOSEBRACE, restElementWasFound ? "Expected a closing '}' following a rest element destructuring pattern" : "Expected either a closing '}' or an ',' after a property destructuring pattern");
1103         pattern = objectPattern;
1104         break;
1105     }
1106
1107     default: {
1108         if (!matchSpecIdentifier()) {
1109             if (kind == DestructuringKind::DestructureToExpressions)
1110                 return 0;
1111             semanticFailureDueToKeyword(destructuringKindToVariableKindName(kind));
1112             failWithMessage("Expected a parameter pattern or a ')' in parameter list");
1113         }
1114         failIfTrue(match(LET) && (kind == DestructuringKind::DestructureToLet || kind == DestructuringKind::DestructureToConst), "Can't use 'let' as an identifier name for a LexicalDeclaration");
1115         semanticFailIfTrue(isDisallowedIdentifierAwait(m_token), "Can't use 'await' as a ", destructuringKindToVariableKindName(kind), " ", disallowedIdentifierAwaitReason());
1116         pattern = createBindingPattern(context, kind, exportType, *m_token.m_data.ident, m_token, bindingContext, duplicateIdentifier);
1117         next();
1118         break;
1119     }
1120     }
1121     m_parserState.nonLHSCount = nonLHSCount;
1122     return pattern;
1123 }
1124
1125 template <typename LexerType>
1126 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseDefaultValueForDestructuringPattern(TreeBuilder& context)
1127 {
1128     if (!match(EQUAL))
1129         return 0;
1130
1131     next(TreeBuilder::DontBuildStrings); // consume '='
1132     return parseAssignmentExpression(context);
1133 }
1134
1135 template <typename LexerType>
1136 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement(TreeBuilder& context)
1137 {
1138     ASSERT(match(FOR));
1139     JSTokenLocation location(tokenLocation());
1140     int startLine = tokenLine();
1141     next();
1142     handleProductionOrFail(OPENPAREN, "(", "start", "for-loop header");
1143     int nonLHSCount = m_parserState.nonLHSCount;
1144     int declarations = 0;
1145     JSTokenLocation declLocation(tokenLocation());
1146     JSTextPosition declsStart;
1147     JSTextPosition declsEnd;
1148     TreeExpression decls = 0;
1149     TreeDestructuringPattern pattern = 0;
1150     bool isVarDeclaraton = match(VAR);
1151     bool isLetDeclaration = match(LET);
1152     bool isConstDeclaration = match(CONSTTOKEN);
1153     bool forLoopConstDoesNotHaveInitializer = false;
1154
1155     VariableEnvironment dummySet;
1156     VariableEnvironment* lexicalVariables = nullptr;
1157     AutoCleanupLexicalScope lexicalScope;
1158
1159     auto gatherLexicalVariablesIfNecessary = [&] {
1160         if (isLetDeclaration || isConstDeclaration) {
1161             ScopeRef scope = lexicalScope.scope();
1162             lexicalVariables = &scope->finalizeLexicalEnvironment();
1163         } else
1164             lexicalVariables = &dummySet;
1165     };
1166
1167     auto popLexicalScopeIfNecessary = [&] {
1168         if (isLetDeclaration || isConstDeclaration)
1169             popScope(lexicalScope, TreeBuilder::NeedsFreeVariableInfo);
1170     };
1171
1172     if (isVarDeclaraton || isLetDeclaration || isConstDeclaration) {
1173         /*
1174          for (var/let/const IDENT in/of expression) statement
1175          for (var/let/const varDeclarationList; expressionOpt; expressionOpt)
1176          */
1177         if (isLetDeclaration || isConstDeclaration) {
1178             ScopeRef newScope = pushScope();
1179             newScope->setIsLexicalScope();
1180             newScope->preventVarDeclarations();
1181             lexicalScope.setIsValid(newScope, this);
1182         }
1183
1184         TreeDestructuringPattern forInTarget = 0;
1185         TreeExpression forInInitializer = 0;
1186         m_allowsIn = false;
1187         JSTextPosition initStart;
1188         JSTextPosition initEnd;
1189         DeclarationType declarationType;
1190         if (isVarDeclaraton)
1191             declarationType = DeclarationType::VarDeclaration;
1192         else if (isLetDeclaration)
1193             declarationType = DeclarationType::LetDeclaration;
1194         else if (isConstDeclaration)
1195             declarationType = DeclarationType::ConstDeclaration;
1196         else
1197             RELEASE_ASSERT_NOT_REACHED();
1198         decls = parseVariableDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd, ForLoopContext, declarationType, ExportType::NotExported, forLoopConstDoesNotHaveInitializer);
1199         m_allowsIn = true;
1200         propagateError();
1201
1202         // Remainder of a standard for loop is handled identically
1203         if (match(SEMICOLON))
1204             goto standardForLoop;
1205
1206         failIfFalse(declarations == 1, "can only declare a single variable in an enumeration");
1207
1208         // Handle for-in with var declaration
1209         JSTextPosition inLocation = tokenStartPosition();
1210         bool isOfEnumeration = false;
1211         if (!consume(INTOKEN)) {
1212             failIfFalse(match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of, "Expected either 'in' or 'of' in enumeration syntax");
1213             isOfEnumeration = true;
1214             next();
1215         }
1216         bool hasAnyAssignments = !!forInInitializer;
1217         if (hasAnyAssignments) {
1218             if (isOfEnumeration)
1219                 internalFailWithMessage(false, "Cannot assign to the loop variable inside a for-of loop header");
1220             if (strictMode() || (isLetDeclaration || isConstDeclaration) || !context.isBindingNode(forInTarget))
1221                 internalFailWithMessage(false, "Cannot assign to the loop variable inside a for-in loop header");
1222         }
1223         TreeExpression expr = parseExpression(context);
1224         failIfFalse(expr, "Expected expression to enumerate");
1225         recordPauseLocation(context.breakpointLocation(expr));
1226         JSTextPosition exprEnd = lastTokenEndPosition();
1227         
1228         int endLine = tokenLine();
1229         
1230         handleProductionOrFail(CLOSEPAREN, ")", "end", (isOfEnumeration ? "for-of header" : "for-in header"));
1231         
1232         const Identifier* unused = 0;
1233         startLoop();
1234         TreeStatement statement = parseStatement(context, unused);
1235         endLoop();
1236         failIfFalse(statement, "Expected statement as body of for-", isOfEnumeration ? "of" : "in", " statement");
1237         gatherLexicalVariablesIfNecessary();
1238         TreeStatement result;
1239         if (isOfEnumeration)
1240             result = context.createForOfLoop(location, forInTarget, expr, statement, declLocation, declsStart, inLocation, exprEnd, startLine, endLine, *lexicalVariables);
1241         else {
1242             if (isVarDeclaraton && forInInitializer)
1243                 result = context.createForInLoop(location, decls, expr, statement, declLocation, declsStart, inLocation, exprEnd, startLine, endLine, *lexicalVariables);
1244             else
1245                 result = context.createForInLoop(location, forInTarget, expr, statement, declLocation, declsStart, inLocation, exprEnd, startLine, endLine, *lexicalVariables);
1246         }
1247         popLexicalScopeIfNecessary();
1248         return result;
1249     }
1250     
1251     if (!match(SEMICOLON)) {
1252         if (match(OPENBRACE) || match(OPENBRACKET)) {
1253             SavePoint savePoint = createSavePoint();
1254             declsStart = tokenStartPosition();
1255             pattern = tryParseDestructuringPatternExpression(context, AssignmentContext::DeclarationStatement);
1256             declsEnd = lastTokenEndPosition();
1257             if (pattern && (match(INTOKEN) || (match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of)))
1258                 goto enumerationLoop;
1259             pattern = TreeDestructuringPattern(0);
1260             restoreSavePoint(savePoint);
1261         }
1262         m_allowsIn = false;
1263         declsStart = tokenStartPosition();
1264         decls = parseExpression(context);
1265         declsEnd = lastTokenEndPosition();
1266         m_allowsIn = true;
1267         failIfFalse(decls, "Cannot parse for loop declarations");
1268         recordPauseLocation(context.breakpointLocation(decls));
1269     }
1270     
1271     if (match(SEMICOLON)) {
1272     standardForLoop:
1273         // Standard for loop
1274         if (decls)
1275             recordPauseLocation(context.breakpointLocation(decls));
1276         next();
1277         TreeExpression condition = 0;
1278         failIfTrue(forLoopConstDoesNotHaveInitializer && isConstDeclaration, "const variables in for loops must have initializers");
1279         
1280         if (!match(SEMICOLON)) {
1281             condition = parseExpression(context);
1282             failIfFalse(condition, "Cannot parse for loop condition expression");
1283             recordPauseLocation(context.breakpointLocation(condition));
1284         }
1285         consumeOrFail(SEMICOLON, "Expected a ';' after the for loop condition expression");
1286         
1287         TreeExpression increment = 0;
1288         if (!match(CLOSEPAREN)) {
1289             increment = parseExpression(context);
1290             failIfFalse(increment, "Cannot parse for loop iteration expression");
1291             recordPauseLocation(context.breakpointLocation(increment));
1292         }
1293         int endLine = tokenLine();
1294         handleProductionOrFail(CLOSEPAREN, ")", "end", "for-loop header");
1295         const Identifier* unused = 0;
1296         startLoop();
1297         TreeStatement statement = parseStatement(context, unused);
1298         endLoop();
1299         failIfFalse(statement, "Expected a statement as the body of a for loop");
1300         gatherLexicalVariablesIfNecessary();
1301         TreeStatement result = context.createForLoop(location, decls, condition, increment, statement, startLine, endLine, *lexicalVariables);
1302         popLexicalScopeIfNecessary();
1303         return result;
1304     }
1305     
1306     // For-in and For-of loop
1307 enumerationLoop:
1308     failIfFalse(nonLHSCount == m_parserState.nonLHSCount, "Expected a reference on the left hand side of an enumeration statement");
1309     bool isOfEnumeration = false;
1310     if (!consume(INTOKEN)) {
1311         failIfFalse(match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of, "Expected either 'in' or 'of' in enumeration syntax");
1312         isOfEnumeration = true;
1313         next();
1314     }
1315     TreeExpression expr = parseExpression(context);
1316     failIfFalse(expr, "Cannot parse subject for-", isOfEnumeration ? "of" : "in", " statement");
1317     recordPauseLocation(context.breakpointLocation(expr));
1318     JSTextPosition exprEnd = lastTokenEndPosition();
1319     int endLine = tokenLine();
1320     
1321     handleProductionOrFail(CLOSEPAREN, ")", "end", (isOfEnumeration ? "for-of header" : "for-in header"));
1322     const Identifier* unused = 0;
1323     startLoop();
1324     TreeStatement statement = parseStatement(context, unused);
1325     endLoop();
1326     failIfFalse(statement, "Expected a statement as the body of a for-", isOfEnumeration ? "of" : "in", "loop");
1327     gatherLexicalVariablesIfNecessary();
1328     TreeStatement result;
1329     if (pattern) {
1330         ASSERT(!decls);
1331         if (isOfEnumeration)
1332             result = context.createForOfLoop(location, pattern, expr, statement, declLocation, declsStart, declsEnd, exprEnd, startLine, endLine, *lexicalVariables);
1333         else 
1334             result = context.createForInLoop(location, pattern, expr, statement, declLocation, declsStart, declsEnd, exprEnd, startLine, endLine, *lexicalVariables);
1335
1336         popLexicalScopeIfNecessary();
1337         return result;
1338     }
1339     if (isOfEnumeration)
1340         result = context.createForOfLoop(location, decls, expr, statement, declLocation, declsStart, declsEnd, exprEnd, startLine, endLine, *lexicalVariables);
1341     else
1342         result = context.createForInLoop(location, decls, expr, statement, declLocation, declsStart, declsEnd, exprEnd, startLine, endLine, *lexicalVariables);
1343     popLexicalScopeIfNecessary();
1344     return result;
1345 }
1346
1347 template <typename LexerType>
1348 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBreakStatement(TreeBuilder& context)
1349 {
1350     ASSERT(match(BREAK));
1351     JSTokenLocation location(tokenLocation());
1352     JSTextPosition start = tokenStartPosition();
1353     JSTextPosition end = tokenEndPosition();
1354     next();
1355     
1356     if (autoSemiColon()) {
1357         semanticFailIfFalse(breakIsValid(), "'break' is only valid inside a switch or loop statement");
1358         return context.createBreakStatement(location, &m_vm->propertyNames->nullIdentifier, start, end);
1359     }
1360     failIfFalse(matchSpecIdentifier(), "Expected an identifier as the target for a break statement");
1361     const Identifier* ident = m_token.m_data.ident;
1362     semanticFailIfFalse(getLabel(ident), "Cannot use the undeclared label '", ident->impl(), "'");
1363     end = tokenEndPosition();
1364     next();
1365     failIfFalse(autoSemiColon(), "Expected a ';' following a targeted break statement");
1366     return context.createBreakStatement(location, ident, start, end);
1367 }
1368
1369 template <typename LexerType>
1370 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseContinueStatement(TreeBuilder& context)
1371 {
1372     ASSERT(match(CONTINUE));
1373     JSTokenLocation location(tokenLocation());
1374     JSTextPosition start = tokenStartPosition();
1375     JSTextPosition end = tokenEndPosition();
1376     next();
1377     
1378     if (autoSemiColon()) {
1379         semanticFailIfFalse(continueIsValid(), "'continue' is only valid inside a loop statement");
1380         return context.createContinueStatement(location, &m_vm->propertyNames->nullIdentifier, start, end);
1381     }
1382     failIfFalse(matchSpecIdentifier(), "Expected an identifier as the target for a continue statement");
1383     const Identifier* ident = m_token.m_data.ident;
1384     ScopeLabelInfo* label = getLabel(ident);
1385     semanticFailIfFalse(label, "Cannot use the undeclared label '", ident->impl(), "'");
1386     semanticFailIfFalse(label->isLoop, "Cannot continue to the label '", ident->impl(), "' as it is not targeting a loop");
1387     end = tokenEndPosition();
1388     next();
1389     failIfFalse(autoSemiColon(), "Expected a ';' following a targeted continue statement");
1390     return context.createContinueStatement(location, ident, start, end);
1391 }
1392
1393 template <typename LexerType>
1394 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseReturnStatement(TreeBuilder& context)
1395 {
1396     ASSERT(match(RETURN));
1397     JSTokenLocation location(tokenLocation());
1398     semanticFailIfFalse(currentScope()->isFunction(), "Return statements are only valid inside functions");
1399     JSTextPosition start = tokenStartPosition();
1400     JSTextPosition end = tokenEndPosition();
1401     next();
1402     // We do the auto semicolon check before attempting to parse expression
1403     // as we need to ensure the a line break after the return correctly terminates
1404     // the statement
1405     if (match(SEMICOLON))
1406         end = tokenEndPosition();
1407
1408     if (autoSemiColon())
1409         return context.createReturnStatement(location, 0, start, end);
1410     TreeExpression expr = parseExpression(context);
1411     failIfFalse(expr, "Cannot parse the return expression");
1412     end = lastTokenEndPosition();
1413     if (match(SEMICOLON))
1414         end  = tokenEndPosition();
1415     if (!autoSemiColon())
1416         failWithMessage("Expected a ';' following a return statement");
1417     return context.createReturnStatement(location, expr, start, end);
1418 }
1419
1420 template <typename LexerType>
1421 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseThrowStatement(TreeBuilder& context)
1422 {
1423     ASSERT(match(THROW));
1424     JSTokenLocation location(tokenLocation());
1425     JSTextPosition start = tokenStartPosition();
1426     next();
1427     failIfTrue(match(SEMICOLON), "Expected expression after 'throw'");
1428     semanticFailIfTrue(autoSemiColon(), "Cannot have a newline after 'throw'");
1429     
1430     TreeExpression expr = parseExpression(context);
1431     failIfFalse(expr, "Cannot parse expression for throw statement");
1432     JSTextPosition end = lastTokenEndPosition();
1433     failIfFalse(autoSemiColon(), "Expected a ';' after a throw statement");
1434     
1435     return context.createThrowStatement(location, expr, start, end);
1436 }
1437
1438 template <typename LexerType>
1439 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWithStatement(TreeBuilder& context)
1440 {
1441     ASSERT(match(WITH));
1442     JSTokenLocation location(tokenLocation());
1443     semanticFailIfTrue(strictMode(), "'with' statements are not valid in strict mode");
1444     currentScope()->setNeedsFullActivation();
1445     int startLine = tokenLine();
1446     next();
1447
1448     handleProductionOrFail(OPENPAREN, "(", "start", "subject of a 'with' statement");
1449     int start = tokenStart();
1450     TreeExpression expr = parseExpression(context);
1451     failIfFalse(expr, "Cannot parse 'with' subject expression");
1452     recordPauseLocation(context.breakpointLocation(expr));
1453     JSTextPosition end = lastTokenEndPosition();
1454     int endLine = tokenLine();
1455     handleProductionOrFail(CLOSEPAREN, ")", "start", "subject of a 'with' statement");
1456     const Identifier* unused = 0;
1457     TreeStatement statement = parseStatement(context, unused);
1458     failIfFalse(statement, "A 'with' statement must have a body");
1459     
1460     return context.createWithStatement(location, expr, statement, start, end, startLine, endLine);
1461 }
1462
1463 template <typename LexerType>
1464 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStatement(TreeBuilder& context)
1465 {
1466     ASSERT(match(SWITCH));
1467     JSTokenLocation location(tokenLocation());
1468     int startLine = tokenLine();
1469     next();
1470     handleProductionOrFail(OPENPAREN, "(", "start", "subject of a 'switch'");
1471     TreeExpression expr = parseExpression(context);
1472     failIfFalse(expr, "Cannot parse switch subject expression");
1473     recordPauseLocation(context.breakpointLocation(expr));
1474     int endLine = tokenLine();
1475     
1476     handleProductionOrFail(CLOSEPAREN, ")", "end", "subject of a 'switch'");
1477     handleProductionOrFail(OPENBRACE, "{", "start", "body of a 'switch'");
1478     AutoPopScopeRef lexicalScope(this, pushScope());
1479     lexicalScope->setIsLexicalScope();
1480     lexicalScope->preventVarDeclarations();
1481     startSwitch();
1482     TreeClauseList firstClauses = parseSwitchClauses(context);
1483     propagateError();
1484     
1485     TreeClause defaultClause = parseSwitchDefaultClause(context);
1486     propagateError();
1487     
1488     TreeClauseList secondClauses = parseSwitchClauses(context);
1489     propagateError();
1490     endSwitch();
1491     handleProductionOrFail(CLOSEBRACE, "}", "end", "body of a 'switch'");
1492     
1493     TreeStatement result = context.createSwitchStatement(location, expr, firstClauses, defaultClause, secondClauses, startLine, endLine, lexicalScope->finalizeLexicalEnvironment(), lexicalScope->takeFunctionDeclarations());
1494     popScope(lexicalScope, TreeBuilder::NeedsFreeVariableInfo);
1495     return result;
1496 }
1497
1498 template <typename LexerType>
1499 template <class TreeBuilder> TreeClauseList Parser<LexerType>::parseSwitchClauses(TreeBuilder& context)
1500 {
1501     if (!match(CASE))
1502         return 0;
1503     unsigned startOffset = tokenStart();
1504     next();
1505     TreeExpression condition = parseExpression(context);
1506     failIfFalse(condition, "Cannot parse switch clause");
1507     consumeOrFail(COLON, "Expected a ':' after switch clause expression");
1508     TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
1509     failIfFalse(statements, "Cannot parse the body of a switch clause");
1510     TreeClause clause = context.createClause(condition, statements);
1511     context.setStartOffset(clause, startOffset);
1512     TreeClauseList clauseList = context.createClauseList(clause);
1513     TreeClauseList tail = clauseList;
1514     
1515     while (match(CASE)) {
1516         startOffset = tokenStart();
1517         next();
1518         TreeExpression condition = parseExpression(context);
1519         failIfFalse(condition, "Cannot parse switch case expression");
1520         consumeOrFail(COLON, "Expected a ':' after switch clause expression");
1521         TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
1522         failIfFalse(statements, "Cannot parse the body of a switch clause");
1523         clause = context.createClause(condition, statements);
1524         context.setStartOffset(clause, startOffset);
1525         tail = context.createClauseList(tail, clause);
1526     }
1527     return clauseList;
1528 }
1529
1530 template <typename LexerType>
1531 template <class TreeBuilder> TreeClause Parser<LexerType>::parseSwitchDefaultClause(TreeBuilder& context)
1532 {
1533     if (!match(DEFAULT))
1534         return 0;
1535     unsigned startOffset = tokenStart();
1536     next();
1537     consumeOrFail(COLON, "Expected a ':' after switch default clause");
1538     TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
1539     failIfFalse(statements, "Cannot parse the body of a switch default clause");
1540     TreeClause result = context.createClause(0, statements);
1541     context.setStartOffset(result, startOffset);
1542     return result;
1543 }
1544
1545 template <typename LexerType>
1546 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement(TreeBuilder& context)
1547 {
1548     ASSERT(match(TRY));
1549     JSTokenLocation location(tokenLocation());
1550     TreeStatement tryBlock = 0;
1551     TreeDestructuringPattern catchPattern = 0;
1552     TreeStatement catchBlock = 0;
1553     TreeStatement finallyBlock = 0;
1554     int firstLine = tokenLine();
1555     next();
1556     matchOrFail(OPENBRACE, "Expected a block statement as body of a try statement");
1557     
1558     tryBlock = parseBlockStatement(context);
1559     failIfFalse(tryBlock, "Cannot parse the body of try block");
1560     int lastLine = m_lastTokenEndPosition.line;
1561     VariableEnvironment catchEnvironment; 
1562     if (match(CATCH)) {
1563         next();
1564         
1565         handleProductionOrFail(OPENPAREN, "(", "start", "'catch' target");
1566         AutoPopScopeRef catchScope(this, pushScope());
1567         catchScope->setIsLexicalScope();
1568         catchScope->preventVarDeclarations();
1569         const Identifier* ident = nullptr;
1570         if (matchSpecIdentifier()) {
1571             ident = m_token.m_data.ident;
1572             catchPattern = context.createBindingLocation(m_token.m_location, *ident, m_token.m_startPosition, m_token.m_endPosition, AssignmentContext::DeclarationStatement);
1573             next();
1574             failIfTrueIfStrict(catchScope->declareLexicalVariable(ident, false) & DeclarationResult::InvalidStrictMode, "Cannot declare a catch variable named '", ident->impl(), "' in strict mode");
1575         } else {
1576             catchPattern = parseDestructuringPattern(context, DestructuringKind::DestructureToCatchParameters, ExportType::NotExported);
1577             failIfFalse(catchPattern, "Cannot parse this destructuring pattern");
1578         }
1579         handleProductionOrFail(CLOSEPAREN, ")", "end", "'catch' target");
1580         matchOrFail(OPENBRACE, "Expected exception handler to be a block statement");
1581         catchBlock = parseBlockStatement(context);
1582         failIfFalse(catchBlock, "Unable to parse 'catch' block");
1583         catchEnvironment = catchScope->finalizeLexicalEnvironment();
1584         RELEASE_ASSERT(!ident || (catchEnvironment.size() == 1 && catchEnvironment.contains(ident->impl())));
1585         popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo);
1586     }
1587     
1588     if (match(FINALLY)) {
1589         next();
1590         matchOrFail(OPENBRACE, "Expected block statement for finally body");
1591         finallyBlock = parseBlockStatement(context);
1592         failIfFalse(finallyBlock, "Cannot parse finally body");
1593     }
1594     failIfFalse(catchBlock || finallyBlock, "Try statements must have at least a catch or finally block");
1595     return context.createTryStatement(location, tryBlock, catchPattern, catchBlock, finallyBlock, firstLine, lastLine, catchEnvironment);
1596 }
1597
1598 template <typename LexerType>
1599 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDebuggerStatement(TreeBuilder& context)
1600 {
1601     ASSERT(match(DEBUGGER));
1602     JSTokenLocation location(tokenLocation());
1603     int startLine = tokenLine();
1604     int endLine = startLine;
1605     next();
1606     if (match(SEMICOLON))
1607         startLine = tokenLine();
1608     failIfFalse(autoSemiColon(), "Debugger keyword must be followed by a ';'");
1609     return context.createDebugger(location, startLine, endLine);
1610 }
1611
1612 template <typename LexerType>
1613 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context)
1614 {
1615     ASSERT(match(OPENBRACE));
1616
1617     // We should treat the first block statement of the function (the body of the function) as the lexical 
1618     // scope of the function itself, and not the lexical scope of a 'block' statement within the function.
1619     AutoCleanupLexicalScope lexicalScope;
1620     bool shouldPushLexicalScope = m_statementDepth > 0;
1621     if (shouldPushLexicalScope) {
1622         ScopeRef newScope = pushScope();
1623         newScope->setIsLexicalScope();
1624         newScope->preventVarDeclarations();
1625         lexicalScope.setIsValid(newScope, this);
1626     }
1627     JSTokenLocation location(tokenLocation());
1628     int startOffset = m_token.m_data.offset;
1629     int start = tokenLine();
1630     VariableEnvironment emptyEnvironment;
1631     DeclarationStacks::FunctionStack emptyFunctionStack;
1632     next();
1633     if (match(CLOSEBRACE)) {
1634         int endOffset = m_token.m_data.offset;
1635         next();
1636         TreeStatement result = context.createBlockStatement(location, 0, start, m_lastTokenEndPosition.line, shouldPushLexicalScope ? currentScope()->finalizeLexicalEnvironment() : emptyEnvironment, shouldPushLexicalScope ? currentScope()->takeFunctionDeclarations() : WTFMove(emptyFunctionStack));
1637         context.setStartOffset(result, startOffset);
1638         context.setEndOffset(result, endOffset);
1639         if (shouldPushLexicalScope)
1640             popScope(lexicalScope, TreeBuilder::NeedsFreeVariableInfo);
1641         return result;
1642     }
1643     TreeSourceElements subtree = parseSourceElements(context, DontCheckForStrictMode);
1644     failIfFalse(subtree, "Cannot parse the body of the block statement");
1645     matchOrFail(CLOSEBRACE, "Expected a closing '}' at the end of a block statement");
1646     int endOffset = m_token.m_data.offset;
1647     next();
1648     TreeStatement result = context.createBlockStatement(location, subtree, start, m_lastTokenEndPosition.line, shouldPushLexicalScope ? currentScope()->finalizeLexicalEnvironment() : emptyEnvironment, shouldPushLexicalScope ? currentScope()->takeFunctionDeclarations() : WTFMove(emptyFunctionStack));
1649     context.setStartOffset(result, startOffset);
1650     context.setEndOffset(result, endOffset);
1651     if (shouldPushLexicalScope)
1652         popScope(lexicalScope, TreeBuilder::NeedsFreeVariableInfo);
1653
1654     return result;
1655 }
1656
1657 template <typename LexerType>
1658 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatement(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength)
1659 {
1660     DepthManager statementDepth(&m_statementDepth);
1661     m_statementDepth++;
1662     int nonTrivialExpressionCount = 0;
1663     failIfStackOverflow();
1664     TreeStatement result = 0;
1665     bool shouldSetEndOffset = true;
1666     bool shouldSetPauseLocation = false;
1667     bool parentAllowsFunctionDeclarationAsStatement = m_immediateParentAllowsFunctionDeclarationInStatement;
1668     m_immediateParentAllowsFunctionDeclarationInStatement = false;
1669
1670     switch (m_token.m_type) {
1671     case OPENBRACE:
1672         result = parseBlockStatement(context);
1673         shouldSetEndOffset = false;
1674         break;
1675     case VAR:
1676         result = parseVariableDeclaration(context, DeclarationType::VarDeclaration);
1677         shouldSetPauseLocation = true;
1678         break;
1679     case FUNCTION: {
1680         const bool isAsync = false;
1681         result = parseFunctionDeclarationStatement(context, isAsync, parentAllowsFunctionDeclarationAsStatement);
1682         break;
1683     }
1684     case SEMICOLON: {
1685         JSTokenLocation location(tokenLocation());
1686         next();
1687         result = context.createEmptyStatement(location);
1688         shouldSetPauseLocation = true;
1689         break;
1690     }
1691     case IF:
1692         result = parseIfStatement(context);
1693         break;
1694     case DO:
1695         result = parseDoWhileStatement(context);
1696         break;
1697     case WHILE:
1698         result = parseWhileStatement(context);
1699         break;
1700     case FOR:
1701         result = parseForStatement(context);
1702         break;
1703     case CONTINUE:
1704         result = parseContinueStatement(context);
1705         shouldSetPauseLocation = true;
1706         break;
1707     case BREAK:
1708         result = parseBreakStatement(context);
1709         shouldSetPauseLocation = true;
1710         break;
1711     case RETURN:
1712         result = parseReturnStatement(context);
1713         shouldSetPauseLocation = true;
1714         break;
1715     case WITH:
1716         result = parseWithStatement(context);
1717         break;
1718     case SWITCH:
1719         result = parseSwitchStatement(context);
1720         break;
1721     case THROW:
1722         result = parseThrowStatement(context);
1723         shouldSetPauseLocation = true;
1724         break;
1725     case TRY:
1726         result = parseTryStatement(context);
1727         break;
1728     case DEBUGGER:
1729         result = parseDebuggerStatement(context);
1730         shouldSetPauseLocation = true;
1731         break;
1732     case EOFTOK:
1733     case CASE:
1734     case CLOSEBRACE:
1735     case DEFAULT:
1736         // These tokens imply the end of a set of source elements
1737         return 0;
1738     case LET: {
1739         if (!strictMode())
1740             goto identcase;
1741         goto defaultCase;
1742     }
1743     case ASYNC:
1744         if (maybeParseAsyncFunctionDeclarationStatement(context, result, parentAllowsFunctionDeclarationAsStatement))
1745             break;
1746         FALLTHROUGH;
1747     case IDENT:
1748     case AWAIT:
1749     case YIELD: {
1750         identcase:
1751         bool allowFunctionDeclarationAsStatement = false;
1752         result = parseExpressionOrLabelStatement(context, allowFunctionDeclarationAsStatement);
1753         shouldSetPauseLocation = !context.shouldSkipPauseLocation(result);
1754         break;
1755     }
1756     case STRING:
1757         directive = m_token.m_data.ident;
1758         if (directiveLiteralLength)
1759             *directiveLiteralLength = m_token.m_location.endOffset - m_token.m_location.startOffset;
1760         nonTrivialExpressionCount = m_parserState.nonTrivialExpressionCount;
1761         FALLTHROUGH;
1762     default:
1763         defaultCase:
1764         TreeStatement exprStatement = parseExpressionStatement(context);
1765         if (directive && nonTrivialExpressionCount != m_parserState.nonTrivialExpressionCount)
1766             directive = nullptr;
1767         result = exprStatement;
1768         shouldSetPauseLocation = true;
1769         break;
1770     }
1771
1772     if (result) {
1773         if (shouldSetEndOffset)
1774             context.setEndOffset(result, m_lastTokenEndPosition.offset);
1775         if (shouldSetPauseLocation)
1776             recordPauseLocation(context.breakpointLocation(result));
1777     }
1778
1779     return result;
1780 }
1781
1782 template <typename LexerType>
1783 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclarationStatement(TreeBuilder& context, bool isAsync, bool parentAllowsFunctionDeclarationAsStatement)
1784 {
1785     semanticFailIfTrue(strictMode(), "Function declarations are only allowed inside blocks or switch statements in strict mode");
1786     failIfFalse(parentAllowsFunctionDeclarationAsStatement, "Function declarations are only allowed inside block statements or at the top level of a program");
1787     if (!currentScope()->isFunction()) {
1788         // We only implement annex B.3.3 if we're in function mode. Otherwise, we fall back
1789         // to hoisting behavior.
1790         // FIXME: https://bugs.webkit.org/show_bug.cgi?id=155813
1791         DepthManager statementDepth(&m_statementDepth);
1792         m_statementDepth = 1;
1793         if (isAsync)
1794             return parseAsyncFunctionDeclaration(context);
1795         return parseFunctionDeclaration(context);
1796     }
1797
1798     // Any function declaration that isn't in a block is a syntax error unless it's
1799     // in an if/else statement. If it's in an if/else statement, we will magically
1800     // treat it as if the if/else statement is inside a block statement.
1801     // to the very top like a "var". For example:
1802     // function a() {
1803     //     if (cond) function foo() { }
1804     // }
1805     // will be rewritten as:
1806     // function a() {
1807     //     if (cond) { function foo() { } }
1808     // }
1809     AutoPopScopeRef blockScope(this, pushScope());
1810     blockScope->setIsLexicalScope();
1811     blockScope->preventVarDeclarations();
1812     JSTokenLocation location(tokenLocation());
1813     int start = tokenLine();
1814
1815     TreeStatement function = 0;
1816     if (!isAsync)
1817         function = parseFunctionDeclaration(context);
1818     else
1819         function = parseAsyncFunctionDeclaration(context);
1820     propagateError();
1821     failIfFalse(function, "Expected valid function statement after 'function' keyword");
1822     TreeSourceElements sourceElements = context.createSourceElements();
1823     context.appendStatement(sourceElements, function);
1824     TreeStatement result = context.createBlockStatement(location, sourceElements, start, m_lastTokenEndPosition.line, currentScope()->finalizeLexicalEnvironment(), currentScope()->takeFunctionDeclarations());
1825     popScope(blockScope, TreeBuilder::NeedsFreeVariableInfo);
1826     return result;
1827 }
1828
1829 template <typename LexerType>
1830 template <class TreeBuilder> bool Parser<LexerType>::maybeParseAsyncFunctionDeclarationStatement(TreeBuilder& context, TreeStatement& result, bool parentAllowsFunctionDeclarationAsStatement)
1831 {
1832     ASSERT(match(ASYNC));
1833     SavePoint savePoint = createSavePoint();
1834     next();
1835     if (match(FUNCTION) && !m_lexer->prevTerminator()) {
1836         const bool isAsync = true;
1837         result = parseFunctionDeclarationStatement(context, isAsync, parentAllowsFunctionDeclarationAsStatement);
1838         return true;
1839     }
1840     restoreSavePoint(savePoint);
1841     return false;
1842 }
1843
1844 template <typename LexerType>
1845 template <class TreeBuilder> bool Parser<LexerType>::parseFormalParameters(TreeBuilder& context, TreeFormalParameterList list, bool isArrowFunction, unsigned& parameterCount)
1846 {
1847 #define failIfDuplicateIfViolation() \
1848     if (duplicateParameter) {\
1849         semanticFailIfTrue(hasDefaultParameterValues, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in function with default parameter values");\
1850         semanticFailIfTrue(hasDestructuringPattern, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in function with destructuring parameters");\
1851         semanticFailIfTrue(isRestParameter, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in function with a rest parameter");\
1852         semanticFailIfTrue(isArrowFunction, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in an arrow function");\
1853     }
1854
1855     bool hasDefaultParameterValues = false;
1856     bool hasDestructuringPattern = false;
1857     bool isRestParameter = false;
1858     const Identifier* duplicateParameter = nullptr;
1859     unsigned restParameterStart = 0;
1860     do {
1861         TreeDestructuringPattern parameter = 0;
1862         TreeExpression defaultValue = 0;
1863
1864         if (UNLIKELY(match(CLOSEPAREN)))
1865             break;
1866         
1867         if (match(DOTDOTDOT)) {
1868             next();
1869             semanticFailIfTrue(!m_parserState.allowAwait && match(AWAIT), "Can't use 'await' as a parameter name in an async function");
1870             TreeDestructuringPattern destructuringPattern = parseDestructuringPattern(context, DestructuringKind::DestructureToParameters, ExportType::NotExported, &duplicateParameter, &hasDestructuringPattern);
1871             propagateError();
1872             parameter = context.createRestParameter(destructuringPattern, restParameterStart);
1873             failIfTrue(match(COMMA), "Rest parameter should be the last parameter in a function declaration"); // Let's have a good error message for this common case.
1874             isRestParameter = true;
1875         } else
1876             parameter = parseDestructuringPattern(context, DestructuringKind::DestructureToParameters, ExportType::NotExported, &duplicateParameter, &hasDestructuringPattern);
1877         failIfFalse(parameter, "Cannot parse parameter pattern");
1878         if (!isRestParameter) {
1879             defaultValue = parseDefaultValueForDestructuringPattern(context);
1880             if (defaultValue)
1881                 hasDefaultParameterValues = true;
1882         }
1883         propagateError();
1884         failIfDuplicateIfViolation();
1885         if (isRestParameter || defaultValue || hasDestructuringPattern)
1886             currentScope()->setHasNonSimpleParameterList();
1887         context.appendParameter(list, parameter, defaultValue);
1888         if (!isRestParameter) {
1889             restParameterStart++;
1890             if (!hasDefaultParameterValues)
1891                 parameterCount++;
1892         }
1893     } while (!isRestParameter && consume(COMMA));
1894
1895     return true;
1896 #undef failIfDuplicateIfViolation
1897 }
1898
1899 template <typename LexerType>
1900 template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(
1901     TreeBuilder& context, SyntaxChecker& syntaxChecker, const JSTokenLocation& startLocation, int startColumn, int functionKeywordStart, int functionNameStart, int parametersStart,
1902     ConstructorKind constructorKind, SuperBinding superBinding, FunctionBodyType bodyType, unsigned parameterCount, SourceParseMode parseMode)
1903 {
1904     bool isArrowFunctionBodyExpression = bodyType == ArrowFunctionBodyExpression;
1905     if (!isArrowFunctionBodyExpression) {
1906         next();
1907         if (match(CLOSEBRACE)) {
1908             unsigned endColumn = tokenColumn();
1909             SuperBinding functionSuperBinding = adjustSuperBindingForBaseConstructor(constructorKind, superBinding, currentScope());
1910             return context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, endColumn, functionKeywordStart, functionNameStart, parametersStart, strictMode(), constructorKind, functionSuperBinding, parameterCount, parseMode, isArrowFunctionBodyExpression);
1911         }
1912     }
1913
1914     DepthManager statementDepth(&m_statementDepth);
1915     m_statementDepth = 0;
1916     if (bodyType == ArrowFunctionBodyExpression) {
1917         if (m_debuggerParseData)
1918             failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(context), "Cannot parse body of this arrow function");
1919         else
1920             failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(syntaxChecker), "Cannot parse body of this arrow function");
1921     } else {
1922         if (m_debuggerParseData)
1923             failIfFalse(parseSourceElements(context, CheckForStrictMode), bodyType == StandardFunctionBodyBlock ? "Cannot parse body of this function" : "Cannot parse body of this arrow function");
1924         else
1925             failIfFalse(parseSourceElements(syntaxChecker, CheckForStrictMode), bodyType == StandardFunctionBodyBlock ? "Cannot parse body of this function" : "Cannot parse body of this arrow function");
1926     }
1927     unsigned endColumn = tokenColumn();
1928     SuperBinding functionSuperBinding = adjustSuperBindingForBaseConstructor(constructorKind, superBinding, currentScope());
1929     return context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, endColumn, functionKeywordStart, functionNameStart, parametersStart, strictMode(), constructorKind, functionSuperBinding, parameterCount, parseMode, isArrowFunctionBodyExpression);
1930 }
1931
1932 static const char* stringForFunctionMode(SourceParseMode mode)
1933 {
1934     switch (mode) {
1935     case SourceParseMode::GetterMode:
1936         return "getter";
1937     case SourceParseMode::SetterMode:
1938         return "setter";
1939     case SourceParseMode::NormalFunctionMode:
1940         return "function";
1941     case SourceParseMode::MethodMode:
1942         return "method";
1943     case SourceParseMode::GeneratorBodyMode:
1944         return "generator";
1945     case SourceParseMode::GeneratorWrapperFunctionMode:
1946         return "generator function";
1947     case SourceParseMode::ArrowFunctionMode:
1948         return "arrow function";
1949     case SourceParseMode::AsyncFunctionMode:
1950     case SourceParseMode::AsyncFunctionBodyMode:
1951         return "async function";
1952     case SourceParseMode::AsyncMethodMode:
1953         return "async method";
1954     case SourceParseMode::AsyncArrowFunctionBodyMode:
1955     case SourceParseMode::AsyncArrowFunctionMode:
1956         return "async arrow function";
1957     case SourceParseMode::ProgramMode:
1958     case SourceParseMode::ModuleAnalyzeMode:
1959     case SourceParseMode::ModuleEvaluateMode:
1960         RELEASE_ASSERT_NOT_REACHED();
1961         return "";
1962     }
1963     RELEASE_ASSERT_NOT_REACHED();
1964     return nullptr;
1965 }
1966
1967 template <typename LexerType> template <class TreeBuilder, class FunctionInfoType> typename TreeBuilder::FormalParameterList Parser<LexerType>::parseFunctionParameters(TreeBuilder& context, SourceParseMode mode, FunctionInfoType& functionInfo)
1968 {
1969     RELEASE_ASSERT(!(SourceParseModeSet(SourceParseMode::ProgramMode, SourceParseMode::ModuleAnalyzeMode, SourceParseMode::ModuleEvaluateMode).contains(mode)));
1970     TreeFormalParameterList parameterList = context.createFormalParameterList();
1971     SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Parameters);
1972     
1973     if (UNLIKELY((SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(mode)))) {
1974         if (!matchSpecIdentifier() && !match(OPENPAREN)) {
1975             semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
1976             failWithMessage("Expected an arrow function input parameter");
1977         } else {
1978             if (match(OPENPAREN)) {
1979                 next();
1980                 
1981                 if (match(CLOSEPAREN)) {
1982                     functionInfo.parameterCount = 0;
1983                 } else {
1984                     bool isArrowFunction = true;
1985                     failIfFalse(parseFormalParameters(context, parameterList, isArrowFunction, functionInfo.parameterCount), "Cannot parse parameters for this ", stringForFunctionMode(mode));
1986                 }
1987                 
1988                 consumeOrFail(CLOSEPAREN, "Expected a ')' or a ',' after a parameter declaration");
1989             } else {
1990                 functionInfo.parameterCount = 1;
1991                 auto parameter = parseDestructuringPattern(context, DestructuringKind::DestructureToParameters, ExportType::NotExported);
1992                 failIfFalse(parameter, "Cannot parse parameter pattern");
1993                 context.appendParameter(parameterList, parameter, 0);
1994             }
1995         }
1996
1997         return parameterList;
1998     }
1999
2000     if (!consume(OPENPAREN)) {
2001         semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
2002         failWithMessage("Expected an opening '(' before a ", stringForFunctionMode(mode), "'s parameter list");
2003     }
2004
2005     if (mode == SourceParseMode::GetterMode) {
2006         consumeOrFail(CLOSEPAREN, "getter functions must have no parameters");
2007         functionInfo.parameterCount = 0;
2008     } else if (mode == SourceParseMode::SetterMode) {
2009         failIfTrue(match(CLOSEPAREN), "setter functions must have one parameter");
2010         const Identifier* duplicateParameter = nullptr;
2011         bool hasDestructuringPattern = false;
2012         auto parameter = parseDestructuringPattern(context, DestructuringKind::DestructureToParameters, ExportType::NotExported, &duplicateParameter, &hasDestructuringPattern);
2013         failIfFalse(parameter, "setter functions must have one parameter");
2014         auto defaultValue = parseDefaultValueForDestructuringPattern(context);
2015         propagateError();
2016         if (defaultValue || hasDestructuringPattern) {
2017             semanticFailIfTrue(duplicateParameter, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in function with non-simple parameter list");
2018             currentScope()->setHasNonSimpleParameterList();
2019         }
2020         context.appendParameter(parameterList, parameter, defaultValue);
2021         functionInfo.parameterCount = defaultValue ? 0 : 1;
2022         failIfTrue(match(COMMA), "setter functions must have one parameter");
2023         consumeOrFail(CLOSEPAREN, "Expected a ')' after a parameter declaration");
2024     } else {
2025         if (match(CLOSEPAREN)) {
2026             functionInfo.parameterCount = 0;
2027         } else {
2028             bool isArrowFunction = false;
2029             failIfFalse(parseFormalParameters(context, parameterList, isArrowFunction, functionInfo.parameterCount), "Cannot parse parameters for this ", stringForFunctionMode(mode));
2030         }
2031         consumeOrFail(CLOSEPAREN, "Expected a ')' or a ',' after a parameter declaration");
2032     }
2033
2034     return parameterList;
2035 }
2036
2037 template <typename LexerType>
2038 template <class TreeBuilder> typename TreeBuilder::FormalParameterList Parser<LexerType>::createGeneratorParameters(TreeBuilder& context, unsigned& parameterCount)
2039 {
2040     auto parameters = context.createFormalParameterList();
2041
2042     JSTokenLocation location(tokenLocation());
2043     JSTextPosition position = tokenStartPosition();
2044
2045     auto addParameter = [&](const Identifier& name) {
2046         declareParameter(&name);
2047         auto binding = context.createBindingLocation(location, name, position, position, AssignmentContext::DeclarationStatement);
2048         context.appendParameter(parameters, binding, 0);
2049         ++parameterCount;
2050     };
2051
2052     // @generator
2053     addParameter(m_vm->propertyNames->builtinNames().generatorPrivateName());
2054     // @generatorState
2055     addParameter(m_vm->propertyNames->builtinNames().generatorStatePrivateName());
2056     // @generatorValue
2057     addParameter(m_vm->propertyNames->builtinNames().generatorValuePrivateName());
2058     // @generatorResumeMode
2059     addParameter(m_vm->propertyNames->builtinNames().generatorResumeModePrivateName());
2060     // @generatorFrame
2061     addParameter(m_vm->propertyNames->builtinNames().generatorFramePrivateName());
2062
2063     return parameters;
2064 }
2065
2066 template <typename LexerType>
2067 template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, FunctionNameRequirements requirements, SourceParseMode mode, bool nameIsInContainingScope, ConstructorKind constructorKind, SuperBinding expectedSuperBinding, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>& functionInfo, FunctionDefinitionType functionDefinitionType)
2068 {
2069     RELEASE_ASSERT(isFunctionParseMode(mode));
2070
2071     ScopeRef parentScope = currentScope();
2072
2073     bool isDisallowedAwaitFunctionName = isDisallowedIdentifierAwait(m_token);
2074     const char* isDisallowedAwaitFunctionNameReason = isDisallowedAwaitFunctionName ? disallowedIdentifierAwaitReason() : nullptr;
2075
2076     AutoPopScopeRef functionScope(this, pushScope());
2077     functionScope->setSourceParseMode(mode);
2078     functionScope->setExpectedSuperBinding(expectedSuperBinding);
2079     functionScope->setConstructorKind(constructorKind);
2080     SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Body);
2081     int functionNameStart = m_token.m_location.startOffset;
2082     const Identifier* lastFunctionName = m_parserState.lastFunctionName;
2083     m_parserState.lastFunctionName = nullptr;
2084     int parametersStart = -1;
2085     JSTokenLocation startLocation;
2086     int startColumn = -1;
2087     FunctionBodyType functionBodyType;
2088
2089     auto loadCachedFunction = [&] () -> bool {
2090         if (UNLIKELY(!Options::useSourceProviderCache()))
2091             return false;
2092
2093         if (UNLIKELY(m_debuggerParseData))
2094             return false;
2095
2096         ASSERT(parametersStart != -1);
2097         ASSERT(startColumn != -1);
2098
2099         // If we know about this function already, we can use the cached info and skip the parser to the end of the function.
2100         if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(parametersStart) : 0) {
2101             // If we're in a strict context, the cached function info must say it was strict too.
2102             ASSERT(!strictMode() || cachedInfo->strictMode);
2103             JSTokenLocation endLocation;
2104
2105             ConstructorKind constructorKind = static_cast<ConstructorKind>(cachedInfo->constructorKind);
2106             SuperBinding expectedSuperBinding = static_cast<SuperBinding>(cachedInfo->expectedSuperBinding);
2107
2108             endLocation.line = cachedInfo->lastTokenLine;
2109             endLocation.startOffset = cachedInfo->lastTokenStartOffset;
2110             endLocation.lineStartOffset = cachedInfo->lastTokenLineStartOffset;
2111             ASSERT(endLocation.startOffset >= endLocation.lineStartOffset);
2112
2113             bool endColumnIsOnStartLine = endLocation.line == functionInfo.startLine;
2114             unsigned currentLineStartOffset = m_lexer->currentLineStartOffset();
2115             unsigned bodyEndColumn = endColumnIsOnStartLine ? endLocation.startOffset - currentLineStartOffset : endLocation.startOffset - endLocation.lineStartOffset;
2116
2117             ASSERT(endLocation.startOffset >= endLocation.lineStartOffset);
2118             
2119             FunctionBodyType functionBodyType;
2120             if (UNLIKELY(SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(mode)))
2121                 functionBodyType = cachedInfo->isBodyArrowExpression ?  ArrowFunctionBodyExpression : ArrowFunctionBodyBlock;
2122             else
2123                 functionBodyType = StandardFunctionBodyBlock;
2124
2125             SuperBinding functionSuperBinding = adjustSuperBindingForBaseConstructor(constructorKind, expectedSuperBinding, cachedInfo->needsSuperBinding, cachedInfo->usesEval, cachedInfo->innerArrowFunctionFeatures);
2126
2127             functionInfo.body = context.createFunctionMetadata(
2128                 startLocation, endLocation, startColumn, bodyEndColumn, 
2129                 functionKeywordStart, functionNameStart, parametersStart, 
2130                 cachedInfo->strictMode, constructorKind, functionSuperBinding,
2131                 cachedInfo->parameterCount,
2132                 mode, functionBodyType == ArrowFunctionBodyExpression);
2133             functionInfo.endOffset = cachedInfo->endFunctionOffset;
2134             functionInfo.parameterCount = cachedInfo->parameterCount;
2135
2136             functionScope->restoreFromSourceProviderCache(cachedInfo);
2137             popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo);
2138             
2139             m_token = cachedInfo->endFunctionToken();
2140
2141             if (endColumnIsOnStartLine)
2142                 m_token.m_location.lineStartOffset = currentLineStartOffset;
2143
2144             m_lexer->setOffset(m_token.m_location.endOffset, m_token.m_location.lineStartOffset);
2145             m_lexer->setLineNumber(m_token.m_location.line);
2146
2147             switch (functionBodyType) {
2148             case ArrowFunctionBodyExpression:
2149                 next();
2150                 context.setEndOffset(functionInfo.body, m_lexer->currentOffset());
2151                 break;
2152             case ArrowFunctionBodyBlock:
2153             case StandardFunctionBodyBlock:
2154                 context.setEndOffset(functionInfo.body, m_lexer->currentOffset());
2155                 next();
2156                 break;
2157             }
2158             functionInfo.endLine = m_lastTokenEndPosition.line;
2159             return true;
2160         }
2161
2162         return false;
2163     };
2164
2165     SyntaxChecker syntaxChecker(const_cast<VM*>(m_vm), m_lexer.get());
2166
2167     if (UNLIKELY((SourceParseModeSet(SourceParseMode::ArrowFunctionMode, SourceParseMode::AsyncArrowFunctionMode).contains(mode)))) {
2168         startLocation = tokenLocation();
2169         functionInfo.startLine = tokenLine();
2170         startColumn = tokenColumn();
2171
2172         parametersStart = m_token.m_location.startOffset;
2173         functionInfo.startOffset = parametersStart;
2174         functionInfo.parametersStartColumn = startColumn;
2175
2176         if (loadCachedFunction())
2177             return true;
2178
2179         {
2180             // Parse formal parameters with [+Yield] parameterization, in order to ban YieldExpressions
2181             // in ArrowFormalParameters, per ES6 #sec-arrow-function-definitions-static-semantics-early-errors.
2182             Scope::MaybeParseAsGeneratorForScope parseAsGenerator(functionScope, parentScope->isGenerator());
2183             SetForScope<bool> overrideAllowAwait(m_parserState.allowAwait, !isAsyncFunctionParseMode(mode));
2184             parseFunctionParameters(syntaxChecker, mode, functionInfo);
2185             propagateError();
2186         }
2187
2188         matchOrFail(ARROWFUNCTION, "Expected a '=>' after arrow function parameter declaration");
2189
2190         if (m_lexer->prevTerminator())
2191             failDueToUnexpectedToken();
2192
2193         ASSERT(constructorKind == ConstructorKind::None);
2194
2195         // Check if arrow body start with {. If it true it mean that arrow function is Fat arrow function
2196         // and we need use common approach to parse function body
2197         next();
2198         functionBodyType = match(OPENBRACE) ? ArrowFunctionBodyBlock : ArrowFunctionBodyExpression;
2199     } else {
2200         // http://ecma-international.org/ecma-262/6.0/#sec-function-definitions
2201         // FunctionExpression :
2202         //     function BindingIdentifieropt ( FormalParameters ) { FunctionBody }
2203         //
2204         // FunctionDeclaration[Yield, Default] :
2205         //     function BindingIdentifier[?Yield] ( FormalParameters ) { FunctionBody }
2206         //     [+Default] function ( FormalParameters ) { FunctionBody }
2207         //
2208         // GeneratorDeclaration[Yield, Default] :
2209         //     function * BindingIdentifier[?Yield] ( FormalParameters[Yield] ) { GeneratorBody }
2210         //     [+Default] function * ( FormalParameters[Yield] ) { GeneratorBody }
2211         //
2212         // GeneratorExpression :
2213         //     function * BindingIdentifier[Yield]opt ( FormalParameters[Yield] ) { GeneratorBody }
2214         //
2215         // The name of FunctionExpression and AsyncFunctionExpression can accept "yield" even in the context of generator.
2216         bool upperScopeIsGenerator = false;
2217         if (!(functionDefinitionType == FunctionDefinitionType::Expression && SourceParseModeSet(SourceParseMode::NormalFunctionMode, SourceParseMode::AsyncFunctionMode).contains(mode)))
2218             upperScopeIsGenerator = upperScope(1)->isGenerator();
2219
2220         if (requirements != FunctionNameRequirements::Unnamed) {
2221             ASSERT_WITH_MESSAGE(!(requirements == FunctionNameRequirements::None && !functionInfo.name), "When specifying FunctionNameRequirements::None, we need to initialize functionInfo.name with the default value in the caller side.");
2222             if (matchSpecIdentifier(upperScopeIsGenerator)) {
2223                 functionInfo.name = m_token.m_data.ident;
2224                 m_parserState.lastFunctionName = functionInfo.name;
2225                 if (UNLIKELY(isDisallowedAwaitFunctionName))
2226                     semanticFailIfTrue(functionDefinitionType == FunctionDefinitionType::Declaration || isAsyncFunctionWrapperParseMode(mode), "Cannot declare function named 'await' ", isDisallowedAwaitFunctionNameReason);
2227                 else if (isAsyncFunctionWrapperParseMode(mode) && match(AWAIT) && functionDefinitionType == FunctionDefinitionType::Expression)
2228                     semanticFail("Cannot declare async function named 'await'");
2229                 next();
2230                 if (!nameIsInContainingScope)
2231                     failIfTrueIfStrict(functionScope->declareCallee(functionInfo.name) & DeclarationResult::InvalidStrictMode, "'", functionInfo.name->impl(), "' is not a valid ", stringForFunctionMode(mode), " name in strict mode");
2232             } else if (requirements == FunctionNameRequirements::Named) {
2233                 if (match(OPENPAREN)) {
2234                     semanticFailIfTrue(mode == SourceParseMode::NormalFunctionMode, "Function statements must have a name");
2235                     semanticFailIfTrue(mode == SourceParseMode::AsyncFunctionMode, "Async function statements must have a name");
2236                 }
2237                 semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
2238                 failDueToUnexpectedToken();
2239                 return false;
2240             }
2241             ASSERT(functionInfo.name);
2242         }
2243
2244         startLocation = tokenLocation();
2245         functionInfo.startLine = tokenLine();
2246         startColumn = tokenColumn();
2247         functionInfo.parametersStartColumn = startColumn;
2248
2249         parametersStart = m_token.m_location.startOffset;
2250         functionInfo.startOffset = parametersStart;
2251
2252         if (loadCachedFunction())
2253             return true;
2254         {
2255             SetForScope<bool> overrideAllowAwait(m_parserState.allowAwait, !isAsyncFunctionParseMode(mode));
2256             parseFunctionParameters(syntaxChecker, mode, functionInfo);
2257             propagateError();
2258         }
2259         
2260         matchOrFail(OPENBRACE, "Expected an opening '{' at the start of a ", stringForFunctionMode(mode), " body");
2261         
2262         // BytecodeGenerator emits code to throw TypeError when a class constructor is "call"ed.
2263         // Set ConstructorKind to None for non-constructor methods of classes.
2264     
2265         if (m_defaultConstructorKind != ConstructorKind::None) {
2266             constructorKind = m_defaultConstructorKind;
2267             expectedSuperBinding = m_defaultConstructorKind == ConstructorKind::Extends ? SuperBinding::Needed : SuperBinding::NotNeeded;
2268         }
2269
2270         functionBodyType = StandardFunctionBodyBlock;
2271     }
2272
2273     functionScope->setConstructorKind(constructorKind);
2274     functionScope->setExpectedSuperBinding(expectedSuperBinding);
2275
2276     m_parserState.lastFunctionName = lastFunctionName;
2277     ParserState oldState = internalSaveParserState();
2278
2279     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=156962
2280     // This loop collects the set of capture candidates that aren't
2281     // part of the set of this function's declared parameters. We will
2282     // figure out which parameters are captured for this function when
2283     // we actually generate code for it. For now, we just propagate to
2284     // our parent scopes which variables we might have closed over that
2285     // belong to them. This is necessary for correctness when using
2286     // the source provider cache because we can't close over a variable
2287     // that we don't claim to close over. The source provider cache must
2288     // know this information to properly cache this function.
2289     // This might work itself out nicer if we declared a different
2290     // Scope struct for the parameters (because they are indeed implemented
2291     // as their own scope).
2292     UniquedStringImplPtrSet nonLocalCapturesFromParameterExpressions;
2293     functionScope->forEachUsedVariable([&] (UniquedStringImpl* impl) {
2294         if (!functionScope->hasDeclaredParameter(impl)) {
2295             nonLocalCapturesFromParameterExpressions.add(impl);
2296             if (TreeBuilder::NeedsFreeVariableInfo)
2297                 parentScope->addClosedVariableCandidateUnconditionally(impl);
2298         }
2299     });
2300
2301     auto performParsingFunctionBody = [&] {
2302         return parseFunctionBody(context, syntaxChecker, startLocation, startColumn, functionKeywordStart, functionNameStart, parametersStart, constructorKind, expectedSuperBinding, functionBodyType, functionInfo.parameterCount, mode);
2303     };
2304
2305     if (isGeneratorOrAsyncFunctionWrapperParseMode(mode)) {
2306         AutoPopScopeRef generatorBodyScope(this, pushScope());
2307         SourceParseMode innerParseMode = SourceParseMode::GeneratorBodyMode;
2308         if (isAsyncFunctionWrapperParseMode(mode)) {
2309             innerParseMode = mode == SourceParseMode::AsyncArrowFunctionMode
2310                 ? SourceParseMode::AsyncArrowFunctionBodyMode
2311                 : SourceParseMode::AsyncFunctionBodyMode;
2312         }
2313         generatorBodyScope->setSourceParseMode(innerParseMode);
2314         generatorBodyScope->setConstructorKind(ConstructorKind::None);
2315         generatorBodyScope->setExpectedSuperBinding(expectedSuperBinding);
2316
2317         // Disallow 'use strict' directives in the implicit inner function if
2318         // needed.
2319         if (functionScope->hasNonSimpleParameterList())
2320             generatorBodyScope->setHasNonSimpleParameterList();
2321
2322         functionInfo.body = performParsingFunctionBody();
2323
2324         // When a generator has a "use strict" directive, a generator function wrapping it should be strict mode.
2325         if  (generatorBodyScope->strictMode())
2326             functionScope->setStrictMode();
2327
2328         popScope(generatorBodyScope, TreeBuilder::NeedsFreeVariableInfo);
2329     } else
2330         functionInfo.body = performParsingFunctionBody();
2331     
2332     restoreParserState(oldState);
2333     failIfFalse(functionInfo.body, "Cannot parse the body of this ", stringForFunctionMode(mode));
2334     context.setEndOffset(functionInfo.body, m_lexer->currentOffset());
2335     if (functionScope->strictMode() && requirements != FunctionNameRequirements::Unnamed) {
2336         ASSERT(functionInfo.name);
2337         RELEASE_ASSERT(SourceParseModeSet(SourceParseMode::NormalFunctionMode, SourceParseMode::MethodMode, SourceParseMode::ArrowFunctionMode, SourceParseMode::GeneratorBodyMode, SourceParseMode::GeneratorWrapperFunctionMode).contains(mode) || isAsyncFunctionWrapperParseMode(mode));
2338         semanticFailIfTrue(m_vm->propertyNames->arguments == *functionInfo.name, "'", functionInfo.name->impl(), "' is not a valid function name in strict mode");
2339         semanticFailIfTrue(m_vm->propertyNames->eval == *functionInfo.name, "'", functionInfo.name->impl(), "' is not a valid function name in strict mode");
2340     }
2341
2342     JSTokenLocation location = JSTokenLocation(m_token.m_location);
2343     functionInfo.endOffset = m_token.m_data.offset;
2344     
2345     if (functionBodyType == ArrowFunctionBodyExpression) {
2346         location = locationBeforeLastToken();
2347         functionInfo.endOffset = location.endOffset;
2348     } else {
2349         recordFunctionEntryLocation(JSTextPosition(startLocation.line, startLocation.startOffset, startLocation.lineStartOffset));
2350         recordFunctionLeaveLocation(JSTextPosition(location.line, location.startOffset, location.lineStartOffset));
2351     }
2352
2353     // Cache the tokenizer state and the function scope the first time the function is parsed.
2354     // Any future reparsing can then skip the function.
2355     // For arrow function is 8 = x=>x + 4 symbols;
2356     // For ordinary function is 16  = function(){} + 4 symbols
2357     const int minimumSourceLengthToCache = functionBodyType == StandardFunctionBodyBlock ? 16 : 8;
2358     std::unique_ptr<SourceProviderCacheItem> newInfo;
2359     int sourceLength = functionInfo.endOffset - functionInfo.startOffset;
2360     if (TreeBuilder::CanUseFunctionCache && m_functionCache && sourceLength > minimumSourceLengthToCache) {
2361         SourceProviderCacheItemCreationParameters parameters;
2362         parameters.endFunctionOffset = functionInfo.endOffset;
2363         parameters.functionNameStart = functionNameStart;
2364         parameters.lastTokenLine = location.line;
2365         parameters.lastTokenStartOffset = location.startOffset;
2366         parameters.lastTokenEndOffset = location.endOffset;
2367         parameters.lastTokenLineStartOffset = location.lineStartOffset;
2368         parameters.parameterCount = functionInfo.parameterCount;
2369         parameters.constructorKind = constructorKind;
2370         parameters.expectedSuperBinding = expectedSuperBinding;
2371         if (functionBodyType == ArrowFunctionBodyExpression) {
2372             parameters.isBodyArrowExpression = true;
2373             parameters.tokenType = m_token.m_type;
2374         }
2375         functionScope->fillParametersForSourceProviderCache(parameters, nonLocalCapturesFromParameterExpressions);
2376         newInfo = SourceProviderCacheItem::create(parameters);
2377     }
2378     
2379     popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo);
2380     
2381     if (functionBodyType != ArrowFunctionBodyExpression) {
2382         matchOrFail(CLOSEBRACE, "Expected a closing '}' after a ", stringForFunctionMode(mode), " body");
2383         next();
2384     }
2385
2386     if (newInfo)
2387         m_functionCache->add(functionInfo.startOffset, WTFMove(newInfo));
2388     
2389     functionInfo.endLine = m_lastTokenEndPosition.line;
2390     return true;
2391 }
2392
2393 static NO_RETURN_DUE_TO_CRASH FunctionMetadataNode* getMetadata(ParserFunctionInfo<SyntaxChecker>&) { RELEASE_ASSERT_NOT_REACHED(); }
2394 static FunctionMetadataNode* getMetadata(ParserFunctionInfo<ASTBuilder>& info) { return info.body; }
2395
2396 template <typename LexerType>
2397 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context, ExportType exportType, DeclarationDefaultContext declarationDefaultContext)
2398 {
2399     ASSERT(match(FUNCTION));
2400     JSTokenLocation location(tokenLocation());
2401     unsigned functionKeywordStart = tokenStart();
2402     next();
2403     SourceParseMode parseMode = SourceParseMode::NormalFunctionMode;
2404     if (consume(TIMES))
2405         parseMode = SourceParseMode::GeneratorWrapperFunctionMode;
2406
2407     ParserFunctionInfo<TreeBuilder> functionInfo;
2408     FunctionNameRequirements requirements = FunctionNameRequirements::Named;
2409     if (declarationDefaultContext == DeclarationDefaultContext::ExportDefault) {
2410         // Under the "export default" context, function declaration does not require the function name.
2411         //
2412         //     ExportDeclaration:
2413         //         ...
2414         //         export default HoistableDeclaration[~Yield, +Default]
2415         //         ...
2416         //
2417         //     HoistableDeclaration[Yield, Default]:
2418         //         FunctionDeclaration[?Yield, ?Default]
2419         //         GeneratorDeclaration[?Yield, ?Default]
2420         //
2421         //     FunctionDeclaration[Yield, Default]:
2422         //         ...
2423         //         [+Default] function ( FormalParameters[~Yield] ) { FunctionBody[~Yield] }
2424         //
2425         //     GeneratorDeclaration[Yield, Default]:
2426         //         ...
2427         //         [+Default] function * ( FormalParameters[+Yield] ) { GeneratorBody }
2428         //
2429         // In this case, we use "*default*" as this function declaration's name.
2430         requirements = FunctionNameRequirements::None;
2431         functionInfo.name = &m_vm->propertyNames->builtinNames().starDefaultPrivateName();
2432     }
2433
2434     failIfFalse((parseFunctionInfo(context, requirements, parseMode, true, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, functionInfo, FunctionDefinitionType::Declaration)), "Cannot parse this function");
2435     ASSERT(functionInfo.name);
2436
2437     std::pair<DeclarationResultMask, ScopeRef> functionDeclaration = declareFunction(functionInfo.name);
2438     DeclarationResultMask declarationResult = functionDeclaration.first;
2439     failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare a function named '", functionInfo.name->impl(), "' in strict mode");
2440     if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration)
2441         internalFailWithMessage(false, "Cannot declare a function that shadows a let/const/class/function variable '", functionInfo.name->impl(), "' in strict mode");
2442     if (exportType == ExportType::Exported) {
2443         ASSERT_WITH_MESSAGE(declarationDefaultContext != DeclarationDefaultContext::ExportDefault, "Export default case will export the name and binding in the caller.");
2444         semanticFailIfFalse(exportName(*functionInfo.name), "Cannot export a duplicate function name: '", functionInfo.name->impl(), "'");
2445         m_moduleScopeData->exportBinding(*functionInfo.name);
2446     }
2447
2448     TreeStatement result = context.createFuncDeclStatement(location, functionInfo);
2449     if (TreeBuilder::CreatesAST)
2450         functionDeclaration.second->appendFunction(getMetadata(functionInfo));
2451     return result;
2452 }
2453
2454 template <typename LexerType>
2455 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseAsyncFunctionDeclaration(TreeBuilder& context, ExportType exportType, DeclarationDefaultContext declarationDefaultContext)
2456 {
2457     ASSERT(match(FUNCTION));
2458     JSTokenLocation location(tokenLocation());
2459     unsigned functionKeywordStart = tokenStart();
2460     next();
2461     ParserFunctionInfo<TreeBuilder> functionInfo;
2462     SourceParseMode parseMode = SourceParseMode::AsyncFunctionMode;
2463     FunctionNameRequirements requirements = FunctionNameRequirements::Named;
2464     if (declarationDefaultContext == DeclarationDefaultContext::ExportDefault) {
2465         // Under the "export default" context, function declaration does not require the function name.
2466         //
2467         //     ExportDeclaration:
2468         //         ...
2469         //         export default HoistableDeclaration[~Yield, +Default]
2470         //         ...
2471         //
2472         //     HoistableDeclaration[Yield, Default]:
2473         //         FunctionDeclaration[?Yield, ?Default]
2474         //         GeneratorDeclaration[?Yield, ?Default]
2475         //
2476         //     FunctionDeclaration[Yield, Default]:
2477         //         ...
2478         //         [+Default] function ( FormalParameters[~Yield] ) { FunctionBody[~Yield] }
2479         //
2480         //     GeneratorDeclaration[Yield, Default]:
2481         //         ...
2482         //         [+Default] function * ( FormalParameters[+Yield] ) { GeneratorBody }
2483         //
2484         // In this case, we use "*default*" as this function declaration's name.
2485         requirements = FunctionNameRequirements::None;
2486         functionInfo.name = &m_vm->propertyNames->builtinNames().starDefaultPrivateName();
2487     }
2488
2489     failIfFalse((parseFunctionInfo(context, requirements, parseMode, true, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, functionInfo, FunctionDefinitionType::Declaration)), "Cannot parse this async function");
2490     failIfFalse(functionInfo.name, "Async function statements must have a name");
2491
2492     std::pair<DeclarationResultMask, ScopeRef> functionDeclaration = declareFunction(functionInfo.name);
2493     DeclarationResultMask declarationResult = functionDeclaration.first;
2494     failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare an async function named '", functionInfo.name->impl(), "' in strict mode");
2495     if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration)
2496         internalFailWithMessage(false, "Cannot declare an async function that shadows a let/const/class/function variable '", functionInfo.name->impl(), "' in strict mode");
2497     if (exportType == ExportType::Exported) {
2498         semanticFailIfFalse(exportName(*functionInfo.name), "Cannot export a duplicate function name: '", functionInfo.name->impl(), "'");
2499         m_moduleScopeData->exportBinding(*functionInfo.name);
2500     }
2501
2502     TreeStatement result = context.createFuncDeclStatement(location, functionInfo);
2503     if (TreeBuilder::CreatesAST)
2504         functionDeclaration.second->appendFunction(getMetadata(functionInfo));
2505     return result;
2506 }
2507
2508 template <typename LexerType>
2509 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseClassDeclaration(TreeBuilder& context, ExportType exportType, DeclarationDefaultContext declarationDefaultContext)
2510 {
2511     ASSERT(match(CLASSTOKEN));
2512     JSTokenLocation location(tokenLocation());
2513     JSTextPosition classStart = tokenStartPosition();
2514     unsigned classStartLine = tokenLine();
2515
2516     ParserClassInfo<TreeBuilder> info;
2517     FunctionNameRequirements requirements = FunctionNameRequirements::Named;
2518     if (declarationDefaultContext == DeclarationDefaultContext::ExportDefault) {
2519         // Under the "export default" context, class declaration does not require the class name.
2520         //
2521         //     ExportDeclaration:
2522         //         ...
2523         //         export default ClassDeclaration[~Yield, +Default]
2524         //         ...
2525         //
2526         //     ClassDeclaration[Yield, Default]:
2527         //         ...
2528         //         [+Default] class ClassTail[?Yield]
2529         //
2530         // In this case, we use "*default*" as this class declaration's name.
2531         requirements = FunctionNameRequirements::None;
2532         info.className = &m_vm->propertyNames->builtinNames().starDefaultPrivateName();
2533     }
2534
2535     TreeClassExpression classExpr = parseClass(context, requirements, info);
2536     failIfFalse(classExpr, "Failed to parse class");
2537     ASSERT(info.className);
2538
2539     DeclarationResultMask declarationResult = declareVariable(info.className, DeclarationType::LetDeclaration);
2540     if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration)
2541         internalFailWithMessage(false, "Cannot declare a class twice: '", info.className->impl(), "'");
2542     if (exportType == ExportType::Exported) {
2543         ASSERT_WITH_MESSAGE(declarationDefaultContext != DeclarationDefaultContext::ExportDefault, "Export default case will export the name and binding in the caller.");
2544         semanticFailIfFalse(exportName(*info.className), "Cannot export a duplicate class name: '", info.className->impl(), "'");
2545         m_moduleScopeData->exportBinding(*info.className);
2546     }
2547
2548     JSTextPosition classEnd = lastTokenEndPosition();
2549     unsigned classEndLine = tokenLine();
2550
2551     return context.createClassDeclStatement(location, classExpr, classStart, classEnd, classStartLine, classEndLine);
2552 }
2553
2554 template <typename LexerType>
2555 template <class TreeBuilder> TreeClassExpression Parser<LexerType>::parseClass(TreeBuilder& context, FunctionNameRequirements requirements, ParserClassInfo<TreeBuilder>& info)
2556 {
2557     ASSERT(match(CLASSTOKEN));
2558     JSTokenLocation location(tokenLocation());
2559     info.startLine = location.line;
2560     info.startColumn = tokenColumn();
2561     info.startOffset = location.startOffset;
2562     next();
2563
2564     AutoPopScopeRef classScope(this, pushScope());
2565     classScope->setIsLexicalScope();
2566     classScope->preventVarDeclarations();
2567     classScope->setStrictMode();
2568
2569     ASSERT_WITH_MESSAGE(requirements != FunctionNameRequirements::Unnamed, "Currently, there is no caller that uses FunctionNameRequirements::Unnamed for class syntax.");
2570     ASSERT_WITH_MESSAGE(!(requirements == FunctionNameRequirements::None && !info.className), "When specifying FunctionNameRequirements::None, we need to initialize info.className with the default value in the caller side.");
2571     if (match(IDENT)) {
2572         info.className = m_token.m_data.ident;
2573         next();
2574         failIfTrue(classScope->declareLexicalVariable(info.className, true) & DeclarationResult::InvalidStrictMode, "'", info.className->impl(), "' is not a valid class name");
2575     } else if (requirements == FunctionNameRequirements::Named) {
2576         if (match(OPENBRACE))
2577             semanticFail("Class statements must have a name");
2578         semanticFailureDueToKeyword("class name");
2579         failDueToUnexpectedToken();
2580     }
2581     ASSERT(info.className);
2582
2583     TreeExpression parentClass = 0;
2584     if (consume(EXTENDS)) {
2585         parentClass = parseMemberExpression(context);
2586         failIfFalse(parentClass, "Cannot parse the parent class name");
2587     }
2588     const ConstructorKind constructorKind = parentClass ? ConstructorKind::Extends : ConstructorKind::Base;
2589
2590     consumeOrFail(OPENBRACE, "Expected opening '{' at the start of a class body");
2591
2592     TreeExpression constructor = 0;
2593     TreePropertyList staticMethods = 0;
2594     TreePropertyList instanceMethods = 0;
2595     TreePropertyList instanceMethodsTail = 0;
2596     TreePropertyList staticMethodsTail = 0;
2597     while (!match(CLOSEBRACE)) {
2598         if (match(SEMICOLON)) {
2599             next();
2600             continue;
2601         }
2602
2603         JSTokenLocation methodLocation(tokenLocation());
2604         unsigned methodStart = tokenStart();
2605
2606         // For backwards compatibility, "static" is a non-reserved keyword in non-strict mode.
2607         bool isStaticMethod = false;
2608         if (match(RESERVED_IF_STRICT) && *m_token.m_data.ident == m_vm->propertyNames->staticKeyword) {
2609             SavePoint savePoint = createSavePoint();
2610             next();
2611             if (match(OPENPAREN)) {
2612                 // Reparse "static()" as a method named "static".
2613                 restoreSavePoint(savePoint);
2614             } else
2615                 isStaticMethod = true;
2616         }
2617
2618         // FIXME: Figure out a way to share more code with parseProperty.
2619         const CommonIdentifiers& propertyNames = *m_vm->propertyNames;
2620         const Identifier* ident = &propertyNames.nullIdentifier;
2621         TreeExpression computedPropertyName = 0;
2622         bool isGetter = false;
2623         bool isSetter = false;
2624         bool isGenerator = false;
2625         bool isAsync = false;
2626         bool isAsyncMethod = false;
2627         if (consume(TIMES))
2628             isGenerator = true;
2629
2630 parseMethod:
2631         switch (m_token.m_type) {
2632         namedKeyword:
2633         case STRING:
2634             ident = m_token.m_data.ident;
2635             ASSERT(ident);
2636             next();
2637             break;
2638         case ASYNC:
2639             isAsync = !isGenerator && !isAsyncMethod;
2640             FALLTHROUGH;
2641         case IDENT:
2642         case AWAIT:
2643             ident = m_token.m_data.ident;
2644             ASSERT(ident);
2645             next();
2646             if (!isGenerator && !isAsyncMethod && (matchIdentifierOrKeyword() || match(STRING) || match(DOUBLE) || match(INTEGER) || match(OPENBRACKET))) {
2647                 isGetter = *ident == propertyNames.get;
2648                 isSetter = *ident == propertyNames.set;
2649
2650                 if (UNLIKELY(isAsync && !m_lexer->prevTerminator())) {
2651                     isAsyncMethod = true;
2652                     goto parseMethod;
2653                 }
2654             }
2655             break;
2656         case DOUBLE:
2657         case INTEGER:
2658             ident = &m_parserArena.identifierArena().makeNumericIdentifier(const_cast<VM*>(m_vm), m_token.m_data.doubleValue);
2659             ASSERT(ident);
2660             next();
2661             break;
2662         case OPENBRACKET:
2663             next();
2664             computedPropertyName = parseAssignmentExpression(context);
2665             failIfFalse(computedPropertyName, "Cannot parse computed property name");
2666             handleProductionOrFail(CLOSEBRACKET, "]", "end", "computed property name");
2667             break;
2668         default:
2669             if (m_token.m_type & KeywordTokenFlag)
2670                 goto namedKeyword;
2671             failDueToUnexpectedToken();
2672         }
2673
2674         TreeProperty property;
2675         const bool alwaysStrictInsideClass = true;
2676         if (isGetter || isSetter) {
2677             bool isClassProperty = true;
2678             property = parseGetterSetter(context, alwaysStrictInsideClass, isGetter ? PropertyNode::Getter : PropertyNode::Setter, methodStart,
2679                 ConstructorKind::None, isClassProperty);
2680             failIfFalse(property, "Cannot parse this method");
2681         } else {
2682             ParserFunctionInfo<TreeBuilder> methodInfo;
2683             bool isConstructor = !isStaticMethod && *ident == propertyNames.constructor;
2684             SourceParseMode parseMode = SourceParseMode::MethodMode;
2685             if (isAsyncMethod) {
2686                 isConstructor = false;
2687                 parseMode = SourceParseMode::AsyncMethodMode;
2688                 semanticFailIfTrue(*ident == m_vm->propertyNames->prototype, "Cannot declare an async method named 'prototype'");
2689                 semanticFailIfTrue(*ident == m_vm->propertyNames->constructor, "Cannot declare an async method named 'constructor'");
2690             } else if (isGenerator) {
2691                 isConstructor = false;
2692                 parseMode = SourceParseMode::GeneratorWrapperFunctionMode;
2693                 semanticFailIfTrue(*ident == m_vm->propertyNames->prototype, "Cannot declare a generator named 'prototype'");
2694                 semanticFailIfTrue(*ident == m_vm->propertyNames->constructor, "Cannot declare a generator named 'constructor'");
2695             }
2696             methodInfo.name = isConstructor ? info.className : ident;
2697             failIfFalse((parseFunctionInfo(context, FunctionNameRequirements::Unnamed, parseMode, false, isConstructor ? constructorKind : ConstructorKind::None, SuperBinding::Needed, methodStart, methodInfo, FunctionDefinitionType::Method)), "Cannot parse this method");
2698
2699             TreeExpression method = context.createMethodDefinition(methodLocation, methodInfo);
2700             if (isConstructor) {
2701                 semanticFailIfTrue(constructor, "Cannot declare multiple constructors in a single class");
2702                 constructor = method;
2703                 continue;
2704             }
2705
2706             // FIXME: Syntax error when super() is called
2707             semanticFailIfTrue(isStaticMethod && methodInfo.name && *methodInfo.name == propertyNames.prototype,
2708                 "Cannot declare a static method named 'prototype'");
2709
2710             bool isClassProperty = true;
2711             if (computedPropertyName) {
2712                 property = context.createProperty(computedPropertyName, method, static_cast<PropertyNode::Type>(PropertyNode::Constant | PropertyNode::Computed),
2713                     PropertyNode::Unknown, alwaysStrictInsideClass, SuperBinding::Needed, isClassProperty);
2714             } else
2715                 property = context.createProperty(methodInfo.name, method, PropertyNode::Constant, PropertyNode::Unknown, alwaysStrictInsideClass, SuperBinding::Needed, InferName::Allowed, isClassProperty);
2716         }
2717
2718         TreePropertyList& tail = isStaticMethod ? staticMethodsTail : instanceMethodsTail;
2719         if (tail)
2720             tail = context.createPropertyList(methodLocation, property, tail);
2721         else {
2722             tail = context.createPropertyList(methodLocation, property);
2723             if (isStaticMethod)
2724                 staticMethods = tail;
2725             else
2726                 instanceMethods = tail;
2727         }
2728     }
2729
2730     info.endOffset = tokenLocation().endOffset - 1;
2731     consumeOrFail(CLOSEBRACE, "Expected a closing '}' after a class body");
2732
2733     auto classExpression = context.createClassExpr(location, info, classScope->finalizeLexicalEnvironment(), constructor, parentClass, instanceMethods, staticMethods);
2734     popScope(classScope, TreeBuilder::NeedsFreeVariableInfo);
2735     return classExpression;
2736 }
2737
2738 struct LabelInfo {
2739     LabelInfo(const Identifier* ident, const JSTextPosition& start, const JSTextPosition& end)
2740     : m_ident(ident)
2741     , m_start(start)
2742     , m_end(end)
2743     {
2744     }
2745     
2746     const Identifier* m_ident;
2747     JSTextPosition m_start;
2748     JSTextPosition m_end;
2749 };
2750
2751 template <typename LexerType>
2752 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrLabelStatement(TreeBuilder& context, bool allowFunctionDeclarationAsStatement)
2753 {
2754     
2755     /* Expression and Label statements are ambiguous at LL(1), so we have a
2756      * special case that looks for a colon as the next character in the input.
2757      */
2758     Vector<LabelInfo> labels;
2759     JSTokenLocation location;
2760     do {
2761         JSTextPosition start = tokenStartPosition();
2762         location = tokenLocation();
2763         if (!nextTokenIsColon()) {
2764             // If we hit this path we're making a expression statement, which
2765             // by definition can't make use of continue/break so we can just
2766             // ignore any labels we might have accumulated.
2767             TreeExpression expression = parseExpression(context);
2768             failIfFalse(expression, "Cannot parse expression statement");
2769             if (!autoSemiColon())
2770                 failDueToUnexpectedToken();
2771             return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
2772         }
2773
2774         if (UNLIKELY(match(AWAIT)))
2775             semanticFailIfTrue(isDisallowedIdentifierAwait(m_token), "Can't use 'await' as a label ", disallowedIdentifierAwaitReason());
2776
2777         const Identifier* ident = m_token.m_data.ident;
2778         JSTextPosition end = tokenEndPosition();
2779         next();
2780         consumeOrFail(COLON, "Labels must be followed by a ':'");
2781         if (!m_syntaxAlreadyValidated) {
2782             // This is O(N^2) over the current list of consecutive labels, but I
2783             // have never seen more than one label in a row in the real world.
2784             for (size_t i = 0; i < labels.size(); i++)
2785                 failIfTrue(ident->impl() == labels[i].m_ident->impl(), "Attempted to redeclare the label '", ident->impl(), "'");
2786             failIfTrue(getLabel(ident), "Cannot find scope for the label '", ident->impl(), "'");
2787             labels.append(LabelInfo(ident, start, end));
2788         }
2789     } while (matchSpecIdentifier());
2790     bool isLoop = false;
2791     switch (m_token.m_type) {
2792     case FOR:
2793     case WHILE:
2794     case DO:
2795         isLoop = true;
2796         break;
2797         
2798     default:
2799         break;
2800     }
2801     const Identifier* unused = 0;
2802     ScopeRef labelScope = currentScope();
2803     if (!m_syntaxAlreadyValidated) {
2804         for (size_t i = 0; i < labels.size(); i++)
2805             pushLabel(labels[i].m_ident, isLoop);
2806     }
2807     m_immediateParentAllowsFunctionDeclarationInStatement = allowFunctionDeclarationAsStatement;
2808     TreeStatement statement = parseStatement(context, unused);
2809     if (!m_syntaxAlreadyValidated) {
2810         for (size_t i = 0; i < labels.size(); i++)
2811             popLabel(labelScope);
2812     }
2813     failIfFalse(statement, "Cannot parse statement");
2814     for (size_t i = 0; i < labels.size(); i++) {
2815         const LabelInfo& info = labels[labels.size() - i - 1];
2816         statement = context.createLabelStatement(location, info.m_ident, statement, info.m_start, info.m_end);
2817     }
2818     return statement;
2819 }
2820
2821 template <typename LexerType>
2822 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionStatement(TreeBuilder& context)
2823 {
2824     switch (m_token.m_type) {
2825     // Consult: http://www.ecma-international.org/ecma-262/6.0/index.html#sec-expression-statement
2826     // The ES6 spec mandates that we should fail from FUNCTION token here. We handle this case 
2827     // in parseStatement() which is the only caller of parseExpressionStatement().
2828     // We actually allow FUNCTION in situations where it should not be allowed unless we're in strict mode.
2829     case CLASSTOKEN:
2830         failWithMessage("'class' declaration is not directly within a block statement");
2831         break;
2832     default:
2833         // FIXME: when implementing 'let' we should fail when we see the token sequence "let [".
2834         // https://bugs.webkit.org/show_bug.cgi?id=142944
2835         break;
2836     }
2837     JSTextPosition start = tokenStartPosition();
2838     JSTokenLocation location(tokenLocation());
2839     TreeExpression expression = parseExpression(context);
2840     failIfFalse(expression, "Cannot parse expression statement");
2841     failIfFalse(autoSemiColon(), "Parse error");
2842     return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
2843 }
2844
2845 template <typename LexerType>
2846 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(TreeBuilder& context)
2847 {
2848     ASSERT(match(IF));
2849     JSTokenLocation ifLocation(tokenLocation());
2850     int start = tokenLine();
2851     next();
2852     handleProductionOrFail2(OPENPAREN, "(", "start", "'if' condition");
2853
2854     TreeExpression condition = parseExpression(context);
2855     failIfFalse(condition, "Expected a expression as the condition for an if statement");
2856     recordPauseLocation(context.breakpointLocation(condition));
2857     int end = tokenLine();
2858     handleProductionOrFail2(CLOSEPAREN, ")", "end", "'if' condition");
2859
2860     const Identifier* unused = 0;
2861     m_immediateParentAllowsFunctionDeclarationInStatement = true;
2862     TreeStatement trueBlock = parseStatement(context, unused);
2863     failIfFalse(trueBlock, "Expected a statement as the body of an if block");
2864
2865     if (!match(ELSE))
2866         return context.createIfStatement(ifLocation, condition, trueBlock, 0, start, end);
2867
2868     Vector<TreeExpression> exprStack;
2869     Vector<std::pair<int, int>> posStack;
2870     Vector<JSTokenLocation> tokenLocationStack;
2871     Vector<TreeStatement> statementStack;
2872     bool trailingElse = false;
2873     do {
2874         JSTokenLocation tempLocation = tokenLocation();
2875         next();
2876         if (!match(IF)) {
2877             const Identifier* unused = 0;
2878             m_immediateParentAllowsFunctionDeclarationInStatement = true;
2879             TreeStatement block = parseStatement(context, unused);
2880             failIfFalse(block, "Expected a statement as the body of an else block");
2881             statementStack.append(block);
2882             trailingElse = true;
2883             break;
2884         }
2885         int innerStart = tokenLine();
2886         next();
2887         
2888         handleProductionOrFail2(OPENPAREN, "(", "start", "'if' condition");
2889
2890         TreeExpression innerCondition = parseExpression(context);
2891         failIfFalse(innerCondition, "Expected a expression as the condition for an if statement");
2892         recordPauseLocation(context.breakpointLocation(innerCondition));
2893         int innerEnd = tokenLine();
2894         handleProductionOrFail2(CLOSEPAREN, ")", "end", "'if' condition");
2895         const Identifier* unused = 0;
2896         m_immediateParentAllowsFunctionDeclarationInStatement = true;
2897         TreeStatement innerTrueBlock = parseStatement(context, unused);
2898         failIfFalse(innerTrueBlock, "Expected a statement as the body of an if block");
2899         tokenLocationStack.append(tempLocation);
2900         exprStack.append(innerCondition);
2901         posStack.append(std::make_pair(innerStart, innerEnd));
2902         statementStack.append(innerTrueBlock);
2903     } while (match(ELSE));
2904
2905     if (!trailingElse) {
2906         TreeExpression condition = exprStack.last();
2907         exprStack.removeLast();
2908         TreeStatement trueBlock = statementStack.last();
2909         statementStack.removeLast();
2910         std::pair<int, int> pos = posStack.last();
2911         posStack.removeLast();
2912         JSTokenLocation elseLocation = tokenLocationStack.last();
2913         tokenLocationStack.removeLast();
2914         TreeStatement ifStatement = context.createIfStatement(elseLocation, condition, trueBlock, 0, pos.first, pos.second);
2915         context.setEndOffset(ifStatement, context.endOffset(trueBlock));
2916         statementStack.append(ifStatement);
2917     }
2918
2919     while (!exprStack.isEmpty()) {
2920         TreeExpression condition = exprStack.last();
2921         exprStack.removeLast();
2922         TreeStatement falseBlock = statementStack.last();
2923         statementStack.removeLast();
2924         TreeStatement trueBlock = statementStack.last();
2925         statementStack.removeLast();
2926         std::pair<int, int> pos = posStack.last();
2927         posStack.removeLast();
2928         JSTokenLocation elseLocation = tokenLocationStack.last();
2929         tokenLocationStack.removeLast();
2930         TreeStatement ifStatement = context.createIfStatement(elseLocation, condition, trueBlock, falseBlock, pos.first, pos.second);
2931         context.setEndOffset(ifStatement, context.endOffset(falseBlock));
2932         statementStack.append(ifStatement);
2933     }
2934
2935     return context.createIfStatement(ifLocation, condition, trueBlock, statementStack.last(), start, end);
2936 }
2937
2938 template <typename LexerType>
2939 template <class TreeBuilder> typename TreeBuilder::ModuleName Parser<LexerType>::parseModuleName(TreeBuilder& context)
2940 {
2941     // ModuleName (ModuleSpecifier in the spec) represents the module name imported by the script.
2942     // http://www.ecma-international.org/ecma-262/6.0/#sec-imports
2943     // http://www.ecma-international.org/ecma-262/6.0/#sec-exports
2944     JSTokenLocation specifierLocation(tokenLocation());
2945     failIfFalse(match(STRING), "Imported modules names must be string literals");
2946     const Identifier* moduleName = m_token.m_data.ident;
2947     next();
2948     return context.createModuleName(specifierLocation, *moduleName);
2949 }
2950
2951 template <typename LexerType>
2952 template <class TreeBuilder> typename TreeBuilder::ImportSpecifier Parser<LexerType>::parseImportClauseItem(TreeBuilder& context, ImportSpecifierType specifierType)
2953 {
2954     // Produced node is the item of the ImportClause.
2955     // That is the ImportSpecifier, ImportedDefaultBinding or NameSpaceImport.
2956     // http://www.ecma-international.org/ecma-262/6.0/#sec-imports
2957     JSTokenLocation specifierLocation(tokenLocation());
2958     JSToken localNameToken;
2959     const Identifier* importedName = nullptr;
2960     const Identifier* localName = nullptr;
2961
2962     switch (specifierType) {
2963     case ImportSpecifierType::NamespaceImport: {
2964         // NameSpaceImport :
2965         // * as ImportedBinding
2966         // e.g.
2967         //     * as namespace
2968         ASSERT(match(TIMES));
2969         importedName = &m_vm->propertyNames->timesIdentifier;
2970         next();
2971
2972         failIfFalse(matchContextualKeyword(m_vm->propertyNames->as), "Expected 'as' before imported binding name");
2973         next();
2974
2975         failIfFalse(matchSpecIdentifier(), "Expected a variable name for the import declaration");
2976         localNameToken = m_token;
2977         localName = m_token.m_data.ident;
2978         next();
2979         break;
2980     }
2981
2982     case ImportSpecifierType::NamedImport: {
2983         // ImportSpecifier :
2984         // ImportedBinding
2985         // IdentifierName as ImportedBinding
2986         // e.g.
2987         //     A
2988         //     A as B
2989         ASSERT(matchIdentifierOrKeyword());
2990         localNameToken = m_token;
2991         localName = m_token.m_data.ident;
2992         importedName = localName;
2993         next();
2994
2995         if (matchContextualKeyword(m_vm->propertyNames->as)) {
2996             next();
2997             failIfFalse(matchSpecIdentifier(), "Expected a variable name for the import declaration");
2998             localNameToken = m_token;
2999             localName = m_token.m_data.ident;
3000             next();
3001         }
3002         break;
3003     }
3004
3005     case ImportSpecifierType::DefaultImport: {
3006         // ImportedDefaultBinding :
3007         // ImportedBinding
3008         ASSERT(matchSpecIdentifier());
3009         localNameToken = m_token;
3010         localName = m_token.m_data.ident;
3011         importedName = &m_vm->propertyNames->defaultKeyword;
3012         next();
3013         break;
3014     }
3015     }
3016
3017     semanticFailIfTrue(localNameToken.m_type == AWAIT, "Cannot use 'await' as an imported binding name");
3018     semanticFailIfTrue(localNameToken.m_type & KeywordTokenFlag, "Cannot use keyword as imported binding name");
3019     DeclarationResultMask declarationResult = declareVariable(localName, DeclarationType::ConstDeclaration, (specifierType == ImportSpecifierType::NamespaceImport) ? DeclarationImportType::ImportedNamespace : DeclarationImportType::Imported);
3020     if (declarationResult != DeclarationResult::Valid) {
3021         failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare an imported binding named ", localName->impl(), " in strict mode");
3022         if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration)
3023             internalFailWithMessage(false, "Cannot declare an imported binding name twice: '", localName->impl(), "'");
3024     }
3025
3026     return context.createImportSpecifier(specifierLocation, *importedName, *localName);
3027 }
3028
3029 template <typename LexerType>
3030 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseImportDeclaration(TreeBuilder& context)
3031 {
3032     // http://www.ecma-international.org/ecma-262/6.0/#sec-imports
3033     ASSERT(match(IMPORT));
3034     JSTokenLocation importLocation(tokenLocation());
3035     next();
3036
3037     auto specifierList = context.createImportSpecifierList();
3038
3039     if (match(STRING)) {
3040         // import ModuleSpecifier ;
3041         auto moduleName = parseModuleName(context);
3042         failIfFalse(moduleName, "Cannot parse the module name");
3043         failIfFalse(autoSemiColon(), "Expected a ';' following a targeted import declaration");
3044         return context.createImportDeclaration(importLocation, specifierList, moduleName);
3045     }
3046
3047     bool isFinishedParsingImport = false;
3048     if (matchSpecIdentifier()) {
3049         // ImportedDefaultBinding :
3050         // ImportedBinding
3051         auto specifier = parseImportClauseItem(context, ImportSpecifierType::DefaultImport);
3052         failIfFalse(specifier, "Cannot parse the default import");
3053         context.appendImportSpecifier(specifierList, specifier);
3054         if (match(COMMA))
3055             next();
3056         else
3057             isFinishedParsingImport = true;
3058     }
3059
3060     if (!isFinishedParsingImport) {
3061         if (match(TIMES)) {
3062             // import NameSpaceImport FromClause ;
3063             auto specifier = parseImportClauseItem(context, ImportSpecifierType::NamespaceImport);
3064             failIfFalse(specifier, "Cannot parse the namespace import");
3065             context.appendImportSpecifier(specifierList, specifier);
3066         } else if (match(OPENBRACE)) {
3067             // NamedImports :
3068             // { }
3069             // { ImportsList }
3070             // { ImportsList , }
3071             next();
3072
3073             while (!match(CLOSEBRACE)) {
3074                 failIfFalse(matchIdentifierOrKeyword(), "Expected an imported name for the import declaration");
3075                 auto specifier = parseImportClauseItem(context, ImportSpecifierType::NamedImport);
3076                 failIfFalse(specifier, "Cannot parse the named import");
3077                 context.appendImportSpecifier(specifierList, specifier);
3078                 if (!consume(COMMA))
3079                     break;
3080             }
3081             handleProductionOrFail2(CLOSEBRACE, "}", "end", "import list");
3082         } else
3083             failWithMessage("Expected namespace import or import list");
3084     }
3085
3086     // FromClause :
3087     // from ModuleSpecifier
3088
3089     failIfFalse(matchContextualKeyword(m_vm->propertyNames->from), "Expected 'from' before imported module name");
3090     next();
3091
3092     auto moduleName = parseModuleName(context);
3093     failIfFalse(moduleName, "Cannot parse the module name");
3094     failIfFalse(autoSemiColon(), "Expected a ';' following a targeted import declaration");
3095
3096     return context.createImportDeclaration(importLocation, specifierList, moduleName);
3097 }
3098
3099 template <typename LexerType>
3100 template <class TreeBuilder> typename TreeBuilder::ExportSpecifier Parser<LexerType>::parseExportSpecifier(TreeBuilder& context, Vector<std::pair<const Identifier*, const Identifier*>>& maybeExportedLocalNames, bool& hasKeywordForLocalBindings)
3101 {
3102     // ExportSpecifier :
3103     // IdentifierName
3104     // IdentifierName as IdentifierName
3105     // http://www.ecma-international.org/ecma-262/6.0/#sec-exports
3106     ASSERT(matchIdentifierOrKeyword());
3107     JSTokenLocation specifierLocation(tokenLocation());
3108     if (m_token.m_type & KeywordTokenFlag)
3109         hasKeywordForLocalBindings = true;
3110     const Identifier* localName = m_token.m_data.ident;
3111     const Identifier* exportedName = localName;
3112     next();
3113
3114     if (matchContextualKeyword(m_vm->propertyNames->as)) {
3115         next();
3116         failIfFalse(matchIdentifierOrKeyword(), "Expected an exported name for the export declaration");
3117         exportedName = m_token.m_data.ident;
3118         next();
3119     }
3120
3121     semanticFailIfFalse(exportName(*exportedName), "Cannot export a duplicate name '", exportedName->impl(), "'");
3122     maybeExportedLocalNames.append(std::make_pair(localName, exportedName));
3123     return context.createExportSpecifier(specifierLocation, *localName, *exportedName);
3124 }
3125
3126 template <typename LexerType>
3127 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExportDeclaration(TreeBuilder& context)
3128 {
3129     // http://www.ecma-international.org/ecma-262/6.0/#sec-exports
3130     ASSERT(match(EXPORT));
3131     JSTokenLocation exportLocation(tokenLocation());
3132     next();
3133
3134     switch (m_token.m_type) {
3135     case TIMES: {
3136         // export * FromClause ;
3137         next();
3138
3139         failIfFalse(matchContextualKeyword(m_vm->propertyNames->from), "Expected 'from' before exported module name");
3140         next();
3141         auto moduleName = parseModuleName(context);
3142         failIfFalse(moduleName, "Cannot parse the 'from' clause");
3143         failIfFalse(autoSemiColon(), "Expected a ';' following a targeted export declaration");
3144
3145         return context.createExportAllDeclaration(exportLocation, moduleName);
3146     }
3147
3148     case DEFAULT: {
3149         // export default HoistableDeclaration[Default]
3150         // export default ClassDeclaration[Default]
3151         // export default [lookahead not-in {function, class}] AssignmentExpression[In] ;
3152
3153         next();
3154
3155         TreeStatement result = 0;
3156         bool isFunctionOrClassDeclaration = false;
3157         const Identifier* localName = nullptr;
3158
3159         bool startsWithFunction = match(FUNCTION);
3160         if (startsWithFunction || match(CLASSTOKEN)) {
3161             SavePoint savePoint = createSavePoint();
3162             isFunctionOrClassDeclaration = true;
3163             next();
3164
3165             // ES6 Generators
3166             if (startsWithFunction && match(TIMES))
3167                 next();
3168             if (match(IDENT))
3169                 localName = m_token.m_data.ident;
3170             restoreSavePoint(savePoint);
3171         } else if (match(ASYNC)) {
3172             SavePoint savePoint = createSavePoint();
3173             next();
3174             if (match(FUNCTION) && !m_lexer->prevTerminator()) {
3175                 next();
3176                 if (match(IDENT))
3177                     localName = m_token.m_data.ident;
3178                 isFunctionOrClassDeclaration = true;
3179             }
3180             restoreSavePoint(savePoint);
3181         }
3182
3183         if (!localName)
3184             localName = &m_vm->propertyNames->builtinNames().starDefaultPrivateName();
3185
3186         if (isFunctionOrClassDeclaration) {
3187             if (startsWithFunction) {
3188                 ASSERT(match(FUNCTION));
3189                 DepthManager statementDepth(&m_statementDepth);
3190                 m_statementDepth = 1;
3191                 result = parseFunctionDeclaration(context, ExportType::NotExported, DeclarationDefaultContext::ExportDefault);
3192             } else if (match(CLASSTOKEN)) {
3193                 result = parseClassDeclaration(context, ExportType::NotExported, DeclarationDefaultContext::ExportDefault);
3194             } else {
3195                 ASSERT(match(ASYNC));
3196                 next();
3197                 DepthManager statementDepth(&m_statementDepth);
3198                 m_statementDepth = 1;
3199                 result = parseAsyncFunctionDeclaration(context, ExportType::NotExported, DeclarationDefaultContext::ExportDefault);
3200             }
3201         } else {
3202             // export default expr;
3203             //
3204             // It should be treated as the same to the following.
3205             //
3206             // const *default* = expr;
3207             // export { *default* as default }
3208             //
3209             // In the above example, *default* is the invisible variable to the users.
3210             // We use the private symbol to represent the name of this variable.
3211             JSTokenLocation location(tokenLocation());
3212             JSTextPosition start = tokenStartPosition();
3213             TreeExpression expression = parseAssignmentExpression(context);
3214             failIfFalse(expression, "Cannot parse expression");
3215
3216             DeclarationResultMask declarationResult = declareVariable(&m_vm->propertyNames->builtinNames().starDefaultPrivateName(), DeclarationType::ConstDeclaration);
3217             if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration)
3218                 internalFailWithMessage(false, "Only one 'default' export is allowed");
3219
3220             TreeExpression assignment = context.createAssignResolve(location, m_vm->propertyNames->builtinNames().starDefaultPrivateName(), expression, start, start, tokenEndPosition(), AssignmentContext::ConstDeclarationStatement);
3221             result = context.createExprStatement(location, assignment, start, tokenEndPosition());
3222             failIfFalse(autoSemiColon(), "Expected a ';' following a targeted export declaration");
3223         }
3224         failIfFalse(result, "Cannot parse the declaration");
3225
3226         semanticFailIfFalse(exportName(m_vm->propertyNames->defaultKeyword), "Only one 'default' export is allowed");
3227         m_moduleScopeData->exportBinding(*localName, m_vm->propertyNames->defaultKeyword);
3228         return context.createExportDefaultDeclaration(exportLocation, result, *localName);
3229     }
3230
3231     case OPENBRACE: {
3232         // export ExportClause FromClause ;
3233         // export ExportClause ;
3234         //
3235         // ExportClause :
3236         // { }
3237         // { ExportsList }
3238         // { ExportsList , }
3239         //
3240         // ExportsList :
3241         // ExportSpecifier
3242         // ExportsList , ExportSpecifier
3243
3244         next();
3245
3246         auto specifierList = context.createExportSpecifierList();
3247         Vector<std::pair<const Identifier*, const Identifier*>> maybeExportedLocalNames;
3248
3249         bool hasKeywordForLocalBindings = false;
3250         while (!match(CLOSEBRACE)) {
3251             failIfFalse(matchIdentifierOrKeyword(), "Expected a variable name for the export declaration");
3252             auto specifier = parseExportSpecifier(context, maybeExportedLocalNames, hasKeywordForLocalBindings);
3253             failIfFalse(specifier, "Cannot parse the named export");
3254             context.appendExportSpecifier(specifierList, specifier);
3255             if (!consume(COMMA))
3256                 break;
3257         }
3258         handleProductionOrFail2(CLOSEBRACE, "}", "end", "export list");
3259
3260         typename TreeBuilder::ModuleName moduleName = 0;
3261         if (matchContextualKeyword(m_vm->propertyNames->from)) {
3262             next();
3263             moduleName = parseModuleName(context);
3264             failIfFalse(moduleName, "Cannot parse the 'from' clause");
3265         }
3266         failIfFalse(autoSemiColon(), "Expected a ';' following a targeted export declaration");
3267
3268         if (!moduleName) {
3269             semanticFailIfTrue(hasKeywordForLocalBindings, "Cannot use keyword as exported variable name");
3270             // Since this export declaration does not have module specifier part, it exports the local bindings.
3271             // While the export declaration with module specifier does not have any effect on the current module's scope,
3272             // the export named declaration without module specifier references the the local binding names.
3273             // For example,
3274             //   export { A, B, C as D } from "mod"
3275             // does not have effect on the current module's scope. But,
3276             //   export { A, B, C as D }
3277             // will reference the current module's bindings.
3278             for (const auto& pair : maybeExportedLocalNames) {
3279                 const Identifier* localName = pair.first;
3280                 const Identifier* exportedName = pair.second;
3281                 m_moduleScopeData->exportBinding(*localName, *exportedName);
3282             }
3283         }
3284
3285         return context.createExportNamedDeclaration(exportLocation, specifierList, moduleName);
3286     }
3287
3288     default: {
3289         // export VariableStatement
3290         // export Declaration
3291         TreeStatement result = 0;
3292         switch (m_token.m_type) {
3293         case VAR:
3294             result = parseVariableDeclaration(context, DeclarationType::VarDeclaration, ExportType::Exported);
3295             break;
3296
3297         case CONSTTOKEN:
3298             result = parseVariableDeclaration(context, DeclarationType::ConstDeclaration, ExportType::Exported);
3299             break;
3300
3301         case LET:
3302             result = parseVariableDeclaration(context, DeclarationType::LetDeclaration, ExportType::Exported);
3303             break;
3304
3305         case FUNCTION: {
3306             DepthManager statementDepth(&m_statementDepth);
3307             m_statementDepth = 1;
3308             result = parseFunctionDeclaration(context, ExportType::Exported);
3309             break;
3310         }
3311
3312         case CLASSTOKEN:
3313             result = parseClassDeclaration(context, ExportType::Exported);
3314             break;
3315
3316         case ASYNC:
3317             next();
3318             semanticFailIfFalse(match(FUNCTION) && !m_lexer->prevTerminator(), "Expected 'function' keyword following 'async' keyword with no preceding line terminator");
3319             result = parseAsyncFunctionDeclaration(context, ExportType::Exported);
3320             break;
3321
3322         default:
3323             failWithMessage("Expected either a declaration or a variable statement");
3324             break;
3325         }
3326
3327         failIfFalse(result, "Cannot parse the declaration");
3328         return context.createExportLocalDeclaration(exportLocation, result);
3329     }
3330     }
3331
3332     RELEASE_ASSERT_NOT_REACHED();
3333     return 0;
3334 }
3335
3336 template <typename LexerType>
3337 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseExpression(TreeBuilder& context)
3338 {
3339     failIfStackOverflow();
3340     JSTokenLocation location(tokenLocation());
3341     TreeExpression node = parseAssignmentExpression(context);
3342     failIfFalse(node, "Cannot parse expression");
3343     context.setEndOffset(node, m_lastTokenEndPosition.offset);
3344     if (!match(COMMA))
3345         return node;
3346     next();
3347     m_parserState.nonTrivialExpressionCount++;
3348     m_parserState.nonLHSCount++;
3349     TreeExpression right = parseAssignmentExpression(context);
3350     failIfFalse(right, "Cannot parse expression in a comma expression");
3351     context.setEndOffset(right, m_lastTokenEndPosition.offset);
3352     typename TreeBuilder::Comma head = context.createCommaExpr(location, node);
3353     typename TreeBuilder::Comma tail = context.appendToCommaExpr(location, head, head, right);
3354     while (match(COMMA)) {
3355         next(TreeBuilder::DontBuildStrings);
3356         right = parseAssignmentExpression(context);
3357         failIfFalse(right, "Cannot parse expression in a comma expression");
3358         context.setEndOffset(right, m_lastTokenEndPosition.offset);
3359         tail = context.appendToCommaExpr(location, head, tail, right);
3360     }
3361     context.setEndOffset(head, m_lastTokenEndPosition.offset);
3362     return head;
3363 }
3364
3365 template <typename LexerType>
3366 template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpressionOrPropagateErrorClass(TreeBuilder& context)
3367 {
3368     ExpressionErrorClassifier classifier(this);
3369     auto assignment = parseAssignmentExpression(context, classifier);
3370     if (!assignment)
3371         classifier.propagateExpressionErrorClass();
3372     return assignment;
3373 }
3374
3375 template <typename LexerType>
3376 template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpression(TreeBuilder& context)
3377 {
3378     ExpressionErrorClassifier classifier(this);
3379     return parseAssignmentExpression(context, classifier);
3380 }
3381     
3382 template <typename LexerType>
3383 template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpression(TreeBuilder& context, ExpressionErrorClassifier& classifier)
3384 {
3385     ASSERT(!hasError());
3386     
3387     failIfStackOverflow();
3388
3389     if (match(YIELD) && !isYIELDMaskedAsIDENT(currentScope()->isGenerator()))
3390         return parseYieldExpression(context);
3391
3392     JSTextPosition start = tokenStartPosition();
3393     JSTokenLocation location(tokenLocation());
3394     int initialAssignmentCount = m_parserState.assignmentCount;
3395     int initialNonLHSCount = m_parserState.nonLHSCount;
3396     bool maybeAssignmentPattern = match(OPENBRACE) || match(OPENBRACKET);
3397     bool wasOpenParen = match(OPENPAREN);
3398     // Do not use matchSpecIdentifier() here since it is slower than isIdentifierOrKeyword.
3399     // Whether spec identifier is will be validated by isArrowFunctionParameters().
3400     bool wasIdentifierOrKeyword = isIdentifierOrKeyword(m_token);
3401     bool maybeValidArrowFunctionStart = wasOpenParen || wasIdentifierOrKeyword;
3402     SavePoint savePoint = createSavePoint();
3403     size_t usedVariablesSize = 0;
3404
3405     if (wasOpenParen) {
3406         usedVariablesSize = currentScope()->currentUsedVariablesSize();
3407         currentScope()->pushUsedVariableSet();
3408     }
3409
3410     TreeExpression lhs = parseConditionalExpression(context);
3411
3412     if (maybeValidArrowFunctionStart && !match(EOFTOK)) {
3413         bool isArrowFunctionToken = match(ARROWFUNCTION);
3414         if (!lhs || isArrowFunctionToken) {
3415             SavePointWithError errorRestorationSavePoint = createSavePointForError();
3416             restoreSavePoint(savePoint);
3417             bool isAsyncArrow = false;
3418             if (UNLIKELY(classifier.indicatesPossibleAsyncArrowFunction())) {
3419                 ASSERT(match(ASYNC));
3420                 next();
3421                 isAsyncArrow = !m_lexer->prevTerminator();
3422             }
3423             if (isArrowFunctionParameters()) {
3424                 if (wasOpenParen)
3425                     currentScope()->revertToPreviousUsedVariables(usedVariablesSize);
3426                 return parseArrowFunctionExpression(context, isAsyncArrow);
3427             }
3428             if (isArrowFunctionToken)
3429                 propagateError();
3430             restoreSavePointWithError(errorRestorationSavePoint);
3431             if (isArrowFunctionToken)
3432                 failDueToUnexpectedToken();
3433         }
3434     }
3435
3436     if (!lhs && (!maybeAssignmentPattern || !classifier.indicatesPossiblePattern()))
3437         propagateError();
3438
3439     if (maybeAssignmentPattern && (!lhs || (context.isObjectOrArrayLiteral(lhs) && match(EQUAL)))) {
3440         SavePointWithError expressionErrorLocation = createSavePointForError();
3441         restoreSavePoint(savePoint);
3442         auto pattern = tryParseDestructuringPatternExpression(context, AssignmentContext::AssignmentExpression);
3443         if (classifier.indicatesPossiblePattern() && (!pattern || !match(EQUAL))) {
3444             restoreSavePointWithError(expressionErrorLocation);
3445             return 0;
3446         }
3447         failIfFalse(pattern, "Cannot parse assignment pattern");
3448         consumeOrFail(EQUAL, "Expected '=' following assignment pattern");
3449         auto rhs = parseAssignmentExpression(context);
3450         if (!rhs)
3451             propagateError();
3452         return context.createDestructuringAssignment(location, pattern, rhs);
3453     }
3454
3455     failIfFalse(lhs, "Cannot parse expression");
3456     if (initialNonLHSCount != m_parserState.nonLHSCount) {
3457         if (m_token.m_type >= EQUAL && m_token.m_type <= OREQUAL)
3458             semanticFail("Left hand side of operator '", getToken(), "' must be a reference");
3459
3460         return lhs;
3461     }
3462     
3463     int assignmentStack = 0;
3464     Operator op;
3465     bool hadAssignment = false;
3466     while (true) {
3467         switch (m_token.m_type) {
3468         case EQUAL: op = OpEqual; break;
3469         case PLUSEQUAL: op = OpPlusEq; break;
3470         case MINUSEQUAL: op = OpMinusEq; break;
3471         case MULTEQUAL: op = OpMultEq; break;
3472         case DIVEQUAL: op = OpDivEq; break;
3473         case LSHIFTEQUAL: op = OpLShift; break;
3474         case RSHIFTEQUAL: op = OpRShift; break;
3475         case URSHIFTEQUAL: op = OpURShift; break;
3476         case ANDEQUAL: op = OpAndEq; break;
3477         case XOREQUAL: op = OpXOrEq; break;
3478         case OREQUAL: op = OpOrEq; break;
3479         case MODEQUAL: op = OpModEq; break;
3480         case POWEQUAL: op = OpPowEq; break;
3481         default:
3482             goto end;
3483         }
3484         m_parserState.nonTrivialExpressionCount++;
3485         hadAssignment = true;
3486         if (UNLIKELY(context.isNewTarget(lhs)))
3487             internalFailWithMessage(false, "new.target can't be the left hand side of an assignment expression");
3488         context.assignmentStackAppend(assignmentStack, lhs, start, tokenStartPosition(), m_parserState.assignmentCount, op);
3489         start = tokenStartPosition();
3490         m_parserState.assignmentCount++;
3491         next(TreeBuilder::DontBuildStrings);
3492         if (strictMode() && m_parserState.lastIdentifier && context.isResolve(lhs)) {
3493             failIfTrueIfStrict(m_vm->propertyNames->eval == *m_parserState.lastIdentifier, "Cannot modify 'eval' in strict mode");
3494             failIfTrueIfStrict(m_vm->propertyNames->arguments == *m_parserState.lastIdentifier, "Cannot modify 'arguments' in strict mode");
3495             m_parserState.lastIdentifier = 0;
3496         }
3497         lhs = parseAssignmentExpression(context);
3498         failIfFalse(lhs, "Cannot parse the right hand side of an assignment expression");
3499         if (initialNonLHSCount != m_parserState.nonLHSCount) {
3500             if (m_token.m_type >= EQUAL && m_token.m_type <= OREQUAL)
3501                 semanticFail("Left hand side of operator '", getToken(), "' must be a reference");
3502             break;
3503         }
3504     }
3505 end:
3506     if (hadAssignment)
3507         m_parserState.nonLHSCount++;
3508     
3509     if (!TreeBuilder::CreatesAST)
3510         return lhs;
3511     
3512     while (assignmentStack)
3513         lhs = context.createAssignment(location, assignmentStack, lhs, initialAssignmentCount, m_parserState.assignmentCount, lastTokenEndPosition());
3514     
3515     return lhs;
3516 }
3517
3518 template <typename LexerType>
3519 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseYieldExpression(TreeBuilder& context)
3520 {
3521     // YieldExpression[In] :
3522     //     yield
3523     //     yield [no LineTerminator here] AssignmentExpression[?In, Yield]
3524     //     yield [no LineTerminator here] * AssignmentExpression[?In, Yield]
3525
3526     // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions
3527     failIfFalse(currentScope()->isGenerator() && !currentScope()->isArrowFunctionBoundary(), "Cannot use yield expression out of generator");
3528
3529     // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors
3530     failIfTrue(m_parserState.functionParsePhase == FunctionParsePhase::Parameters, "Cannot use yield expression within parameters");
3531
3532     JSTokenLocation location(tokenLocation());
3533     JSTextPosition divotStart = tokenStartPosition();
3534     ASSERT(match(YIELD));
3535     SavePoint savePoint = createSavePoint();
3536     next();
3537     if (m_lexer->prevTerminator())
3538         return context.createYield(location);
3539
3540     bool delegate = consume(TIMES);
3541     JSTextPosition argumentStart = tokenStartPosition();
3542     TreeExpression argument = parseAssignmentExpression(context);
3543     if (!argument) {
3544         restoreSavePoint(savePoint);
3545         next();
3546         return context.createYield(location);
3547     }
3548     return context.createYield(location, argument, delegate, divotStart, argumentStart, lastTokenEndPosition());
3549 }
3550
3551 template <typename LexerType>
3552 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseAwaitExpression(TreeBuilder& context)
3553 {
3554     ASSERT(match(AWAIT));
3555     ASSERT(currentScope()->isAsyncFunction());
3556     failIfTrue(m_parserState.functionParsePhase == FunctionParsePhase::Parameters, "Cannot use await expression within parameters");
3557     JSTokenLocation location(tokenLocation());
3558     JSTextPosition divotStart = tokenStartPosition();
3559     next();
3560     JSTextPosition argumentStart = tokenStartPosition();
3561     ExpressionErrorClassifier classifier(this);
3562     TreeExpression argument = parseUnaryExpression(context);
3563     failIfFalse(argument, "Failed to parse await expression");
3564     return context.createAwait(location, argument, divotStart, argumentStart, lastTokenEndPosition());
3565 }
3566
3567 template <typename LexerType>
3568 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalExpression(TreeBuilder& context)
3569 {
3570     JSTokenLocation location(tokenLocation());
3571     TreeExpression cond = parseBinaryExpression(context);
3572     failIfFalse(cond, "Cannot parse expression");
3573     if (!match(QUESTION))
3574         return cond;
3575     m_parserState.nonTrivialExpressionCount++;
3576     m_parserState.nonLHSCount++;
3577     next(TreeBuilder::DontBuildStrings);
3578     TreeExpression lhs = parseAssignmentExpression(context);
3579     failIfFalse(lhs, "Cannot parse left hand side of ternary operator");
3580     context.setEndOffset(lhs, m_lastTokenEndPosition.offset);
3581     consumeOrFailWithFlags(COLON, TreeBuilder::DontBuildStrings, "Expected ':' in ternary operator");
3582     
3583     TreeExpression rhs = parseAssignmentExpression(context);
3584     failIfFalse(rhs, "Cannot parse right hand side of ternary operator");
3585     context.setEndOffset(rhs, m_lastTokenEndPosition.offset);
3586     return context.createConditionalExpr(location, cond, lhs, rhs);
3587 }
3588
3589 ALWAYS_INLINE static bool isUnaryOpExcludingUpdateOp(JSTokenType token)
3590 {
3591     if (isUpdateOp(token))
3592         return false;
3593     return isUnaryOp(token);
3594 }
3595
3596 template <typename LexerType>
3597 int Parser<LexerType>::isBinaryOperator(JSTokenType token)
3598 {
3599     if (m_allowsIn)
3600         return token & (BinaryOpTokenPrecedenceMask << BinaryOpTokenAllowsInPrecedenceAdditionalShift);
3601     return token & BinaryOpTokenPrecedenceMask;
3602 }
3603
3604 template <typename LexerType>
3605 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseBinaryExpression(TreeBuilder& context)
3606 {
3607     int operandStackDepth = 0;
3608     int operatorStackDepth = 0;
3609     typename TreeBuilder::BinaryExprContext binaryExprContext(context);
3610     JSTokenLocation location(tokenLocation());
3611     while (true) {
3612         JSTextPosition exprStart = tokenStartPosition();
3613         int initialAssignments = m_parserState.assignmentCount;
3614         JSTokenType leadingTokenTypeForUnaryExpression = m_token.m_type;
3615         TreeExpression current = parseUnaryExpression(context);
3616         failIfFalse(current, "Cannot parse expression");
3617         
3618         context.appendBinaryExpressionInfo(operandStackDepth, current, exprStart, lastTokenEndPosition(), lastTokenEndPosition(), initialAssignments != m_parserState.assignmentCount);
3619
3620         // 12.6 https://tc39.github.io/ecma262/#sec-exp-operator
3621         // ExponentiationExpresion is described as follows.
3622         //
3623         //     ExponentiationExpression[Yield]:
3624         //         UnaryExpression[?Yield]
3625         //         UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]
3626         //
3627         // As we can see, the left hand side of the ExponentiationExpression is UpdateExpression, not UnaryExpression.
3628         // So placing UnaryExpression not included in UpdateExpression here is a syntax error.
3629         // This is intentional. For example, if UnaryExpression is allowed, we can have the code like `-x**y`.
3630         // But this is confusing: `-(x**y)` OR `(-x)**y`, which interpretation is correct?
3631         // To avoid this problem, ECMA262 makes unparenthesized exponentiation expression as operand of unary operators an early error.
3632         // More rationale: https://mail.mozilla.org/pipermail/es-discuss/2015-September/044232.html
3633         //
3634         // Here, we guarantee that the left hand side of this expression is not unary expression by checking the leading operator of the parseUnaryExpression.
3635         // This check just works. Let's consider the example,
3636         //     y <> -x ** z
3637         //          ^
3638         //          Check this.
3639         // If the binary operator <> has higher precedence than one of "**", this check does not work.
3640         // But it's OK for ** because the operator "**" has the highest operator precedence in the binary operators.
3641         failIfTrue(match(POW) && isUnaryOpExcludingUpdateOp(leadingTokenTypeForUnaryExpression), "Amiguous unary expression in the left hand side of the exponentiation expression; parenthesis must be used to disambiguate the expression");
3642
3643         int precedence = isBinaryOperator(m_token.m_type);
3644         if (!precedence)
3645             break;
3646         m_parserState.nonTrivialExpressionCount++;
3647         m_parserState.nonLHSCount++;
3648         int operatorToken = m_token.m_type;
3649         next(TreeBuilder::DontBuildStrings);
3650         
3651         while (operatorStackDepth && context.operatorStackShouldReduce(precedence)) {
3652             ASSERT(operandStackDepth > 1);
3653             
3654             typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
3655             typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
3656             context.shrinkOperandStackBy(operandStackDepth, 2);
3657             context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
3658             context.operatorStackPop(operatorStackDepth);
3659         }
3660         context.operatorStackAppend(operatorStackDepth, operatorToken, precedence);
3661     }
3662     while (operatorStackDepth) {
3663         ASSERT(operandStackDepth > 1);
3664         
3665         typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
3666         typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
3667         context.shrinkOperandStackBy(operandStackDepth, 2);
3668         context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
3669         context.operatorStackPop(operatorStackDepth);
3670     }
3671     return context.popOperandStack(operandStackDepth);
3672 }
3673
3674 template <typename LexerType>
3675 template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeBuilder& context, bool complete)