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