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