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