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