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