Implement ES6 class syntax without inheritance support
[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, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #include "config.h"
24 #include "Parser.h"
25
26 #include "ASTBuilder.h"
27 #include "CodeBlock.h"
28 #include "Debugger.h"
29 #include "JSCJSValueInlines.h"
30 #include "Lexer.h"
31 #include "JSCInlines.h"
32 #include "SourceProvider.h"
33 #include "VM.h"
34 #include <utility>
35 #include <wtf/HashFunctions.h>
36 #include <wtf/StringPrintStream.h>
37 #include <wtf/WTFThreadData.h>
38
39
40 #define updateErrorMessage(shouldPrintToken, ...) do {\
41     propagateError(); \
42     logError(shouldPrintToken, __VA_ARGS__); \
43 } while (0)
44
45 #define propagateError() do { if (hasError()) return 0; } while (0)
46 #define internalFailWithMessage(shouldPrintToken, ...) do { updateErrorMessage(shouldPrintToken, __VA_ARGS__); return 0; } while (0)
47 #define handleErrorToken() do { if (m_token.m_type == EOFTOK || m_token.m_type & ErrorTokenFlag) { failDueToUnexpectedToken(); } } while (0)
48 #define failWithMessage(...) do { { handleErrorToken(); updateErrorMessage(true, __VA_ARGS__); } return 0; } while (0)
49 #define failWithStackOverflow() do { updateErrorMessage(false, "Stack exhausted"); m_hasStackOverflow = true; return 0; } while (0)
50 #define failIfFalse(cond, ...) do { if (!(cond)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
51 #define failIfTrue(cond, ...) do { if (cond) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
52 #define failIfTrueIfStrict(cond, ...) do { if ((cond) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)
53 #define failIfFalseIfStrict(cond, ...) do { if ((!(cond)) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)
54 #define consumeOrFail(tokenType, ...) do { if (!consume(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
55 #define consumeOrFailWithFlags(tokenType, flags, ...) do { if (!consume(tokenType, flags)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
56 #define matchOrFail(tokenType, ...) do { if (!match(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
57 #define failIfStackOverflow() do { if (!canRecurse()) failWithStackOverflow(); } while (0)
58 #define semanticFail(...) do { internalFailWithMessage(false, __VA_ARGS__); } while (0)
59 #define semanticFailIfTrue(cond, ...) do { if (cond) internalFailWithMessage(false, __VA_ARGS__); } while (0)
60 #define semanticFailIfFalse(cond, ...) do { if (!(cond)) internalFailWithMessage(false, __VA_ARGS__); } while (0)
61 #define regexFail(failure) do { setErrorMessage(failure); return 0; } while (0)
62 #define failDueToUnexpectedToken() do {\
63         logError(true);\
64     return 0;\
65 } while (0)
66
67 #define handleProductionOrFail(token, tokenString, operation, production) do {\
68     consumeOrFail(token, "Expected '", tokenString, "' to ", operation, " a ", production);\
69 } while (0)
70
71 #define semanticFailureDueToKeyword(...) do { \
72     if (strictMode() && m_token.m_type == RESERVED_IF_STRICT) \
73         semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__, " in strict mode"); \
74     if (m_token.m_type == RESERVED || m_token.m_type == RESERVED_IF_STRICT) \
75         semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__); \
76     if (m_token.m_type & KeywordTokenFlag) \
77         semanticFail("Cannot use the keyword '", getToken(), "' as a ", __VA_ARGS__); \
78 } while (0)
79
80 using namespace std;
81
82 namespace JSC {
83
84 template <typename LexerType>
85 void Parser<LexerType>::logError(bool)
86 {
87     if (hasError())
88         return;
89     StringPrintStream stream;
90     printUnexpectedTokenText(stream);
91     setErrorMessage(stream.toString());
92 }
93
94 template <typename LexerType> template <typename A>
95 void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1)
96 {
97     if (hasError())
98         return;
99     StringPrintStream stream;
100     if (shouldPrintToken) {
101         printUnexpectedTokenText(stream);
102         stream.print(". ");
103     }
104     stream.print(value1, ".");
105     setErrorMessage(stream.toString());
106 }
107
108 template <typename LexerType> template <typename A, typename B>
109 void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2)
110 {
111     if (hasError())
112         return;
113     StringPrintStream stream;
114     if (shouldPrintToken) {
115         printUnexpectedTokenText(stream);
116         stream.print(". ");
117     }
118     stream.print(value1, value2, ".");
119     setErrorMessage(stream.toString());
120 }
121
122 template <typename LexerType> template <typename A, typename B, typename C>
123 void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2, const C& value3)
124 {
125     if (hasError())
126         return;
127     StringPrintStream stream;
128     if (shouldPrintToken) {
129         printUnexpectedTokenText(stream);
130         stream.print(". ");
131     }
132     stream.print(value1, value2, value3, ".");
133     setErrorMessage(stream.toString());
134 }
135
136 template <typename LexerType> template <typename A, typename B, typename C, typename D>
137 void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2, const C& value3, const D& value4)
138 {
139     if (hasError())
140         return;
141     StringPrintStream stream;
142     if (shouldPrintToken) {
143         printUnexpectedTokenText(stream);
144         stream.print(". ");
145     }
146     stream.print(value1, value2, value3, value4, ".");
147     setErrorMessage(stream.toString());
148 }
149
150 template <typename LexerType> template <typename A, typename B, typename C, typename D, typename E>
151 void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2, const C& value3, const D& value4, const E& value5)
152 {
153     if (hasError())
154         return;
155     StringPrintStream stream;
156     if (shouldPrintToken) {
157         printUnexpectedTokenText(stream);
158         stream.print(". ");
159     }
160     stream.print(value1, value2, value3, value4, value5, ".");
161     setErrorMessage(stream.toString());
162 }
163
164 template <typename LexerType> template <typename A, typename B, typename C, typename D, typename E, typename F>
165 void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2, const C& value3, const D& value4, const E& value5, const F& value6)
166 {
167     if (hasError())
168         return;
169     StringPrintStream stream;
170     if (shouldPrintToken) {
171         printUnexpectedTokenText(stream);
172         stream.print(". ");
173     }
174     stream.print(value1, value2, value3, value4, value5, value6, ".");
175     setErrorMessage(stream.toString());
176 }
177
178 template <typename LexerType> template <typename A, typename B, typename C, typename D, typename E, typename F, typename G>
179 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)
180 {
181     if (hasError())
182         return;
183     StringPrintStream stream;
184     if (shouldPrintToken) {
185         printUnexpectedTokenText(stream);
186         stream.print(". ");
187     }
188     stream.print(value1, value2, value3, value4, value5, value6, value7, ".");
189     setErrorMessage(stream.toString());
190 }
191
192 template <typename LexerType>
193 Parser<LexerType>::Parser(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name, JSParserStrictness strictness, JSParserMode parserMode)
194     : m_vm(vm)
195     , m_source(&source)
196     , m_hasStackOverflow(false)
197     , m_allowsIn(true)
198     , m_assignmentCount(0)
199     , m_nonLHSCount(0)
200     , m_syntaxAlreadyValidated(source.provider()->isValid())
201     , m_statementDepth(0)
202     , m_nonTrivialExpressionCount(0)
203     , m_lastIdentifier(0)
204     , m_lastFunctionName(nullptr)
205     , m_sourceElements(0)
206     , m_parsingBuiltin(strictness == JSParseBuiltin)
207 {
208     m_lexer = std::make_unique<LexerType>(vm, strictness);
209     m_lexer->setCode(source, &m_parserArena);
210     m_token.m_location.line = source.firstLine();
211     m_token.m_location.startOffset = source.startOffset();
212     m_token.m_location.endOffset = source.startOffset();
213     m_token.m_location.lineStartOffset = source.startOffset();
214     m_functionCache = vm->addSourceProviderCache(source.provider());
215     ScopeRef scope = pushScope();
216     if (parserMode == JSParseFunctionCode)
217         scope->setIsFunction();
218     if (strictness == JSParseStrict)
219         scope->setStrictMode();
220     if (parameters) {
221         bool hadBindingParameters = false;
222         for (unsigned i = 0; i < parameters->size(); i++) {
223             auto parameter = parameters->at(i);
224             if (!parameter->isBindingNode()) {
225                 hadBindingParameters = true;
226                 continue;
227             }
228             scope->declareParameter(&static_cast<BindingNode*>(parameter)->boundProperty());
229         }
230         if (hadBindingParameters) {
231             Vector<Identifier> boundParameterNames;
232             for (unsigned i = 0; i < parameters->size(); i++) {
233                 auto parameter = parameters->at(i);
234                 if (parameter->isBindingNode())
235                     continue;
236                 parameter->collectBoundIdentifiers(boundParameterNames);
237             }
238             for (auto& boundParameterName : boundParameterNames)
239                 scope->declareVariable(&boundParameterName);
240         }
241     }
242     if (!name.isNull())
243         scope->declareCallee(&name);
244     next();
245 }
246
247 template <typename LexerType>
248 Parser<LexerType>::~Parser()
249 {
250 }
251
252 template <typename LexerType>
253 String Parser<LexerType>::parseInner()
254 {
255     String parseError = String();
256     
257     ASTBuilder context(const_cast<VM*>(m_vm), m_parserArena, const_cast<SourceCode*>(m_source));
258     if (m_lexer->isReparsing())
259         m_statementDepth--;
260     ScopeRef scope = currentScope();
261     SourceElements* sourceElements = parseSourceElements(context, CheckForStrictMode);
262     if (!sourceElements || !consume(EOFTOK)) {
263         if (hasError())
264             parseError = m_errorMessage;
265         else
266             parseError = ASCIILiteral("Parser error");
267     }
268
269     IdentifierSet capturedVariables;
270     bool modifiedParameter = false;
271     bool modifiedArguments = false;
272     scope->getCapturedVariables(capturedVariables, modifiedParameter, modifiedArguments);
273     
274     CodeFeatures features = context.features();
275     if (scope->strictMode())
276         features |= StrictModeFeature;
277     if (scope->shadowsArguments())
278         features |= ShadowsArgumentsFeature;
279     if (modifiedParameter)
280         features |= ModifiedParameterFeature;
281     if (modifiedArguments)
282         features |= ModifiedArgumentsFeature;
283     Vector<RefPtr<StringImpl>> closedVariables;
284     if (m_parsingBuiltin) {
285         RELEASE_ASSERT(!capturedVariables.size());
286         IdentifierSet usedVariables;
287         scope->getUsedVariables(usedVariables);
288         for (const auto& variable : usedVariables) {
289             if (scope->hasDeclaredVariable(Identifier(m_vm, variable.get())))
290                 continue;
291             
292             if (scope->hasDeclaredParameter(Identifier(m_vm, variable.get())))
293                 continue;
294
295             if (variable == m_vm->propertyNames->arguments.impl())
296                 continue;
297
298             closedVariables.append(variable);
299         }
300     }
301     didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), features,
302         context.numConstants(), capturedVariables, WTF::move(closedVariables));
303
304     return parseError;
305 }
306
307 template <typename LexerType>
308 void Parser<LexerType>::didFinishParsing(SourceElements* sourceElements, DeclarationStacks::VarStack& varStack, 
309     DeclarationStacks::FunctionStack& funcStack, CodeFeatures features, int numConstants, IdentifierSet& capturedVars, const Vector<RefPtr<StringImpl>>&& closedVariables)
310 {
311     m_sourceElements = sourceElements;
312     m_varDeclarations.swap(varStack);
313     m_funcDeclarations.swap(funcStack);
314     m_capturedVariables.swap(capturedVars);
315     m_closedVariables = closedVariables;
316     m_features = features;
317     m_numConstants = numConstants;
318 }
319
320 template <typename LexerType>
321 bool Parser<LexerType>::allowAutomaticSemicolon()
322 {
323     return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator();
324 }
325
326 template <typename LexerType>
327 template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceElements(TreeBuilder& context, SourceElementsMode mode)
328 {
329     const unsigned lengthOfUseStrictLiteral = 12; // "use strict".length
330     TreeSourceElements sourceElements = context.createSourceElements();
331     bool seenNonDirective = false;
332     const Identifier* directive = 0;
333     unsigned directiveLiteralLength = 0;
334     auto savePoint = createSavePoint();
335     bool hasSetStrict = false;
336     while (TreeStatement statement = parseStatement(context, directive, &directiveLiteralLength)) {
337         if (mode == CheckForStrictMode && !seenNonDirective) {
338             if (directive) {
339                 // "use strict" must be the exact literal without escape sequences or line continuation.
340                 if (!hasSetStrict && directiveLiteralLength == lengthOfUseStrictLiteral && m_vm->propertyNames->useStrictIdentifier == *directive) {
341                     setStrictMode();
342                     hasSetStrict = true;
343                     if (!isValidStrictMode()) {
344                         if (m_lastFunctionName) {
345                             if (m_vm->propertyNames->arguments == *m_lastFunctionName)
346                                 semanticFail("Cannot name a function 'arguments' in strict mode");
347                             if (m_vm->propertyNames->eval == *m_lastFunctionName)
348                                 semanticFail("Cannot name a function 'eval' in strict mode");
349                         }
350                         if (hasDeclaredVariable(m_vm->propertyNames->arguments))
351                             semanticFail("Cannot declare a variable named 'arguments' in strict mode");
352                         if (hasDeclaredVariable(m_vm->propertyNames->eval))
353                             semanticFail("Cannot declare a variable named 'eval' in strict mode");
354                         semanticFailIfFalse(isValidStrictMode(), "Invalid parameters or function name in strict mode");
355                     }
356                     restoreSavePoint(savePoint);
357                     propagateError();
358                     continue;
359                 }
360             } else
361                 seenNonDirective = true;
362         }
363         context.appendStatement(sourceElements, statement);
364     }
365
366     propagateError();
367     return sourceElements;
368 }
369
370 template <typename LexerType>
371 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVarDeclaration(TreeBuilder& context)
372 {
373     ASSERT(match(VAR));
374     JSTokenLocation location(tokenLocation());
375     int start = tokenLine();
376     int end = 0;
377     int scratch;
378     TreeDeconstructionPattern scratch1 = 0;
379     TreeExpression scratch2 = 0;
380     JSTextPosition scratch3;
381     TreeExpression varDecls = parseVarDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3);
382     propagateError();
383     failIfFalse(autoSemiColon(), "Expected ';' after var declaration");
384     
385     return context.createVarStatement(location, varDecls, start, end);
386 }
387
388 template <typename LexerType>
389 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseConstDeclaration(TreeBuilder& context)
390 {
391     ASSERT(match(CONSTTOKEN));
392     JSTokenLocation location(tokenLocation());
393     int start = tokenLine();
394     int end = 0;
395     TreeConstDeclList constDecls = parseConstDeclarationList(context);
396     propagateError();
397     failIfFalse(autoSemiColon(), "Expected ';' after const declaration");
398     
399     return context.createConstStatement(location, constDecls, start, end);
400 }
401
402 template <typename LexerType>
403 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDoWhileStatement(TreeBuilder& context)
404 {
405     ASSERT(match(DO));
406     int startLine = tokenLine();
407     next();
408     const Identifier* unused = 0;
409     startLoop();
410     TreeStatement statement = parseStatement(context, unused);
411     endLoop();
412     failIfFalse(statement, "Expected a statement following 'do'");
413     int endLine = tokenLine();
414     JSTokenLocation location(tokenLocation());
415     handleProductionOrFail(WHILE, "while", "end", "do-while loop");
416     handleProductionOrFail(OPENPAREN, "(", "start", "do-while loop condition");
417     semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a do-while loop condition");
418     TreeExpression expr = parseExpression(context);
419     failIfFalse(expr, "Unable to parse do-while loop condition");
420     handleProductionOrFail(CLOSEPAREN, ")", "end", "do-while loop condition");
421     if (match(SEMICOLON))
422         next(); // Always performs automatic semicolon insertion.
423     return context.createDoWhileStatement(location, statement, expr, startLine, endLine);
424 }
425
426 template <typename LexerType>
427 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWhileStatement(TreeBuilder& context)
428 {
429     ASSERT(match(WHILE));
430     JSTokenLocation location(tokenLocation());
431     int startLine = tokenLine();
432     next();
433     
434     handleProductionOrFail(OPENPAREN, "(", "start", "while loop condition");
435     semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a while loop condition");
436     TreeExpression expr = parseExpression(context);
437     failIfFalse(expr, "Unable to parse while loop condition");
438     int endLine = tokenLine();
439     handleProductionOrFail(CLOSEPAREN, ")", "end", "while loop condition");
440     
441     const Identifier* unused = 0;
442     startLoop();
443     TreeStatement statement = parseStatement(context, unused);
444     endLoop();
445     failIfFalse(statement, "Expected a statement as the body of a while loop");
446     return context.createWhileStatement(location, expr, statement, startLine, endLine);
447 }
448
449 template <typename LexerType>
450 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarationList(TreeBuilder& context, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd)
451 {
452     TreeExpression head = 0;
453     TreeExpression tail = 0;
454     const Identifier* lastIdent;
455     do {
456         lastIdent = 0;
457         lastPattern = 0;
458         JSTokenLocation location(tokenLocation());
459         next();
460         TreeExpression node = 0;
461         declarations++;
462         bool hasInitializer = false;
463         if (match(IDENT)) {
464             JSTextPosition varStart = tokenStartPosition();
465             JSTokenLocation varStartLocation(tokenLocation());
466             identStart = varStart;
467             const Identifier* name = m_token.m_data.ident;
468             lastIdent = name;
469             next();
470             hasInitializer = match(EQUAL);
471             failIfFalseIfStrict(declareVariable(name), "Cannot declare a variable named ", name->impl(), " in strict mode");
472             context.addVar(name, (hasInitializer || (!m_allowsIn && (match(INTOKEN) || isofToken()))) ? DeclarationStacks::HasInitializer : 0);
473             if (hasInitializer) {
474                 JSTextPosition varDivot = tokenStartPosition() + 1;
475                 initStart = tokenStartPosition();
476                 next(TreeBuilder::DontBuildStrings); // consume '='
477                 TreeExpression initializer = parseAssignmentExpression(context);
478                 initEnd = lastTokenEndPosition();
479                 lastInitializer = initializer;
480                 failIfFalse(initializer, "Expected expression as the intializer for the variable '", name->impl(), "'");
481                 
482                 node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEndPosition());
483             } else
484                 node = context.createEmptyVarExpression(varStartLocation, *name);
485         } else {
486             lastIdent = 0;
487             auto pattern = parseDeconstructionPattern(context, DeconstructToVariables);
488             failIfFalse(pattern, "Cannot parse this deconstruction pattern");
489             hasInitializer = match(EQUAL);
490             lastPattern = pattern;
491             if (hasInitializer) {
492                 next(TreeBuilder::DontBuildStrings); // consume '='
493                 TreeExpression rhs = parseAssignmentExpression(context);
494                 node = context.createDeconstructingAssignment(location, pattern, rhs);
495                 lastInitializer = rhs;
496             }
497         }
498         
499         if (!head)
500             head = node;
501         else if (!tail) {
502             head = context.createCommaExpr(location, head);
503             tail = context.appendToCommaExpr(location, head, head, node);
504         } else
505             tail = context.appendToCommaExpr(location, head, tail, node);
506     } while (match(COMMA));
507     if (lastIdent)
508         lastPattern = createBindingPattern(context, DeconstructToVariables, *lastIdent, 0, m_token);
509     return head;
510 }
511
512 template <typename LexerType>
513 template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, DeconstructionKind kind, const Identifier& name, int depth, JSToken token)
514 {
515     ASSERT(!name.isEmpty());
516     ASSERT(!name.isNull());
517     
518     ASSERT(name.impl()->isAtomic());
519     if (depth) {
520         if (kind == DeconstructToVariables)
521             failIfFalseIfStrict(declareVariable(&name), "Cannot deconstruct to a variable named '", name.impl(), "' in strict mode");
522         if (kind == DeconstructToParameters) {
523             auto bindingResult = declareBoundParameter(&name);
524             if (bindingResult == Scope::StrictBindingFailed && strictMode()) {
525                 semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot deconstruct to a parameter name '", name.impl(), "' in strict mode");
526                 if (m_lastFunctionName && name == *m_lastFunctionName)
527                     semanticFail("Cannot deconstruct to '", name.impl(), "' as it shadows the name of a strict mode function");
528                 semanticFailureDueToKeyword("bound parameter name");
529                 if (hasDeclaredParameter(name))
530                     semanticFail("Cannot deconstruct to '", name.impl(), "' as it has already been declared");
531                 semanticFail("Cannot bind to a parameter named '", name.impl(), "' in strict mode");
532             }
533             if (bindingResult == Scope::BindingFailed) {
534                 semanticFailureDueToKeyword("bound parameter name");
535                 if (hasDeclaredParameter(name))
536                     semanticFail("Cannot deconstruct to '", name.impl(), "' as it has already been declared");
537                 semanticFail("Cannot deconstruct to a parameter named '", name.impl(), "'");
538             }
539         }
540         if (kind != DeconstructToExpressions)
541             context.addVar(&name, DeclarationStacks::HasInitializer);
542
543     } else {
544         if (kind == DeconstructToVariables) {
545             failIfFalseIfStrict(declareVariable(&name), "Cannot declare a variable named '", name.impl(), "' in strict mode");
546             context.addVar(&name, DeclarationStacks::HasInitializer);
547         }
548         
549         if (kind == DeconstructToParameters) {
550             bool declarationResult = declareParameter(&name);
551             if (!declarationResult && strictMode()) {
552                 semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot deconstruct to a parameter name '", name.impl(), "' in strict mode");
553                 if (m_lastFunctionName && name == *m_lastFunctionName)
554                     semanticFail("Cannot declare a parameter named '", name.impl(), "' as it shadows the name of a strict mode function");
555                 semanticFailureDueToKeyword("parameter name");
556                 if (hasDeclaredParameter(name))
557                     semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode as it has already been declared");
558                 semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode");
559             }
560         }
561     }
562     return context.createBindingLocation(token.m_location, name, token.m_startPosition, token.m_endPosition);
563 }
564
565 template <typename LexerType>
566 template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::tryParseDeconstructionPatternExpression(TreeBuilder& context)
567 {
568     return parseDeconstructionPattern(context, DeconstructToExpressions);
569 }
570
571 template <typename LexerType>
572 template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::parseDeconstructionPattern(TreeBuilder& context, DeconstructionKind kind, int depth)
573 {
574     failIfStackOverflow();
575     int nonLHSCount = m_nonLHSCount;
576     TreeDeconstructionPattern pattern;
577     switch (m_token.m_type) {
578     case OPENBRACKET: {
579         auto arrayPattern = context.createArrayPattern(m_token.m_location);
580         next();
581         if (kind == DeconstructToExpressions && match(CLOSEBRACKET))
582             return 0;
583         failIfTrue(match(CLOSEBRACKET), "There must be at least one bound property in an array deconstruction pattern");
584         do {
585             while (match(COMMA)) {
586                 context.appendArrayPatternSkipEntry(arrayPattern, m_token.m_location);
587                 next();
588             }
589             propagateError();
590             JSTokenLocation location = m_token.m_location;
591             auto innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
592             if (kind == DeconstructToExpressions && !innerPattern)
593                 return 0;
594             failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");
595             context.appendArrayPatternEntry(arrayPattern, location, innerPattern);
596         } while (consume(COMMA));
597         
598         if (kind == DeconstructToExpressions && !match(CLOSEBRACKET))
599             return 0;
600
601         consumeOrFail(CLOSEBRACKET, "Expected either a closing ']' or a ',' following an element deconstruction pattern");
602         pattern = arrayPattern;
603         break;
604     }
605     case OPENBRACE: {
606         next();
607         
608         if (kind == DeconstructToExpressions && match(CLOSEBRACE))
609             return 0;
610
611         failIfTrue(match(CLOSEBRACE), "There must be at least one bound property in an object deconstruction pattern");
612         auto objectPattern = context.createObjectPattern(m_token.m_location);
613         bool wasString = false;
614         do {
615             Identifier propertyName;
616             TreeDeconstructionPattern innerPattern = 0;
617             JSTokenLocation location = m_token.m_location;
618             if (match(IDENT)) {
619                 propertyName = *m_token.m_data.ident;
620                 JSToken identifierToken = m_token;
621                 next();
622                 if (consume(COLON))
623                     innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
624                 else
625                     innerPattern = createBindingPattern(context, kind, propertyName, depth, identifierToken);
626             } else {
627                 JSTokenType tokenType = m_token.m_type;
628                 switch (m_token.m_type) {
629                 case NUMBER:
630                     propertyName = Identifier::from(m_vm, m_token.m_data.doubleValue);
631                     break;
632                 case STRING:
633                     propertyName = *m_token.m_data.ident;
634                     wasString = true;
635                     break;
636                 default:
637                     if (m_token.m_type != RESERVED && m_token.m_type != RESERVED_IF_STRICT && !(m_token.m_type & KeywordTokenFlag)) {
638                         if (kind == DeconstructToExpressions)
639                             return 0;
640                         failWithMessage("Expected a property name");
641                     }
642                     propertyName = *m_token.m_data.ident;
643                     break;
644                 }
645                 next();
646                 if (!consume(COLON)) {
647                     if (kind == DeconstructToExpressions)
648                         return 0;
649                     semanticFailIfTrue(tokenType == RESERVED, "Cannot use abbreviated deconstruction syntax for reserved name '", propertyName.impl(), "'");
650                     semanticFailIfTrue(tokenType == RESERVED_IF_STRICT, "Cannot use abbreviated deconstruction syntax for reserved name '", propertyName.impl(), "' in strict mode");
651                     semanticFailIfTrue(tokenType & KeywordTokenFlag, "Cannot use abbreviated deconstruction syntax for keyword '", propertyName.impl(), "'");
652                     
653                     failWithMessage("Expected a ':' prior to named property deconstruction");
654                 }
655                 innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
656             }
657             if (kind == DeconstructToExpressions && !innerPattern)
658                 return 0;
659             failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");
660             context.appendObjectPatternEntry(objectPattern, location, wasString, propertyName, innerPattern);
661         } while (consume(COMMA));
662         if (kind == DeconstructToExpressions && !match(CLOSEBRACE))
663             return 0;
664         consumeOrFail(CLOSEBRACE, "Expected either a closing '}' or an ',' after a property deconstruction pattern");
665         pattern = objectPattern;
666         break;
667     }
668
669     default: {
670         if (!match(IDENT)) {
671             if (kind == DeconstructToExpressions)
672                 return 0;
673             semanticFailureDueToKeyword("variable name");
674             failWithMessage("Expected a parameter pattern or a ')' in parameter list");
675         }
676         pattern = createBindingPattern(context, kind, *m_token.m_data.ident, depth, m_token);
677         next();
678         break;
679     }
680     }
681     m_nonLHSCount = nonLHSCount;
682     return pattern;
683 }
684
685 template <typename LexerType>
686 template <class TreeBuilder> TreeConstDeclList Parser<LexerType>::parseConstDeclarationList(TreeBuilder& context)
687 {
688     failIfTrue(strictMode(), "Const declarations are not supported in strict mode");
689     TreeConstDeclList constDecls = 0;
690     TreeConstDeclList tail = 0;
691     do {
692         JSTokenLocation location(tokenLocation());
693         next();
694         matchOrFail(IDENT, "Expected an identifier name in const declaration");
695         const Identifier* name = m_token.m_data.ident;
696         next();
697         bool hasInitializer = match(EQUAL);
698         declareVariable(name);
699         context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));
700
701         TreeExpression initializer = 0;
702         if (hasInitializer) {
703             next(TreeBuilder::DontBuildStrings); // consume '='
704             initializer = parseAssignmentExpression(context);
705             failIfFalse(!!initializer, "Unable to parse initializer");
706         }
707         tail = context.appendConstDecl(location, tail, name, initializer);
708         if (!constDecls)
709             constDecls = tail;
710     } while (match(COMMA));
711     return constDecls;
712 }
713
714 template <typename LexerType>
715 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement(TreeBuilder& context)
716 {
717     ASSERT(match(FOR));
718     JSTokenLocation location(tokenLocation());
719     int startLine = tokenLine();
720     next();
721     handleProductionOrFail(OPENPAREN, "(", "start", "for-loop header");
722     int nonLHSCount = m_nonLHSCount;
723     int declarations = 0;
724     JSTextPosition declsStart;
725     JSTextPosition declsEnd;
726     TreeExpression decls = 0;
727     TreeDeconstructionPattern pattern = 0;
728     if (match(VAR)) {
729         /*
730          for (var IDENT in expression) statement
731          for (var varDeclarationList; expressionOpt; expressionOpt)
732          */
733         TreeDeconstructionPattern forInTarget = 0;
734         TreeExpression forInInitializer = 0;
735         m_allowsIn = false;
736         JSTextPosition initStart;
737         JSTextPosition initEnd;
738         decls = parseVarDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd);
739         m_allowsIn = true;
740         propagateError();
741
742         // Remainder of a standard for loop is handled identically
743         if (match(SEMICOLON))
744             goto standardForLoop;
745         
746         failIfFalse(declarations == 1, "can only declare a single variable in an enumeration");
747         failIfTrueIfStrict(forInInitializer, "Cannot use initialiser syntax in a strict mode enumeration");
748
749         if (forInInitializer)
750             failIfFalse(context.isBindingNode(forInTarget), "Cannot use initialiser syntax when binding to a pattern during enumeration");
751
752         // Handle for-in with var declaration
753         JSTextPosition inLocation = tokenStartPosition();
754         bool isOfEnumeration = false;
755         if (!consume(INTOKEN)) {
756             failIfFalse(match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of, "Expected either 'in' or 'of' in enumeration syntax");
757             isOfEnumeration = true;
758             failIfTrue(forInInitializer, "Cannot use initialiser syntax in a for-of enumeration");
759             next();
760         }
761         TreeExpression expr = parseExpression(context);
762         failIfFalse(expr, "Expected expression to enumerate");
763         JSTextPosition exprEnd = lastTokenEndPosition();
764         
765         int endLine = tokenLine();
766         
767         handleProductionOrFail(CLOSEPAREN, ")", "end", (isOfEnumeration ? "for-of header" : "for-in header"));
768         
769         const Identifier* unused = 0;
770         startLoop();
771         TreeStatement statement = parseStatement(context, unused);
772         endLoop();
773         failIfFalse(statement, "Expected statement as body of for-", isOfEnumeration ? "of" : "in", " statement");
774         if (isOfEnumeration)
775             return context.createForOfLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine);
776         return context.createForInLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine);
777     }
778     
779     if (!match(SEMICOLON)) {
780         if (match(OPENBRACE) || match(OPENBRACKET)) {
781             SavePoint savePoint = createSavePoint();
782             declsStart = tokenStartPosition();
783             pattern = tryParseDeconstructionPatternExpression(context);
784             declsEnd = lastTokenEndPosition();
785             if (pattern && (match(INTOKEN) || (match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of)))
786                 goto enumerationLoop;
787             pattern = 0;
788             restoreSavePoint(savePoint);
789         }
790         m_allowsIn = false;
791         declsStart = tokenStartPosition();
792         decls = parseExpression(context);
793         declsEnd = lastTokenEndPosition();
794         m_allowsIn = true;
795         failIfFalse(decls, "Cannot parse for loop declarations");
796     }
797     
798     if (match(SEMICOLON)) {
799     standardForLoop:
800         // Standard for loop
801         next();
802         TreeExpression condition = 0;
803         
804         if (!match(SEMICOLON)) {
805             condition = parseExpression(context);
806             failIfFalse(condition, "Cannot parse for loop condition expression");
807         }
808         consumeOrFail(SEMICOLON, "Expected a ';' after the for loop condition expression");
809         
810         TreeExpression increment = 0;
811         if (!match(CLOSEPAREN)) {
812             increment = parseExpression(context);
813             failIfFalse(increment, "Cannot parse for loop iteration expression");
814         }
815         int endLine = tokenLine();
816         handleProductionOrFail(CLOSEPAREN, ")", "end", "for-loop header");
817         const Identifier* unused = 0;
818         startLoop();
819         TreeStatement statement = parseStatement(context, unused);
820         endLoop();
821         failIfFalse(statement, "Expected a statement as the body of a for loop");
822         return context.createForLoop(location, decls, condition, increment, statement, startLine, endLine);
823     }
824     
825     // For-in loop
826 enumerationLoop:
827     failIfFalse(nonLHSCount == m_nonLHSCount, "Expected a reference on the left hand side of an enumeration statement");
828     bool isOfEnumeration = false;
829     if (!consume(INTOKEN)) {
830         failIfFalse(match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of, "Expected either 'in' or 'of' in enumeration syntax");
831         isOfEnumeration = true;
832         next();
833     }
834     TreeExpression expr = parseExpression(context);
835     failIfFalse(expr, "Cannot parse subject for-", isOfEnumeration ? "of" : "in", " statement");
836     JSTextPosition exprEnd = lastTokenEndPosition();
837     int endLine = tokenLine();
838     
839     handleProductionOrFail(CLOSEPAREN, ")", "end", (isOfEnumeration ? "for-of header" : "for-in header"));
840     const Identifier* unused = 0;
841     startLoop();
842     TreeStatement statement = parseStatement(context, unused);
843     endLoop();
844     failIfFalse(statement, "Expected a statement as the body of a for-", isOfEnumeration ? "of" : "in", "loop");
845     if (pattern) {
846         ASSERT(!decls);
847         if (isOfEnumeration)
848             return context.createForOfLoop(location, pattern, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
849         return context.createForInLoop(location, pattern, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
850     }
851     if (isOfEnumeration)
852         return context.createForOfLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
853     return context.createForInLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
854 }
855
856 template <typename LexerType>
857 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBreakStatement(TreeBuilder& context)
858 {
859     ASSERT(match(BREAK));
860     JSTokenLocation location(tokenLocation());
861     JSTextPosition start = tokenStartPosition();
862     JSTextPosition end = tokenEndPosition();
863     next();
864     
865     if (autoSemiColon()) {
866         semanticFailIfFalse(breakIsValid(), "'break' is only valid inside a switch or loop statement");
867         return context.createBreakStatement(location, &m_vm->propertyNames->nullIdentifier, start, end);
868     }
869     matchOrFail(IDENT, "Expected an identifier as the target for a break statement");
870     const Identifier* ident = m_token.m_data.ident;
871     semanticFailIfFalse(getLabel(ident), "Cannot use the undeclared label '", ident->impl(), "'");
872     end = tokenEndPosition();
873     next();
874     failIfFalse(autoSemiColon(), "Expected a ';' following a targeted break statement");
875     return context.createBreakStatement(location, ident, start, end);
876 }
877
878 template <typename LexerType>
879 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseContinueStatement(TreeBuilder& context)
880 {
881     ASSERT(match(CONTINUE));
882     JSTokenLocation location(tokenLocation());
883     JSTextPosition start = tokenStartPosition();
884     JSTextPosition end = tokenEndPosition();
885     next();
886     
887     if (autoSemiColon()) {
888         semanticFailIfFalse(continueIsValid(), "'continue' is only valid inside a loop statement");
889         return context.createContinueStatement(location, &m_vm->propertyNames->nullIdentifier, start, end);
890     }
891     matchOrFail(IDENT, "Expected an identifier as the target for a continue statement");
892     const Identifier* ident = m_token.m_data.ident;
893     ScopeLabelInfo* label = getLabel(ident);
894     semanticFailIfFalse(label, "Cannot use the undeclared label '", ident->impl(), "'");
895     semanticFailIfFalse(label->m_isLoop, "Cannot continue to the label '", ident->impl(), "' as it is not targeting a loop");
896     end = tokenEndPosition();
897     next();
898     failIfFalse(autoSemiColon(), "Expected a ';' following a targeted continue statement");
899     return context.createContinueStatement(location, ident, start, end);
900 }
901
902 template <typename LexerType>
903 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseReturnStatement(TreeBuilder& context)
904 {
905     ASSERT(match(RETURN));
906     JSTokenLocation location(tokenLocation());
907     semanticFailIfFalse(currentScope()->isFunction(), "Return statements are only valid inside functions");
908     JSTextPosition start = tokenStartPosition();
909     JSTextPosition end = tokenEndPosition();
910     next();
911     // We do the auto semicolon check before attempting to parse expression
912     // as we need to ensure the a line break after the return correctly terminates
913     // the statement
914     if (match(SEMICOLON))
915         end = tokenEndPosition();
916
917     if (autoSemiColon())
918         return context.createReturnStatement(location, 0, start, end);
919     TreeExpression expr = parseExpression(context);
920     failIfFalse(expr, "Cannot parse the return expression");
921     end = lastTokenEndPosition();
922     if (match(SEMICOLON))
923         end  = tokenEndPosition();
924     if (!autoSemiColon())
925         failWithMessage("Expected a ';' following a return statement");
926     return context.createReturnStatement(location, expr, start, end);
927 }
928
929 template <typename LexerType>
930 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseThrowStatement(TreeBuilder& context)
931 {
932     ASSERT(match(THROW));
933     JSTokenLocation location(tokenLocation());
934     JSTextPosition start = tokenStartPosition();
935     next();
936     failIfTrue(match(SEMICOLON), "Expected expression after 'throw'");
937     semanticFailIfTrue(autoSemiColon(), "Cannot have a newline after 'throw'");
938     
939     TreeExpression expr = parseExpression(context);
940     failIfFalse(expr, "Cannot parse expression for throw statement");
941     JSTextPosition end = lastTokenEndPosition();
942     failIfFalse(autoSemiColon(), "Expected a ';' after a throw statement");
943     
944     return context.createThrowStatement(location, expr, start, end);
945 }
946
947 template <typename LexerType>
948 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWithStatement(TreeBuilder& context)
949 {
950     ASSERT(match(WITH));
951     JSTokenLocation location(tokenLocation());
952     semanticFailIfTrue(strictMode(), "'with' statements are not valid in strict mode");
953     currentScope()->setNeedsFullActivation();
954     int startLine = tokenLine();
955     next();
956
957     handleProductionOrFail(OPENPAREN, "(", "start", "subject of a 'with' statement");
958     int start = tokenStart();
959     TreeExpression expr = parseExpression(context);
960     failIfFalse(expr, "Cannot parse 'with' subject expression");
961     JSTextPosition end = lastTokenEndPosition();
962     int endLine = tokenLine();
963     handleProductionOrFail(CLOSEPAREN, ")", "start", "subject of a 'with' statement");
964     const Identifier* unused = 0;
965     TreeStatement statement = parseStatement(context, unused);
966     failIfFalse(statement, "A 'with' statement must have a body");
967     
968     return context.createWithStatement(location, expr, statement, start, end, startLine, endLine);
969 }
970
971 template <typename LexerType>
972 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStatement(TreeBuilder& context)
973 {
974     ASSERT(match(SWITCH));
975     JSTokenLocation location(tokenLocation());
976     int startLine = tokenLine();
977     next();
978     handleProductionOrFail(OPENPAREN, "(", "start", "subject of a 'switch'");
979     TreeExpression expr = parseExpression(context);
980     failIfFalse(expr, "Cannot parse switch subject expression");
981     int endLine = tokenLine();
982     
983     handleProductionOrFail(CLOSEPAREN, ")", "end", "subject of a 'switch'");
984     handleProductionOrFail(OPENBRACE, "{", "start", "body of a 'switch'");
985     startSwitch();
986     TreeClauseList firstClauses = parseSwitchClauses(context);
987     propagateError();
988     
989     TreeClause defaultClause = parseSwitchDefaultClause(context);
990     propagateError();
991     
992     TreeClauseList secondClauses = parseSwitchClauses(context);
993     propagateError();
994     endSwitch();
995     handleProductionOrFail(CLOSEBRACE, "}", "end", "body of a 'switch'");
996     
997     return context.createSwitchStatement(location, expr, firstClauses, defaultClause, secondClauses, startLine, endLine);
998     
999 }
1000
1001 template <typename LexerType>
1002 template <class TreeBuilder> TreeClauseList Parser<LexerType>::parseSwitchClauses(TreeBuilder& context)
1003 {
1004     if (!match(CASE))
1005         return 0;
1006     unsigned startOffset = tokenStart();
1007     next();
1008     TreeExpression condition = parseExpression(context);
1009     failIfFalse(condition, "Cannot parse switch clause");
1010     consumeOrFail(COLON, "Expected a ':' after switch clause expression");
1011     TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
1012     failIfFalse(statements, "Cannot parse the body of a switch clause");
1013     TreeClause clause = context.createClause(condition, statements);
1014     context.setStartOffset(clause, startOffset);
1015     TreeClauseList clauseList = context.createClauseList(clause);
1016     TreeClauseList tail = clauseList;
1017     
1018     while (match(CASE)) {
1019         startOffset = tokenStart();
1020         next();
1021         TreeExpression condition = parseExpression(context);
1022         failIfFalse(condition, "Cannot parse switch case expression");
1023         consumeOrFail(COLON, "Expected a ':' after switch clause expression");
1024         TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
1025         failIfFalse(statements, "Cannot parse the body of a switch clause");
1026         clause = context.createClause(condition, statements);
1027         context.setStartOffset(clause, startOffset);
1028         tail = context.createClauseList(tail, clause);
1029     }
1030     return clauseList;
1031 }
1032
1033 template <typename LexerType>
1034 template <class TreeBuilder> TreeClause Parser<LexerType>::parseSwitchDefaultClause(TreeBuilder& context)
1035 {
1036     if (!match(DEFAULT))
1037         return 0;
1038     unsigned startOffset = tokenStart();
1039     next();
1040     consumeOrFail(COLON, "Expected a ':' after switch default clause");
1041     TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
1042     failIfFalse(statements, "Cannot parse the body of a switch default clause");
1043     TreeClause result = context.createClause(0, statements);
1044     context.setStartOffset(result, startOffset);
1045     return result;
1046 }
1047
1048 template <typename LexerType>
1049 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement(TreeBuilder& context)
1050 {
1051     ASSERT(match(TRY));
1052     JSTokenLocation location(tokenLocation());
1053     TreeStatement tryBlock = 0;
1054     const Identifier* ident = &m_vm->propertyNames->nullIdentifier;
1055     TreeStatement catchBlock = 0;
1056     TreeStatement finallyBlock = 0;
1057     int firstLine = tokenLine();
1058     next();
1059     matchOrFail(OPENBRACE, "Expected a block statement as body of a try statement");
1060     
1061     tryBlock = parseBlockStatement(context);
1062     failIfFalse(tryBlock, "Cannot parse the body of try block");
1063     int lastLine = m_lastTokenEndPosition.line;
1064     
1065     if (match(CATCH)) {
1066         currentScope()->setNeedsFullActivation();
1067         next();
1068         
1069         handleProductionOrFail(OPENPAREN, "(", "start", "'catch' target");
1070         if (!match(IDENT)) {
1071             semanticFailureDueToKeyword("catch variable name");
1072             failWithMessage("Expected identifier name as catch target");
1073         }
1074         ident = m_token.m_data.ident;
1075         next();
1076         AutoPopScopeRef catchScope(this, pushScope());
1077         failIfFalseIfStrict(declareVariable(ident), "Cannot declare a catch variable named '", ident->impl(), "' in strict mode");
1078         catchScope->preventNewDecls();
1079         handleProductionOrFail(CLOSEPAREN, ")", "end", "'catch' target");
1080         matchOrFail(OPENBRACE, "Expected exception handler to be a block statement");
1081         catchBlock = parseBlockStatement(context);
1082         failIfFalse(catchBlock, "Unable to parse 'catch' block");
1083         failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo), "Parse error");
1084     }
1085     
1086     if (match(FINALLY)) {
1087         next();
1088         matchOrFail(OPENBRACE, "Expected block statement for finally body");
1089         finallyBlock = parseBlockStatement(context);
1090         failIfFalse(finallyBlock, "Cannot parse finally body");
1091     }
1092     failIfFalse(catchBlock || finallyBlock, "Try statements must have at least a catch or finally block");
1093     return context.createTryStatement(location, tryBlock, ident, catchBlock, finallyBlock, firstLine, lastLine);
1094 }
1095
1096 template <typename LexerType>
1097 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDebuggerStatement(TreeBuilder& context)
1098 {
1099     ASSERT(match(DEBUGGER));
1100     JSTokenLocation location(tokenLocation());
1101     int startLine = tokenLine();
1102     int endLine = startLine;
1103     next();
1104     if (match(SEMICOLON))
1105         startLine = tokenLine();
1106     failIfFalse(autoSemiColon(), "Debugger keyword must be followed by a ';'");
1107     return context.createDebugger(location, startLine, endLine);
1108 }
1109
1110 template <typename LexerType>
1111 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context)
1112 {
1113     ASSERT(match(OPENBRACE));
1114     JSTokenLocation location(tokenLocation());
1115     int start = tokenLine();
1116     next();
1117     if (match(CLOSEBRACE)) {
1118         unsigned endOffset = m_lexer->currentOffset();
1119         next();
1120         TreeStatement result = context.createBlockStatement(location, 0, start, m_lastTokenEndPosition.line);
1121         context.setEndOffset(result, endOffset);
1122         return result;
1123     }
1124     TreeSourceElements subtree = parseSourceElements(context, DontCheckForStrictMode);
1125     failIfFalse(subtree, "Cannot parse the body of the block statement");
1126     matchOrFail(CLOSEBRACE, "Expected a closing '}' at the end of a block statement");
1127     unsigned endOffset = m_lexer->currentOffset();
1128     next();
1129     TreeStatement result = context.createBlockStatement(location, subtree, start, m_lastTokenEndPosition.line);
1130     context.setEndOffset(result, endOffset);
1131     return result;
1132 }
1133
1134 template <typename LexerType>
1135 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatement(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength)
1136 {
1137     DepthManager statementDepth(&m_statementDepth);
1138     m_statementDepth++;
1139     directive = 0;
1140     int nonTrivialExpressionCount = 0;
1141     failIfStackOverflow();
1142     TreeStatement result = 0;
1143     switch (m_token.m_type) {
1144     case OPENBRACE:
1145         result = parseBlockStatement(context);
1146         break;
1147     case VAR:
1148         result = parseVarDeclaration(context);
1149         break;
1150     case CONSTTOKEN:
1151         result = parseConstDeclaration(context);
1152         break;
1153 #if ENABLE(ES6_CLASS_SYNTAX)
1154     case CLASSTOKEN:
1155         failIfFalse(m_statementDepth == 1, "Class declaration is not allowed in a lexically nested statement");
1156         result = parseClassDeclaration(context);
1157         break;
1158 #endif
1159     case FUNCTION:
1160         failIfFalseIfStrict(m_statementDepth == 1, "Strict mode does not allow function declarations in a lexically nested statement");
1161         result = parseFunctionDeclaration(context);
1162         break;
1163     case SEMICOLON: {
1164         JSTokenLocation location(tokenLocation());
1165         next();
1166         result = context.createEmptyStatement(location);
1167         break;
1168     }
1169     case IF:
1170         result = parseIfStatement(context);
1171         break;
1172     case DO:
1173         result = parseDoWhileStatement(context);
1174         break;
1175     case WHILE:
1176         result = parseWhileStatement(context);
1177         break;
1178     case FOR:
1179         result = parseForStatement(context);
1180         break;
1181     case CONTINUE:
1182         result = parseContinueStatement(context);
1183         break;
1184     case BREAK:
1185         result = parseBreakStatement(context);
1186         break;
1187     case RETURN:
1188         result = parseReturnStatement(context);
1189         break;
1190     case WITH:
1191         result = parseWithStatement(context);
1192         break;
1193     case SWITCH:
1194         result = parseSwitchStatement(context);
1195         break;
1196     case THROW:
1197         result = parseThrowStatement(context);
1198         break;
1199     case TRY:
1200         result = parseTryStatement(context);
1201         break;
1202     case DEBUGGER:
1203         result = parseDebuggerStatement(context);
1204         break;
1205     case EOFTOK:
1206     case CASE:
1207     case CLOSEBRACE:
1208     case DEFAULT:
1209         // These tokens imply the end of a set of source elements
1210         return 0;
1211     case IDENT:
1212         result = parseExpressionOrLabelStatement(context);
1213         break;
1214     case STRING:
1215         directive = m_token.m_data.ident;
1216         if (directiveLiteralLength)
1217             *directiveLiteralLength = m_token.m_location.endOffset - m_token.m_location.startOffset;
1218         nonTrivialExpressionCount = m_nonTrivialExpressionCount;
1219         FALLTHROUGH;
1220     default:
1221         TreeStatement exprStatement = parseExpressionStatement(context);
1222         if (directive && nonTrivialExpressionCount != m_nonTrivialExpressionCount)
1223             directive = 0;
1224         result = exprStatement;
1225         break;
1226     }
1227
1228     if (result)
1229         context.setEndOffset(result, m_lastTokenEndPosition.offset);
1230     return result;
1231 }
1232
1233 template <typename LexerType>
1234 template <class TreeBuilder> TreeFormalParameterList Parser<LexerType>::parseFormalParameters(TreeBuilder& context)
1235 {
1236     auto parameter = parseDeconstructionPattern(context, DeconstructToParameters);
1237     failIfFalse(parameter, "Cannot parse parameter pattern");
1238     TreeFormalParameterList list = context.createFormalParameterList(parameter);
1239     TreeFormalParameterList tail = list;
1240     while (consume(COMMA)) {
1241         parameter = parseDeconstructionPattern(context, DeconstructToParameters);
1242         failIfFalse(parameter, "Cannot parse parameter pattern");
1243         tail = context.createFormalParameterList(tail, parameter);
1244     }
1245     return list;
1246 }
1247
1248 template <typename LexerType>
1249 template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(TreeBuilder& context)
1250 {
1251     JSTokenLocation startLocation(tokenLocation());
1252     unsigned startColumn = tokenColumn();
1253     next();
1254
1255     if (match(CLOSEBRACE)) {
1256         unsigned endColumn = tokenColumn();
1257         return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, strictMode());
1258     }
1259     DepthManager statementDepth(&m_statementDepth);
1260     m_statementDepth = 0;
1261     typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<VM*>(m_vm), m_lexer.get());
1262     failIfFalse(parseSourceElements(bodyBuilder, CheckForStrictMode), "Cannot parse body of this function");
1263     unsigned endColumn = tokenColumn();
1264     return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, strictMode());
1265 }
1266
1267 static const char* stringForFunctionMode(FunctionParseMode mode)
1268 {
1269     switch (mode) {
1270     case GetterMode:
1271         return "getter";
1272     case SetterMode:
1273         return "setter";
1274     case FunctionMode:
1275         return "function";
1276 #if ENABLE(ES6_CLASS_SYNTAX)
1277     case MethodMode:
1278         return "method";
1279 #endif
1280     }
1281     RELEASE_ASSERT_NOT_REACHED();
1282     return nullptr;
1283 }
1284
1285 template <typename LexerType>
1286 template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, FunctionRequirements requirements, FunctionParseMode mode, bool nameIsInContainingScope, ParserFunctionInfo<TreeBuilder>& info)
1287 {
1288     AutoPopScopeRef functionScope(this, pushScope());
1289     functionScope->setIsFunction();
1290     int functionNameStart = m_token.m_location.startOffset;
1291     const Identifier* lastFunctionName = m_lastFunctionName;
1292     m_lastFunctionName = nullptr;
1293     if (match(IDENT)) {
1294         info.name = m_token.m_data.ident;
1295         m_lastFunctionName = info.name;
1296         next();
1297         if (!nameIsInContainingScope)
1298             failIfFalseIfStrict(functionScope->declareVariable(info.name), "'", info.name->impl(), "' is not a valid ", stringForFunctionMode(mode), " name in strict mode");
1299     } else if (requirements == FunctionNeedsName) {
1300         if (match(OPENPAREN) && mode == FunctionMode)
1301             semanticFail("Function statements must have a name");
1302         semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
1303         failDueToUnexpectedToken();
1304         return false;
1305     }
1306     if (!consume(OPENPAREN)) {
1307         semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
1308         failWithMessage("Expected an opening '(' before a ", stringForFunctionMode(mode), "'s parameter list");
1309     }
1310     if (!match(CLOSEPAREN)) {
1311         info.parameters = parseFormalParameters(context);
1312         failIfFalse(info.parameters, "Cannot parse parameters for this ", stringForFunctionMode(mode));
1313     }
1314     consumeOrFail(CLOSEPAREN, "Expected a ')' or a ',' after a parameter declaration");
1315     matchOrFail(OPENBRACE, "Expected an opening '{' at the start of a ", stringForFunctionMode(mode), " body");
1316     
1317     info.openBraceOffset = m_token.m_data.offset;
1318     info.bodyStartLine = tokenLine();
1319     info.bodyStartColumn = m_token.m_data.offset - m_token.m_data.lineStartOffset;
1320     JSTokenLocation startLocation(tokenLocation());
1321     
1322     // If we know about this function already, we can use the cached info and skip the parser to the end of the function.
1323     if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(info.openBraceOffset) : 0) {
1324         // If we're in a strict context, the cached function info must say it was strict too.
1325         ASSERT(!strictMode() || cachedInfo->strictMode);
1326         JSTokenLocation endLocation;
1327
1328         endLocation.line = cachedInfo->closeBraceLine;
1329         endLocation.startOffset = cachedInfo->closeBraceOffset;
1330         endLocation.lineStartOffset = cachedInfo->closeBraceLineStartOffset;
1331
1332         bool endColumnIsOnStartLine = (endLocation.line == info.bodyStartLine);
1333         ASSERT(endLocation.startOffset >= endLocation.lineStartOffset);
1334         unsigned bodyEndColumn = endColumnIsOnStartLine ?
1335             endLocation.startOffset - m_token.m_data.lineStartOffset :
1336             endLocation.startOffset - endLocation.lineStartOffset;
1337         unsigned currentLineStartOffset = m_token.m_location.lineStartOffset;
1338
1339         info.body = context.createFunctionBody(startLocation, endLocation, info.bodyStartColumn, bodyEndColumn, cachedInfo->strictMode);
1340         
1341         functionScope->restoreFromSourceProviderCache(cachedInfo);
1342         failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo), "Parser error");
1343         
1344         info.closeBraceOffset = cachedInfo->closeBraceOffset;
1345
1346         context.setFunctionNameStart(info.body, functionNameStart);
1347         m_token = cachedInfo->closeBraceToken();
1348         if (endColumnIsOnStartLine)
1349             m_token.m_location.lineStartOffset = currentLineStartOffset;
1350
1351         m_lexer->setOffset(m_token.m_location.endOffset, m_token.m_location.lineStartOffset);
1352         m_lexer->setLineNumber(m_token.m_location.line);
1353
1354         context.setEndOffset(info.body, m_lexer->currentOffset());
1355         
1356         next();
1357         info.bodyEndLine = m_lastTokenEndPosition.line;
1358         return true;
1359     }
1360     m_lastFunctionName = lastFunctionName;
1361     ParserState oldState = saveState();
1362     info.body = parseFunctionBody(context);
1363     restoreState(oldState);
1364     failIfFalse(info.body, "Cannot parse the body of this ", stringForFunctionMode(mode));
1365     context.setEndOffset(info.body, m_lexer->currentOffset());
1366     if (functionScope->strictMode() && info.name) {
1367         RELEASE_ASSERT(mode == FunctionMode);
1368         semanticFailIfTrue(m_vm->propertyNames->arguments == *info.name, "'", info.name->impl(), "' is not a valid function name in strict mode");
1369         semanticFailIfTrue(m_vm->propertyNames->eval == *info.name, "'", info.name->impl(), "' is not a valid function name in strict mode");
1370     }
1371     info.closeBraceOffset = m_token.m_data.offset;
1372     unsigned closeBraceLine = m_token.m_data.line;
1373     unsigned closeBraceLineStartOffset = m_token.m_data.lineStartOffset;
1374     
1375     // Cache the tokenizer state and the function scope the first time the function is parsed.
1376     // Any future reparsing can then skip the function.
1377     static const int minimumFunctionLengthToCache = 16;
1378     std::unique_ptr<SourceProviderCacheItem> newInfo;
1379     int functionLength = info.closeBraceOffset - info.openBraceOffset;
1380     if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) {
1381         SourceProviderCacheItemCreationParameters parameters;
1382         parameters.functionNameStart = functionNameStart;
1383         parameters.closeBraceLine = closeBraceLine;
1384         parameters.closeBraceOffset = info.closeBraceOffset;
1385         parameters.closeBraceLineStartOffset = closeBraceLineStartOffset;
1386         functionScope->fillParametersForSourceProviderCache(parameters);
1387         newInfo = SourceProviderCacheItem::create(parameters);
1388
1389     }
1390     context.setFunctionNameStart(info.body, functionNameStart);
1391     
1392     failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo), "Parser error");
1393     matchOrFail(CLOSEBRACE, "Expected a closing '}' after a ", stringForFunctionMode(mode), " body");
1394     
1395     if (newInfo)
1396         m_functionCache->add(info.openBraceOffset, WTF::move(newInfo));
1397     
1398     next();
1399     info.bodyEndLine = m_lastTokenEndPosition.line;
1400     return true;
1401 }
1402
1403 template <typename LexerType>
1404 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context)
1405 {
1406     ASSERT(match(FUNCTION));
1407     JSTokenLocation location(tokenLocation());
1408     unsigned functionKeywordStart = tokenStart();
1409     next();
1410     ParserFunctionInfo<TreeBuilder> info;
1411     failIfFalse((parseFunctionInfo(context, FunctionNeedsName, FunctionMode, true, info)), "Cannot parse this function");
1412     failIfFalse(info.name, "Function statements must have a name");
1413     failIfFalseIfStrict(declareVariable(info.name), "Cannot declare a function named '", info.name->impl(), "' in strict mode");
1414     return context.createFuncDeclStatement(location, info, functionKeywordStart);
1415 }
1416
1417 #if ENABLE(ES6_CLASS_SYNTAX)
1418 template <typename LexerType>
1419 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseClassDeclaration(TreeBuilder& context)
1420 {
1421     ASSERT(match(CLASSTOKEN));
1422     JSTokenLocation location(tokenLocation());
1423     JSTextPosition classStart = tokenStartPosition();
1424     unsigned classStartLine = tokenLine();
1425
1426     TreeClassExpression classExpr = parseClass(context, FunctionNeedsName);
1427     failIfFalse(classExpr, "Failed to parse class");
1428
1429     JSTextPosition classEnd = lastTokenEndPosition();
1430     unsigned classEndLine = tokenLine();
1431
1432     return context.createClassDeclStatement(location, classExpr, classStart, classEnd, classStartLine, classEndLine);
1433 }
1434
1435 template <typename LexerType>
1436 template <class TreeBuilder> TreeClassExpression Parser<LexerType>::parseClass(TreeBuilder& context, FunctionRequirements requirements)
1437 {
1438     ASSERT(match(CLASSTOKEN));
1439     JSTokenLocation location(tokenLocation());
1440     next();
1441
1442     AutoPopScopeRef classScope(this, pushScope());
1443     classScope->setStrictMode();
1444
1445     const Identifier* className = nullptr;
1446     if (match(IDENT)) {
1447         className = m_token.m_data.ident;
1448         next();
1449         failIfFalse(classScope->declareVariable(className), "'", className->impl(), "' is not a valid class name");
1450     } else if (requirements == FunctionNeedsName) {
1451         semanticFailureDueToKeyword("class name");
1452         failDueToUnexpectedToken();
1453     } else
1454         className = &m_vm->propertyNames->nullIdentifier;
1455     ASSERT(className);
1456
1457     TreeExpression parentClass = 0;
1458     if (consume(EXTENDS)) {
1459         parentClass = parsePrimaryExpression(context);
1460         failIfFalse(parentClass, "Cannot parse the parent class name");
1461         failWithMessage("Inheritance is not supported yet");
1462     }
1463
1464     consumeOrFailWithFlags(OPENBRACE, TreeBuilder::DontBuildStrings, "Expected opening '{' at the start of a class body");
1465
1466     TreeExpression constructor = 0;
1467     TreePropertyList staticMethods = 0;
1468     TreePropertyList instanceMethods = 0;
1469     TreePropertyList instanceMethodsTail = 0;
1470     TreePropertyList staticMethodsTail = 0;
1471     while (!match(CLOSEBRACE)) {
1472         if (match(SEMICOLON))
1473             next();
1474
1475         JSTokenLocation methodLocation(tokenLocation());
1476         unsigned methodStart = tokenStart();
1477
1478         bool isStaticMethod = match(STATICTOKEN);
1479         if (isStaticMethod)
1480             next();
1481
1482         matchOrFail(IDENT, "Expected an indentifier");
1483
1484         const CommonIdentifiers& propertyNames = *m_vm->propertyNames;
1485         const Identifier& ident = *m_token.m_data.ident;
1486         bool isGetter = ident == propertyNames.get;
1487         bool isSetter = ident == propertyNames.set;
1488
1489         TreeProperty property;
1490         const bool alwaysStrictInsideClass = true;
1491         if (isGetter || isSetter) {
1492             semanticFailIfTrue(isStaticMethod, "Cannot declare a static", stringForFunctionMode(isGetter ? GetterMode : SetterMode));
1493             nextExpectIdentifier(LexerFlagsIgnoreReservedWords);
1494             property = parseGetterSetter(context, alwaysStrictInsideClass, isGetter ? PropertyNode::Getter : PropertyNode::Setter, methodStart);
1495             failIfFalse(property, "Cannot parse this method");
1496         } else {
1497             ParserFunctionInfo<TreeBuilder> methodInfo;
1498             failIfFalse((parseFunctionInfo(context, FunctionNeedsName, FunctionMode, false, methodInfo)), "Cannot parse this method");
1499             failIfFalse(methodInfo.name, "method must have a name");
1500             failIfFalse(declareVariable(methodInfo.name), "Cannot declare a method named '", methodInfo.name->impl(), "'");
1501
1502             bool isConstructor = !isStaticMethod && *methodInfo.name == propertyNames.constructor;
1503             if (isConstructor)
1504                 methodInfo.name = className;
1505
1506             TreeExpression method = context.createFunctionExpr(methodLocation, methodInfo, methodStart);
1507             if (isConstructor) {
1508                 semanticFailIfTrue(constructor, "Cannot declare multiple constructors in a single class");
1509                 constructor = method;
1510                 continue;
1511             }
1512
1513             // FIXME: Syntax error when super() is called
1514             semanticFailIfTrue(isStaticMethod && *methodInfo.name == propertyNames.prototype,
1515                 "Cannot declare a static method named 'prototype'");
1516             property = context.createProperty(methodInfo.name, method, PropertyNode::Constant, alwaysStrictInsideClass);
1517         }
1518
1519         TreePropertyList& tail = isStaticMethod ? staticMethodsTail : instanceMethodsTail;
1520         if (tail)
1521             tail = context.createPropertyList(methodLocation, property, tail);
1522         else {
1523             tail = context.createPropertyList(methodLocation, property);
1524             if (isStaticMethod)
1525                 staticMethods = tail;
1526             else
1527                 instanceMethods = tail;
1528         }
1529     }
1530
1531     // FIXME: Create a Miranda function instead.
1532     semanticFailIfFalse(constructor, "Class declaration without a constructor is not supported yet");
1533
1534     consumeOrFail(CLOSEBRACE, "Expected a closing '}' after a class body");
1535
1536     return context.createClassExpr(location, *className, constructor, parentClass, instanceMethods, staticMethods);
1537 }
1538 #endif
1539
1540 struct LabelInfo {
1541     LabelInfo(const Identifier* ident, const JSTextPosition& start, const JSTextPosition& end)
1542     : m_ident(ident)
1543     , m_start(start)
1544     , m_end(end)
1545     {
1546     }
1547     
1548     const Identifier* m_ident;
1549     JSTextPosition m_start;
1550     JSTextPosition m_end;
1551 };
1552
1553 template <typename LexerType>
1554 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrLabelStatement(TreeBuilder& context)
1555 {
1556     
1557     /* Expression and Label statements are ambiguous at LL(1), so we have a
1558      * special case that looks for a colon as the next character in the input.
1559      */
1560     Vector<LabelInfo> labels;
1561     JSTokenLocation location;
1562     do {
1563         JSTextPosition start = tokenStartPosition();
1564         location = tokenLocation();
1565         if (!nextTokenIsColon()) {
1566             // If we hit this path we're making a expression statement, which
1567             // by definition can't make use of continue/break so we can just
1568             // ignore any labels we might have accumulated.
1569             TreeExpression expression = parseExpression(context);
1570             failIfFalse(expression, "Cannot parse expression statement");
1571             if (!autoSemiColon())
1572                 failDueToUnexpectedToken();
1573             return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
1574         }
1575         const Identifier* ident = m_token.m_data.ident;
1576         JSTextPosition end = tokenEndPosition();
1577         next();
1578         consumeOrFail(COLON, "Labels must be followed by a ':'");
1579         if (!m_syntaxAlreadyValidated) {
1580             // This is O(N^2) over the current list of consecutive labels, but I
1581             // have never seen more than one label in a row in the real world.
1582             for (size_t i = 0; i < labels.size(); i++)
1583                 failIfTrue(ident->impl() == labels[i].m_ident->impl(), "Attempted to redeclare the label '", ident->impl(), "'");
1584             failIfTrue(getLabel(ident), "Cannot find scope for the label '", ident->impl(), "'");
1585             labels.append(LabelInfo(ident, start, end));
1586         }
1587     } while (match(IDENT));
1588     bool isLoop = false;
1589     switch (m_token.m_type) {
1590     case FOR:
1591     case WHILE:
1592     case DO:
1593         isLoop = true;
1594         break;
1595         
1596     default:
1597         break;
1598     }
1599     const Identifier* unused = 0;
1600     if (!m_syntaxAlreadyValidated) {
1601         for (size_t i = 0; i < labels.size(); i++)
1602             pushLabel(labels[i].m_ident, isLoop);
1603     }
1604     TreeStatement statement = parseStatement(context, unused);
1605     if (!m_syntaxAlreadyValidated) {
1606         for (size_t i = 0; i < labels.size(); i++)
1607             popLabel();
1608     }
1609     failIfFalse(statement, "Cannot parse statement");
1610     for (size_t i = 0; i < labels.size(); i++) {
1611         const LabelInfo& info = labels[labels.size() - i - 1];
1612         statement = context.createLabelStatement(location, info.m_ident, statement, info.m_start, info.m_end);
1613     }
1614     return statement;
1615 }
1616
1617 template <typename LexerType>
1618 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionStatement(TreeBuilder& context)
1619 {
1620     JSTextPosition start = tokenStartPosition();
1621     JSTokenLocation location(tokenLocation());
1622     TreeExpression expression = parseExpression(context);
1623     failIfFalse(expression, "Cannot parse expression statement");
1624     failIfFalse(autoSemiColon(), "Parse error");
1625     return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
1626 }
1627
1628 template <typename LexerType>
1629 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(TreeBuilder& context)
1630 {
1631     ASSERT(match(IF));
1632     JSTokenLocation ifLocation(tokenLocation());
1633     int start = tokenLine();
1634     next();
1635     handleProductionOrFail(OPENPAREN, "(", "start", "'if' condition");
1636
1637     TreeExpression condition = parseExpression(context);
1638     failIfFalse(condition, "Expected a expression as the condition for an if statement");
1639     int end = tokenLine();
1640     handleProductionOrFail(CLOSEPAREN, ")", "end", "'if' condition");
1641
1642     const Identifier* unused = 0;
1643     TreeStatement trueBlock = parseStatement(context, unused);
1644     failIfFalse(trueBlock, "Expected a statement as the body of an if block");
1645
1646     if (!match(ELSE))
1647         return context.createIfStatement(ifLocation, condition, trueBlock, 0, start, end);
1648
1649     Vector<TreeExpression> exprStack;
1650     Vector<std::pair<int, int>> posStack;
1651     Vector<JSTokenLocation> tokenLocationStack;
1652     Vector<TreeStatement> statementStack;
1653     bool trailingElse = false;
1654     do {
1655         JSTokenLocation tempLocation = tokenLocation();
1656         next();
1657         if (!match(IF)) {
1658             const Identifier* unused = 0;
1659             TreeStatement block = parseStatement(context, unused);
1660             failIfFalse(block, "Expected a statement as the body of an else block");
1661             statementStack.append(block);
1662             trailingElse = true;
1663             break;
1664         }
1665         int innerStart = tokenLine();
1666         next();
1667         
1668         handleProductionOrFail(OPENPAREN, "(", "start", "'if' condition");
1669
1670         TreeExpression innerCondition = parseExpression(context);
1671         failIfFalse(innerCondition, "Expected a expression as the condition for an if statement");
1672         int innerEnd = tokenLine();
1673         handleProductionOrFail(CLOSEPAREN, ")", "end", "'if' condition");
1674         const Identifier* unused = 0;
1675         TreeStatement innerTrueBlock = parseStatement(context, unused);
1676         failIfFalse(innerTrueBlock, "Expected a statement as the body of an if block");
1677         tokenLocationStack.append(tempLocation);
1678         exprStack.append(innerCondition);
1679         posStack.append(std::make_pair(innerStart, innerEnd));
1680         statementStack.append(innerTrueBlock);
1681     } while (match(ELSE));
1682
1683     if (!trailingElse) {
1684         TreeExpression condition = exprStack.last();
1685         exprStack.removeLast();
1686         TreeStatement trueBlock = statementStack.last();
1687         statementStack.removeLast();
1688         std::pair<int, int> pos = posStack.last();
1689         posStack.removeLast();
1690         JSTokenLocation elseLocation = tokenLocationStack.last();
1691         tokenLocationStack.removeLast();
1692         TreeStatement ifStatement = context.createIfStatement(elseLocation, condition, trueBlock, 0, pos.first, pos.second);
1693         context.setEndOffset(ifStatement, context.endOffset(trueBlock));
1694         statementStack.append(ifStatement);
1695     }
1696
1697     while (!exprStack.isEmpty()) {
1698         TreeExpression condition = exprStack.last();
1699         exprStack.removeLast();
1700         TreeStatement falseBlock = statementStack.last();
1701         statementStack.removeLast();
1702         TreeStatement trueBlock = statementStack.last();
1703         statementStack.removeLast();
1704         std::pair<int, int> pos = posStack.last();
1705         posStack.removeLast();
1706         JSTokenLocation elseLocation = tokenLocationStack.last();
1707         tokenLocationStack.removeLast();
1708         TreeStatement ifStatement = context.createIfStatement(elseLocation, condition, trueBlock, falseBlock, pos.first, pos.second);
1709         context.setEndOffset(ifStatement, context.endOffset(falseBlock));
1710         statementStack.append(ifStatement);
1711     }
1712
1713     return context.createIfStatement(ifLocation, condition, trueBlock, statementStack.last(), start, end);
1714 }
1715
1716 template <typename LexerType>
1717 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseExpression(TreeBuilder& context)
1718 {
1719     failIfStackOverflow();
1720     JSTokenLocation location(tokenLocation());
1721     TreeExpression node = parseAssignmentExpression(context);
1722     failIfFalse(node, "Cannot parse expression");
1723     context.setEndOffset(node, m_lastTokenEndPosition.offset);
1724     if (!match(COMMA))
1725         return node;
1726     next();
1727     m_nonTrivialExpressionCount++;
1728     m_nonLHSCount++;
1729     TreeExpression right = parseAssignmentExpression(context);
1730     failIfFalse(right, "Cannot parse expression in a comma expression");
1731     context.setEndOffset(right, m_lastTokenEndPosition.offset);
1732     typename TreeBuilder::Comma head = context.createCommaExpr(location, node);
1733     typename TreeBuilder::Comma tail = context.appendToCommaExpr(location, head, head, right);
1734     while (match(COMMA)) {
1735         next(TreeBuilder::DontBuildStrings);
1736         right = parseAssignmentExpression(context);
1737         failIfFalse(right, "Cannot parse expression in a comma expression");
1738         context.setEndOffset(right, m_lastTokenEndPosition.offset);
1739         tail = context.appendToCommaExpr(location, head, tail, right);
1740     }
1741     context.setEndOffset(head, m_lastTokenEndPosition.offset);
1742     return head;
1743 }
1744
1745 template <typename LexerType>
1746 template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpression(TreeBuilder& context)
1747 {
1748     failIfStackOverflow();
1749     JSTextPosition start = tokenStartPosition();
1750     JSTokenLocation location(tokenLocation());
1751     int initialAssignmentCount = m_assignmentCount;
1752     int initialNonLHSCount = m_nonLHSCount;
1753     if (match(OPENBRACE) || match(OPENBRACKET)) {
1754         SavePoint savePoint = createSavePoint();
1755         auto pattern = tryParseDeconstructionPatternExpression(context);
1756         if (pattern && consume(EQUAL)) {
1757             auto rhs = parseAssignmentExpression(context);
1758             if (rhs)
1759                 return context.createDeconstructingAssignment(location, pattern, rhs);
1760         }
1761         restoreSavePoint(savePoint);
1762     }
1763     TreeExpression lhs = parseConditionalExpression(context);
1764     failIfFalse(lhs, "Cannot parse expression");
1765     if (initialNonLHSCount != m_nonLHSCount) {
1766         if (m_token.m_type >= EQUAL && m_token.m_type <= OREQUAL)
1767             semanticFail("Left hand side of operator '", getToken(), "' must be a reference");
1768
1769         return lhs;
1770     }
1771     
1772     int assignmentStack = 0;
1773     Operator op;
1774     bool hadAssignment = false;
1775     while (true) {
1776         switch (m_token.m_type) {
1777         case EQUAL: op = OpEqual; break;
1778         case PLUSEQUAL: op = OpPlusEq; break;
1779         case MINUSEQUAL: op = OpMinusEq; break;
1780         case MULTEQUAL: op = OpMultEq; break;
1781         case DIVEQUAL: op = OpDivEq; break;
1782         case LSHIFTEQUAL: op = OpLShift; break;
1783         case RSHIFTEQUAL: op = OpRShift; break;
1784         case URSHIFTEQUAL: op = OpURShift; break;
1785         case ANDEQUAL: op = OpAndEq; break;
1786         case XOREQUAL: op = OpXOrEq; break;
1787         case OREQUAL: op = OpOrEq; break;
1788         case MODEQUAL: op = OpModEq; break;
1789         default:
1790             goto end;
1791         }
1792         m_nonTrivialExpressionCount++;
1793         hadAssignment = true;
1794         context.assignmentStackAppend(assignmentStack, lhs, start, tokenStartPosition(), m_assignmentCount, op);
1795         start = tokenStartPosition();
1796         m_assignmentCount++;
1797         next(TreeBuilder::DontBuildStrings);
1798         if (strictMode() && m_lastIdentifier && context.isResolve(lhs)) {
1799             failIfTrueIfStrict(m_vm->propertyNames->eval == *m_lastIdentifier, "Cannot modify 'eval' in strict mode");
1800             failIfTrueIfStrict(m_vm->propertyNames->arguments == *m_lastIdentifier, "Cannot modify 'arguments' in strict mode");
1801             declareWrite(m_lastIdentifier);
1802             m_lastIdentifier = 0;
1803         }
1804         lhs = parseAssignmentExpression(context);
1805         failIfFalse(lhs, "Cannot parse the right hand side of an assignment expression");
1806         if (initialNonLHSCount != m_nonLHSCount) {
1807             if (m_token.m_type >= EQUAL && m_token.m_type <= OREQUAL)
1808                 semanticFail("Left hand side of operator '", getToken(), "' must be a reference");
1809             break;
1810         }
1811     }
1812 end:
1813     if (hadAssignment)
1814         m_nonLHSCount++;
1815     
1816     if (!TreeBuilder::CreatesAST)
1817         return lhs;
1818     
1819     while (assignmentStack)
1820         lhs = context.createAssignment(location, assignmentStack, lhs, initialAssignmentCount, m_assignmentCount, lastTokenEndPosition());
1821     
1822     return lhs;
1823 }
1824
1825 template <typename LexerType>
1826 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalExpression(TreeBuilder& context)
1827 {
1828     JSTokenLocation location(tokenLocation());
1829     TreeExpression cond = parseBinaryExpression(context);
1830     failIfFalse(cond, "Cannot parse expression");
1831     if (!match(QUESTION))
1832         return cond;
1833     m_nonTrivialExpressionCount++;
1834     m_nonLHSCount++;
1835     next(TreeBuilder::DontBuildStrings);
1836     TreeExpression lhs = parseAssignmentExpression(context);
1837     failIfFalse(lhs, "Cannot parse left hand side of ternary operator");
1838     context.setEndOffset(lhs, m_lastTokenEndPosition.offset);
1839     consumeOrFailWithFlags(COLON, TreeBuilder::DontBuildStrings, "Expected ':' in ternary operator");
1840     
1841     TreeExpression rhs = parseAssignmentExpression(context);
1842     failIfFalse(rhs, "Cannot parse right hand side of ternary operator");
1843     context.setEndOffset(rhs, m_lastTokenEndPosition.offset);
1844     return context.createConditionalExpr(location, cond, lhs, rhs);
1845 }
1846
1847 ALWAYS_INLINE static bool isUnaryOp(JSTokenType token)
1848 {
1849     return token & UnaryOpTokenFlag;
1850 }
1851
1852 template <typename LexerType>
1853 int Parser<LexerType>::isBinaryOperator(JSTokenType token)
1854 {
1855     if (m_allowsIn)
1856         return token & (BinaryOpTokenPrecedenceMask << BinaryOpTokenAllowsInPrecedenceAdditionalShift);
1857     return token & BinaryOpTokenPrecedenceMask;
1858 }
1859
1860 template <typename LexerType>
1861 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseBinaryExpression(TreeBuilder& context)
1862 {
1863     
1864     int operandStackDepth = 0;
1865     int operatorStackDepth = 0;
1866     typename TreeBuilder::BinaryExprContext binaryExprContext(context);
1867     JSTokenLocation location(tokenLocation());
1868     while (true) {
1869         JSTextPosition exprStart = tokenStartPosition();
1870         int initialAssignments = m_assignmentCount;
1871         TreeExpression current = parseUnaryExpression(context);
1872         failIfFalse(current, "Cannot parse expression");
1873         
1874         context.appendBinaryExpressionInfo(operandStackDepth, current, exprStart, lastTokenEndPosition(), lastTokenEndPosition(), initialAssignments != m_assignmentCount);
1875         int precedence = isBinaryOperator(m_token.m_type);
1876         if (!precedence)
1877             break;
1878         m_nonTrivialExpressionCount++;
1879         m_nonLHSCount++;
1880         int operatorToken = m_token.m_type;
1881         next(TreeBuilder::DontBuildStrings);
1882         
1883         while (operatorStackDepth &&  context.operatorStackHasHigherPrecedence(operatorStackDepth, precedence)) {
1884             ASSERT(operandStackDepth > 1);
1885             
1886             typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
1887             typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
1888             context.shrinkOperandStackBy(operandStackDepth, 2);
1889             context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
1890             context.operatorStackPop(operatorStackDepth);
1891         }
1892         context.operatorStackAppend(operatorStackDepth, operatorToken, precedence);
1893     }
1894     while (operatorStackDepth) {
1895         ASSERT(operandStackDepth > 1);
1896         
1897         typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
1898         typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
1899         context.shrinkOperandStackBy(operandStackDepth, 2);
1900         context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
1901         context.operatorStackPop(operatorStackDepth);
1902     }
1903     return context.popOperandStack(operandStackDepth);
1904 }
1905
1906 template <typename LexerType>
1907 template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeBuilder& context, bool complete)
1908 {
1909     bool wasIdent = false;
1910     switch (m_token.m_type) {
1911     namedProperty:
1912     case IDENT:
1913         wasIdent = true;
1914         FALLTHROUGH;
1915     case STRING: {
1916         const Identifier* ident = m_token.m_data.ident;
1917         unsigned getterOrSetterStartOffset = tokenStart();
1918         if (complete || (wasIdent && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set)))
1919             nextExpectIdentifier(LexerFlagsIgnoreReservedWords);
1920         else
1921             nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
1922         
1923         if (match(COLON)) {
1924             next();
1925             TreeExpression node = parseAssignmentExpression(context);
1926             failIfFalse(node, "Cannot parse expression for property declaration");
1927             context.setEndOffset(node, m_lexer->currentOffset());
1928             return context.createProperty(ident, node, PropertyNode::Constant, complete);
1929         }
1930         failIfFalse(wasIdent, "Expected an identifier as property name");
1931         PropertyNode::Type type;
1932         if (*ident == m_vm->propertyNames->get)
1933             type = PropertyNode::Getter;
1934         else if (*ident == m_vm->propertyNames->set)
1935             type = PropertyNode::Setter;
1936         else
1937             failWithMessage("Expected a ':' following the property name '", ident->impl(), "'");
1938         return parseGetterSetter(context, complete, type, getterOrSetterStartOffset);
1939     }
1940     case NUMBER: {
1941         double propertyName = m_token.m_data.doubleValue;
1942         next();
1943         consumeOrFail(COLON, "Expected ':' after property name");
1944         TreeExpression node = parseAssignmentExpression(context);
1945         failIfFalse(node, "Cannot parse expression for property declaration");
1946         context.setEndOffset(node, m_lexer->currentOffset());
1947         return context.createProperty(const_cast<VM*>(m_vm), m_parserArena, propertyName, node, PropertyNode::Constant, complete);
1948     }
1949     case OPENBRACKET: {
1950         next();
1951         auto propertyName = parseExpression(context);
1952         failIfFalse(propertyName, "Cannot parse computed property name");
1953         
1954         handleProductionOrFail(CLOSEBRACKET, "]", "end", "computed property name");
1955         consumeOrFail(COLON, "Expected ':' after property name");
1956         TreeExpression node = parseAssignmentExpression(context);
1957         failIfFalse(node, "Cannot parse expression for property declaration");
1958         context.setEndOffset(node, m_lexer->currentOffset());
1959         return context.createProperty(propertyName, node, PropertyNode::Constant, complete);
1960     }
1961     default:
1962         failIfFalse(m_token.m_type & KeywordTokenFlag, "Expected a property name");
1963         goto namedProperty;
1964     }
1965 }
1966
1967 template <typename LexerType>
1968 template <class TreeBuilder> TreeProperty Parser<LexerType>::parseGetterSetter(TreeBuilder& context, bool strict, PropertyNode::Type type, unsigned getterOrSetterStartOffset)
1969 {
1970     const Identifier* stringPropertyName = 0;
1971     double numericPropertyName = 0;
1972     if (m_token.m_type == IDENT || m_token.m_type == STRING)
1973         stringPropertyName = m_token.m_data.ident;
1974     else if (m_token.m_type == NUMBER)
1975         numericPropertyName = m_token.m_data.doubleValue;
1976     else
1977         failDueToUnexpectedToken();
1978     JSTokenLocation location(tokenLocation());
1979     next();
1980     ParserFunctionInfo<TreeBuilder> info;
1981     if (type == PropertyNode::Getter) {
1982         failIfFalse(match(OPENPAREN), "Expected a parameter list for getter definition");
1983         failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, GetterMode, false, info)), "Cannot parse getter definition");
1984     } else {
1985         failIfFalse(match(OPENPAREN), "Expected a parameter list for setter definition");
1986         failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SetterMode, false, info)), "Cannot parse setter definition");
1987     }
1988     if (stringPropertyName)
1989         return context.createGetterOrSetterProperty(location, type, strict, stringPropertyName, info, getterOrSetterStartOffset);
1990     return context.createGetterOrSetterProperty(const_cast<VM*>(m_vm), m_parserArena, location, type, strict, numericPropertyName, info, getterOrSetterStartOffset);
1991 }
1992
1993 template <typename LexerType>
1994 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseObjectLiteral(TreeBuilder& context)
1995 {
1996     auto savePoint = createSavePoint();
1997     consumeOrFailWithFlags(OPENBRACE, TreeBuilder::DontBuildStrings, "Expected opening '{' at the start of an object literal");
1998     JSTokenLocation location(tokenLocation());
1999
2000     int oldNonLHSCount = m_nonLHSCount;
2001     
2002     if (match(CLOSEBRACE)) {
2003         next();
2004         return context.createObjectLiteral(location);
2005     }
2006     
2007     TreeProperty property = parseProperty(context, false);
2008     failIfFalse(property, "Cannot parse object literal property");
2009     if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
2010         restoreSavePoint(savePoint);
2011         return parseStrictObjectLiteral(context);
2012     }
2013     TreePropertyList propertyList = context.createPropertyList(location, property);
2014     TreePropertyList tail = propertyList;
2015     while (match(COMMA)) {
2016         next(TreeBuilder::DontBuildStrings);
2017         // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
2018         if (match(CLOSEBRACE))
2019             break;
2020         JSTokenLocation propertyLocation(tokenLocation());
2021         property = parseProperty(context, false);
2022         failIfFalse(property, "Cannot parse object literal property");
2023         if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
2024             restoreSavePoint(savePoint);
2025             return parseStrictObjectLiteral(context);
2026         }
2027         tail = context.createPropertyList(propertyLocation, property, tail);
2028     }
2029
2030     location = tokenLocation();
2031     handleProductionOrFail(CLOSEBRACE, "}", "end", "object literal");
2032     
2033     m_nonLHSCount = oldNonLHSCount;
2034     
2035     return context.createObjectLiteral(location, propertyList);
2036 }
2037
2038 template <typename LexerType>
2039 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseStrictObjectLiteral(TreeBuilder& context)
2040 {
2041     consumeOrFail(OPENBRACE, "Expected opening '{' at the start of an object literal");
2042     
2043     int oldNonLHSCount = m_nonLHSCount;
2044
2045     JSTokenLocation location(tokenLocation());
2046     if (match(CLOSEBRACE)) {
2047         next();
2048         return context.createObjectLiteral(location);
2049     }
2050     
2051     TreeProperty property = parseProperty(context, true);
2052     failIfFalse(property, "Cannot parse object literal property");
2053     
2054     typedef HashMap<RefPtr<StringImpl>, unsigned, IdentifierRepHash> ObjectValidationMap;
2055     ObjectValidationMap objectValidator;
2056     // Add the first property
2057     if (!m_syntaxAlreadyValidated && context.getName(property))
2058         objectValidator.add(context.getName(property)->impl(), context.getType(property));
2059     
2060     TreePropertyList propertyList = context.createPropertyList(location, property);
2061     TreePropertyList tail = propertyList;
2062     while (match(COMMA)) {
2063         next();
2064         // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
2065         if (match(CLOSEBRACE))
2066             break;
2067         JSTokenLocation propertyLocation(tokenLocation());
2068         property = parseProperty(context, true);
2069         failIfFalse(property, "Cannot parse object literal property");
2070         if (!m_syntaxAlreadyValidated && context.getName(property)) {
2071             ObjectValidationMap::AddResult propertyEntry = objectValidator.add(context.getName(property)->impl(), context.getType(property));
2072             if (!propertyEntry.isNewEntry) {
2073                 semanticFailIfTrue(propertyEntry.iterator->value == PropertyNode::Constant, "Attempted to redefine property '", propertyEntry.iterator->key.get(), "'");
2074                 semanticFailIfTrue(context.getType(property) == PropertyNode::Constant, "Attempted to redefine property '", propertyEntry.iterator->key.get(), "'");
2075                 semanticFailIfTrue(context.getType(property) & propertyEntry.iterator->value, "Attempted to redefine property '", propertyEntry.iterator->key.get(), "'");
2076                 propertyEntry.iterator->value |= context.getType(property);
2077             }
2078         }
2079         tail = context.createPropertyList(propertyLocation, property, tail);
2080     }
2081
2082     location = tokenLocation();
2083     handleProductionOrFail(CLOSEBRACE, "}", "end", "object literal");
2084
2085     m_nonLHSCount = oldNonLHSCount;
2086
2087     return context.createObjectLiteral(location, propertyList);
2088 }
2089
2090 template <typename LexerType>
2091 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrayLiteral(TreeBuilder& context)
2092 {
2093     consumeOrFailWithFlags(OPENBRACKET, TreeBuilder::DontBuildStrings, "Expected an opening '[' at the beginning of an array literal");
2094     
2095     int oldNonLHSCount = m_nonLHSCount;
2096     
2097     int elisions = 0;
2098     while (match(COMMA)) {
2099         next(TreeBuilder::DontBuildStrings);
2100         elisions++;
2101     }
2102     if (match(CLOSEBRACKET)) {
2103         JSTokenLocation location(tokenLocation());
2104         next(TreeBuilder::DontBuildStrings);
2105         return context.createArray(location, elisions);
2106     }
2107     
2108     TreeExpression elem;
2109     if (UNLIKELY(match(DOTDOTDOT))) {
2110         auto spreadLocation = m_token.m_location;
2111         auto start = m_token.m_startPosition;
2112         auto divot = m_token.m_endPosition;
2113         next();
2114         auto spreadExpr = parseAssignmentExpression(context);
2115         failIfFalse(spreadExpr, "Cannot parse subject of a spread operation");
2116         elem = context.createSpreadExpression(spreadLocation, spreadExpr, start, divot, m_lastTokenEndPosition);
2117     } else
2118         elem = parseAssignmentExpression(context);
2119     failIfFalse(elem, "Cannot parse array literal element");
2120     typename TreeBuilder::ElementList elementList = context.createElementList(elisions, elem);
2121     typename TreeBuilder::ElementList tail = elementList;
2122     elisions = 0;
2123     while (match(COMMA)) {
2124         next(TreeBuilder::DontBuildStrings);
2125         elisions = 0;
2126         
2127         while (match(COMMA)) {
2128             next();
2129             elisions++;
2130         }
2131         
2132         if (match(CLOSEBRACKET)) {
2133             JSTokenLocation location(tokenLocation());
2134             next(TreeBuilder::DontBuildStrings);
2135             return context.createArray(location, elisions, elementList);
2136         }
2137         if (UNLIKELY(match(DOTDOTDOT))) {
2138             auto spreadLocation = m_token.m_location;
2139             auto start = m_token.m_startPosition;
2140             auto divot = m_token.m_endPosition;
2141             next();
2142             TreeExpression elem = parseAssignmentExpression(context);
2143             failIfFalse(elem, "Cannot parse subject of a spread operation");
2144             auto spread = context.createSpreadExpression(spreadLocation, elem, start, divot, m_lastTokenEndPosition);
2145             tail = context.createElementList(tail, elisions, spread);
2146             continue;
2147         }
2148         TreeExpression elem = parseAssignmentExpression(context);
2149         failIfFalse(elem, "Cannot parse array literal element");
2150         tail = context.createElementList(tail, elisions, elem);
2151     }
2152
2153     JSTokenLocation location(tokenLocation());
2154     if (!consume(CLOSEBRACKET)) {
2155         failIfFalse(match(DOTDOTDOT), "Expected either a closing ']' or a ',' following an array element");
2156         semanticFail("The '...' operator should come before a target expression");
2157     }
2158     
2159     m_nonLHSCount = oldNonLHSCount;
2160     
2161     return context.createArray(location, elementList);
2162 }
2163
2164 template <typename LexerType>
2165 template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpression(TreeBuilder& context)
2166 {
2167     failIfStackOverflow();
2168     switch (m_token.m_type) {
2169     case FUNCTION: {
2170         JSTokenLocation location(tokenLocation());
2171         unsigned functionKeywordStart = tokenStart();
2172         next();
2173         ParserFunctionInfo<TreeBuilder> info;
2174         info.name = &m_vm->propertyNames->nullIdentifier;
2175         failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, FunctionMode, false, info)), "Cannot parse function expression");
2176         return context.createFunctionExpr(location, info, functionKeywordStart);
2177     }
2178 #if ENABLE(ES6_CLASS_SYNTAX)
2179     case CLASSTOKEN:
2180         return parseClass(context, FunctionNoRequirements);
2181 #endif
2182     case OPENBRACE:
2183         if (strictMode())
2184             return parseStrictObjectLiteral(context);
2185         return parseObjectLiteral(context);
2186     case OPENBRACKET:
2187         return parseArrayLiteral(context);
2188     case OPENPAREN: {
2189         next();
2190         int oldNonLHSCount = m_nonLHSCount;
2191         TreeExpression result = parseExpression(context);
2192         m_nonLHSCount = oldNonLHSCount;
2193         handleProductionOrFail(CLOSEPAREN, ")", "end", "compound expression");
2194         return result;
2195     }
2196     case THISTOKEN: {
2197         JSTokenLocation location(tokenLocation());
2198         next();
2199         return context.thisExpr(location);
2200     }
2201     case IDENT: {
2202         JSTextPosition start = tokenStartPosition();
2203         const Identifier* ident = m_token.m_data.ident;
2204         JSTokenLocation location(tokenLocation());
2205         next();
2206         currentScope()->useVariable(ident, m_vm->propertyNames->eval == *ident);
2207         m_lastIdentifier = ident;
2208         return context.createResolve(location, ident, start);
2209     }
2210     case STRING: {
2211         const Identifier* ident = m_token.m_data.ident;
2212         JSTokenLocation location(tokenLocation());
2213         next();
2214         return context.createString(location, ident);
2215     }
2216     case NUMBER: {
2217         double d = m_token.m_data.doubleValue;
2218         JSTokenLocation location(tokenLocation());
2219         next();
2220         return context.createNumberExpr(location, d);
2221     }
2222     case NULLTOKEN: {
2223         JSTokenLocation location(tokenLocation());
2224         next();
2225         return context.createNull(location);
2226     }
2227     case TRUETOKEN: {
2228         JSTokenLocation location(tokenLocation());
2229         next();
2230         return context.createBoolean(location, true);
2231     }
2232     case FALSETOKEN: {
2233         JSTokenLocation location(tokenLocation());
2234         next();
2235         return context.createBoolean(location, false);
2236     }
2237     case DIVEQUAL:
2238     case DIVIDE: {
2239         /* regexp */
2240         const Identifier* pattern;
2241         const Identifier* flags;
2242         if (match(DIVEQUAL))
2243             failIfFalse(m_lexer->scanRegExp(pattern, flags, '='), "Invalid regular expression");
2244         else
2245             failIfFalse(m_lexer->scanRegExp(pattern, flags), "Invalid regular expression");
2246         
2247         JSTextPosition start = tokenStartPosition();
2248         JSTokenLocation location(tokenLocation());
2249         next();
2250         TreeExpression re = context.createRegExp(location, *pattern, *flags, start);
2251         if (!re) {
2252             const char* yarrErrorMsg = Yarr::checkSyntax(pattern->string());
2253             regexFail(yarrErrorMsg);
2254         }
2255         return re;
2256     }
2257     default:
2258         failDueToUnexpectedToken();
2259     }
2260 }
2261
2262 template <typename LexerType>
2263 template <class TreeBuilder> TreeArguments Parser<LexerType>::parseArguments(TreeBuilder& context, SpreadMode mode)
2264 {
2265     consumeOrFailWithFlags(OPENPAREN, TreeBuilder::DontBuildStrings, "Expected opening '(' at start of argument list");
2266     JSTokenLocation location(tokenLocation());
2267     if (match(CLOSEPAREN)) {
2268         next(TreeBuilder::DontBuildStrings);
2269         return context.createArguments();
2270     }
2271     if (match(DOTDOTDOT) && mode == AllowSpread) {
2272         JSTokenLocation spreadLocation(tokenLocation());
2273         auto start = m_token.m_startPosition;
2274         auto divot = m_token.m_endPosition;
2275         next();
2276         auto spreadExpr = parseAssignmentExpression(context);
2277         auto end = m_lastTokenEndPosition;
2278         if (!spreadExpr)
2279             failWithMessage("Cannot parse spread expression");
2280         if (!consume(CLOSEPAREN)) {
2281             if (match(COMMA))
2282                 semanticFail("Spread operator may only be applied to the last argument passed to a function");
2283             handleProductionOrFail(CLOSEPAREN, ")", "end", "argument list");
2284         }
2285         auto spread = context.createSpreadExpression(spreadLocation, spreadExpr, start, divot, end);
2286         TreeArgumentsList argList = context.createArgumentsList(location, spread);
2287         return context.createArguments(argList);
2288     }
2289     TreeExpression firstArg = parseAssignmentExpression(context);
2290     failIfFalse(firstArg, "Cannot parse function argument");
2291     
2292     TreeArgumentsList argList = context.createArgumentsList(location, firstArg);
2293     TreeArgumentsList tail = argList;
2294     while (match(COMMA)) {
2295         JSTokenLocation argumentLocation(tokenLocation());
2296         next(TreeBuilder::DontBuildStrings);
2297         TreeExpression arg = parseAssignmentExpression(context);
2298         failIfFalse(arg, "Cannot parse function argument");
2299         tail = context.createArgumentsList(argumentLocation, tail, arg);
2300     }
2301     semanticFailIfTrue(match(DOTDOTDOT), "The '...' operator should come before the target expression");
2302     handleProductionOrFail(CLOSEPAREN, ")", "end", "argument list");
2303     return context.createArguments(argList);
2304 }
2305
2306 template <typename LexerType>
2307 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpression(TreeBuilder& context)
2308 {
2309     TreeExpression base = 0;
2310     JSTextPosition expressionStart = tokenStartPosition();
2311     int newCount = 0;
2312     JSTokenLocation location;
2313     while (match(NEW)) {
2314         next();
2315         newCount++;
2316     }
2317
2318     base = parsePrimaryExpression(context);
2319     
2320     failIfFalse(base, "Cannot parse base expression");
2321     while (true) {
2322         location = tokenLocation();
2323         switch (m_token.m_type) {
2324         case OPENBRACKET: {
2325             m_nonTrivialExpressionCount++;
2326             JSTextPosition expressionEnd = lastTokenEndPosition();
2327             next();
2328             int nonLHSCount = m_nonLHSCount;
2329             int initialAssignments = m_assignmentCount;
2330             TreeExpression property = parseExpression(context);
2331             failIfFalse(property, "Cannot parse subscript expression");
2332             base = context.createBracketAccess(location, base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEndPosition());
2333             handleProductionOrFail(CLOSEBRACKET, "]", "end", "subscript expression");
2334             m_nonLHSCount = nonLHSCount;
2335             break;
2336         }
2337         case OPENPAREN: {
2338             m_nonTrivialExpressionCount++;
2339             int nonLHSCount = m_nonLHSCount;
2340             if (newCount) {
2341                 newCount--;
2342                 JSTextPosition expressionEnd = lastTokenEndPosition();
2343                 TreeArguments arguments = parseArguments(context, AllowSpread);
2344                 failIfFalse(arguments, "Cannot parse call arguments");
2345                 base = context.createNewExpr(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition());
2346             } else {
2347                 JSTextPosition expressionEnd = lastTokenEndPosition();
2348                 TreeArguments arguments = parseArguments(context, AllowSpread);
2349                 failIfFalse(arguments, "Cannot parse call arguments");
2350                 base = context.makeFunctionCallNode(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition());
2351             }
2352             m_nonLHSCount = nonLHSCount;
2353             break;
2354         }
2355         case DOT: {
2356             m_nonTrivialExpressionCount++;
2357             JSTextPosition expressionEnd = lastTokenEndPosition();
2358             nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
2359             matchOrFail(IDENT, "Expected a property name after '.'");
2360             base = context.createDotAccess(location, base, m_token.m_data.ident, expressionStart, expressionEnd, tokenEndPosition());
2361             next();
2362             break;
2363         }
2364         default:
2365             goto endMemberExpression;
2366         }
2367     }
2368 endMemberExpression:
2369     while (newCount--)
2370         base = context.createNewExpr(location, base, expressionStart, lastTokenEndPosition());
2371     return base;
2372 }
2373
2374 static const char* operatorString(bool prefix, unsigned tok)
2375 {
2376     switch (tok) {
2377     case MINUSMINUS:
2378     case AUTOMINUSMINUS:
2379         return prefix ? "prefix-decrement" : "decrement";
2380
2381     case PLUSPLUS:
2382     case AUTOPLUSPLUS:
2383         return prefix ? "prefix-increment" : "increment";
2384
2385     case EXCLAMATION:
2386         return "logical-not";
2387
2388     case TILDE:
2389         return "bitwise-not";
2390     
2391     case TYPEOF:
2392         return "typeof";
2393     
2394     case VOIDTOKEN:
2395         return "void";
2396     
2397     case DELETETOKEN:
2398         return "delete";
2399     }
2400     RELEASE_ASSERT_NOT_REACHED();
2401     return "error";
2402 }
2403
2404 template <typename LexerType>
2405 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpression(TreeBuilder& context)
2406 {
2407     typename TreeBuilder::UnaryExprContext unaryExprContext(context);
2408     AllowInOverride allowInOverride(this);
2409     int tokenStackDepth = 0;
2410     bool modifiesExpr = false;
2411     bool requiresLExpr = false;
2412     unsigned lastOperator = 0;
2413     while (isUnaryOp(m_token.m_type)) {
2414         if (strictMode()) {
2415             switch (m_token.m_type) {
2416             case PLUSPLUS:
2417             case MINUSMINUS:
2418             case AUTOPLUSPLUS:
2419             case AUTOMINUSMINUS:
2420                 semanticFailIfTrue(requiresLExpr, "The ", operatorString(true, lastOperator), " operator requires a reference expression");
2421                 modifiesExpr = true;
2422                 requiresLExpr = true;
2423                 break;
2424             case DELETETOKEN:
2425                 semanticFailIfTrue(requiresLExpr, "The ", operatorString(true, lastOperator), " operator requires a reference expression");
2426                 requiresLExpr = true;
2427                 break;
2428             default:
2429                 semanticFailIfTrue(requiresLExpr, "The ", operatorString(true, lastOperator), " operator requires a reference expression");
2430                 break;
2431             }
2432         }
2433         lastOperator = m_token.m_type;
2434         m_nonLHSCount++;
2435         context.appendUnaryToken(tokenStackDepth, m_token.m_type, tokenStartPosition());
2436         next();
2437         m_nonTrivialExpressionCount++;
2438     }
2439     JSTextPosition subExprStart = tokenStartPosition();
2440     ASSERT(subExprStart.offset >= subExprStart.lineStartOffset);
2441     JSTokenLocation location(tokenLocation());
2442     TreeExpression expr = parseMemberExpression(context);
2443     if (!expr) {
2444         if (lastOperator)
2445             failWithMessage("Cannot parse subexpression of ", operatorString(true, lastOperator), "operator");
2446         failWithMessage("Cannot parse member expression");
2447     }
2448     bool isEvalOrArguments = false;
2449     if (strictMode() && !m_syntaxAlreadyValidated) {
2450         if (context.isResolve(expr))
2451             isEvalOrArguments = *m_lastIdentifier == m_vm->propertyNames->eval || *m_lastIdentifier == m_vm->propertyNames->arguments;
2452     }
2453     failIfTrueIfStrict(isEvalOrArguments && modifiesExpr, "Cannot modify '", m_lastIdentifier->impl(), "' in strict mode");
2454     switch (m_token.m_type) {
2455     case PLUSPLUS:
2456         m_nonTrivialExpressionCount++;
2457         m_nonLHSCount++;
2458         expr = context.makePostfixNode(location, expr, OpPlusPlus, subExprStart, lastTokenEndPosition(), tokenEndPosition());
2459         m_assignmentCount++;
2460         failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", m_lastIdentifier->impl(), "' in strict mode");
2461         semanticFailIfTrue(requiresLExpr, "The ", operatorString(false, lastOperator), " operator requires a reference expression");
2462         lastOperator = PLUSPLUS;
2463         next();
2464         break;
2465     case MINUSMINUS:
2466         m_nonTrivialExpressionCount++;
2467         m_nonLHSCount++;
2468         expr = context.makePostfixNode(location, expr, OpMinusMinus, subExprStart, lastTokenEndPosition(), tokenEndPosition());
2469         m_assignmentCount++;
2470         failIfTrueIfStrict(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
2471         semanticFailIfTrue(requiresLExpr, "The ", operatorString(false, lastOperator), " operator requires a reference expression");
2472         lastOperator = PLUSPLUS;
2473         next();
2474         break;
2475     default:
2476         break;
2477     }
2478     
2479     JSTextPosition end = lastTokenEndPosition();
2480
2481     if (!TreeBuilder::CreatesAST && (m_syntaxAlreadyValidated || !strictMode()))
2482         return expr;
2483
2484     location = tokenLocation();
2485     location.line = m_lexer->lastLineNumber();
2486     while (tokenStackDepth) {
2487         switch (context.unaryTokenStackLastType(tokenStackDepth)) {
2488         case EXCLAMATION:
2489             expr = context.createLogicalNot(location, expr);
2490             break;
2491         case TILDE:
2492             expr = context.makeBitwiseNotNode(location, expr);
2493             break;
2494         case MINUS:
2495             expr = context.makeNegateNode(location, expr);
2496             break;
2497         case PLUS:
2498             expr = context.createUnaryPlus(location, expr);
2499             break;
2500         case PLUSPLUS:
2501         case AUTOPLUSPLUS:
2502             expr = context.makePrefixNode(location, expr, OpPlusPlus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
2503             m_assignmentCount++;
2504             break;
2505         case MINUSMINUS:
2506         case AUTOMINUSMINUS:
2507             expr = context.makePrefixNode(location, expr, OpMinusMinus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
2508             m_assignmentCount++;
2509             break;
2510         case TYPEOF:
2511             expr = context.makeTypeOfNode(location, expr);
2512             break;
2513         case VOIDTOKEN:
2514             expr = context.createVoid(location, expr);
2515             break;
2516         case DELETETOKEN:
2517             failIfTrueIfStrict(context.isResolve(expr), "Cannot delete unqualified property '", m_lastIdentifier->impl(), "' in strict mode");
2518             expr = context.makeDeleteNode(location, expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end);
2519             break;
2520         default:
2521             // If we get here something has gone horribly horribly wrong
2522             CRASH();
2523         }
2524         subExprStart = context.unaryTokenStackLastStart(tokenStackDepth);
2525         context.unaryTokenStackRemoveLast(tokenStackDepth);
2526     }
2527     return expr;
2528 }
2529
2530
2531 template <typename LexerType> void Parser<LexerType>::printUnexpectedTokenText(WTF::PrintStream& out)
2532 {
2533     switch (m_token.m_type) {
2534     case EOFTOK:
2535         out.print("Unexpected end of script");
2536         return;
2537     case UNTERMINATED_IDENTIFIER_ESCAPE_ERRORTOK:
2538     case UNTERMINATED_IDENTIFIER_UNICODE_ESCAPE_ERRORTOK:
2539         out.print("Incomplete unicode escape in identifier: '", getToken(), "'");
2540         return;
2541     case UNTERMINATED_MULTILINE_COMMENT_ERRORTOK:
2542         out.print("Unterminated multiline comment");
2543         return;
2544     case UNTERMINATED_NUMERIC_LITERAL_ERRORTOK:
2545         out.print("Unterminated numeric literal '", getToken(), "'");
2546         return;
2547     case UNTERMINATED_STRING_LITERAL_ERRORTOK:
2548         out.print("Unterminated string literal '", getToken(), "'");
2549         return;
2550     case INVALID_IDENTIFIER_ESCAPE_ERRORTOK:
2551         out.print("Invalid escape in identifier: '", getToken(), "'");
2552         return;
2553     case INVALID_IDENTIFIER_UNICODE_ESCAPE_ERRORTOK:
2554         out.print("Invalid unicode escape in identifier: '", getToken(), "'");
2555         return;
2556     case INVALID_NUMERIC_LITERAL_ERRORTOK:
2557         out.print("Invalid numeric literal: '", getToken(), "'");
2558         return;
2559     case INVALID_OCTAL_NUMBER_ERRORTOK:
2560         out.print("Invalid use of octal: '", getToken(), "'");
2561         return;
2562     case INVALID_STRING_LITERAL_ERRORTOK:
2563         out.print("Invalid string literal: '", getToken(), "'");
2564         return;
2565     case ERRORTOK:
2566         out.print("Unrecognized token '", getToken(), "'");
2567         return;
2568     case STRING:
2569         out.print("Unexpected string literal ", getToken());
2570         return;
2571     case NUMBER:
2572         out.print("Unexpected number '", getToken(), "'");
2573         return;
2574     
2575     case RESERVED_IF_STRICT:
2576         out.print("Unexpected use of reserved word '", getToken(), "' in strict mode");
2577         return;
2578         
2579     case RESERVED:
2580         out.print("Unexpected use of reserved word '", getToken(), "'");
2581         return;
2582
2583     case INVALID_PRIVATE_NAME_ERRORTOK:
2584         out.print("Invalid private name '", getToken(), "'");
2585         return;
2586             
2587     case IDENT:
2588         out.print("Unexpected identifier '", getToken(), "'");
2589         return;
2590
2591     default:
2592         break;
2593     }
2594
2595     if (m_token.m_type & KeywordTokenFlag) {
2596         out.print("Unexpected keyword '", getToken(), "'");
2597         return;
2598     }
2599     
2600     out.print("Unexpected token '", getToken(), "'");
2601 }
2602
2603 // Instantiate the two flavors of Parser we need instead of putting most of this file in Parser.h
2604 template class Parser<Lexer<LChar>>;
2605 template class Parser<Lexer<UChar>>;
2606     
2607 } // namespace JSC