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