Change a couple of HashMap value types from OwnPtr to std::unique_ptr
[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/WTFThreadData.h>
38
39 #define fail() do { if (!hasError()) updateErrorMessage(); return 0; } while (0)
40 #define failWithToken(tok) do { if (!hasError()) updateErrorMessage(tok); return 0; } while (0)
41 #define failWithMessage(msg) do { if (!hasError()) updateErrorMessage(msg); return 0; } while (0)
42 #define failWithNameAndMessage(before, name, after) do { if (!hasError()) updateErrorWithNameAndMessage(before, name, after); return 0; } while (0)
43 #define failWithStackOverflow() do { updateErrorMessage("Stack exhausted"); m_hasStackOverflow = true; return 0; } while (0)
44 #define failIfFalse(cond) do { if (!(cond)) fail(); } while (0)
45 #define failIfFalseWithMessage(cond, msg) do { if (!(cond)) failWithMessage(msg); } while (0)
46 #define failIfFalseWithNameAndMessage(cond, before, name, msg) do { if (!(cond)) failWithNameAndMessage(before, name, msg); } while (0)
47 #define failIfTrue(cond) do { if ((cond)) fail(); } while (0)
48 #define failIfTrueWithMessage(cond, msg) do { if ((cond)) failWithMessage(msg); } while (0)
49 #define failIfTrueWithNameAndMessage(cond, before, name, msg) do { if ((cond)) failWithNameAndMessage(before, name, msg); } while (0)
50 #define failIfTrueIfStrict(cond) do { if ((cond) && strictMode()) fail(); } while (0)
51 #define failIfTrueIfStrictWithMessage(cond, msg) do { if ((cond) && strictMode()) failWithMessage(msg); } while (0)
52 #define failIfTrueIfStrictWithNameAndMessage(cond, before, name, after) do { if ((cond) && strictMode()) failWithNameAndMessage(before, name, after); } while (0)
53 #define failIfFalseIfStrict(cond) do { if ((!(cond)) && strictMode()) fail(); } while (0)
54 #define failIfFalseIfStrictWithMessage(cond, msg) do { if ((!(cond)) && strictMode()) failWithMessage(msg); } while (0)
55 #define failIfFalseIfStrictWithNameAndMessage(cond, before, name, after) do { if ((!(cond)) && strictMode()) failWithNameAndMessage(before, name, after); } while (0)
56 #define consumeOrFail(tokenType) do { if (!consume(tokenType)) failWithToken(tokenType); } while (0)
57 #define consumeOrFailWithFlags(tokenType, flags) do { if (!consume(tokenType, flags)) failWithToken(tokenType); } while (0)
58 #define matchOrFail(tokenType) do { if (!match(tokenType)) failWithToken(tokenType); } while (0)
59 #define failIfStackOverflow() do { if (!canRecurse()) failWithStackOverflow(); } while (0)
60
61 using namespace std;
62
63 namespace JSC {
64
65 template <typename LexerType>
66 Parser<LexerType>::Parser(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name, JSParserStrictness strictness, JSParserMode parserMode)
67     : m_vm(vm)
68     , m_source(&source)
69     , m_stack(*vm, wtfThreadData().stack())
70     , m_hasStackOverflow(false)
71     , m_allowsIn(true)
72     , m_assignmentCount(0)
73     , m_nonLHSCount(0)
74     , m_syntaxAlreadyValidated(source.provider()->isValid())
75     , m_statementDepth(0)
76     , m_nonTrivialExpressionCount(0)
77     , m_lastIdentifier(0)
78     , m_sourceElements(0)
79 {
80     m_lexer = adoptPtr(new LexerType(vm));
81     m_arena = m_vm->parserArena.get();
82     m_lexer->setCode(source, m_arena);
83     m_token.m_location.line = source.firstLine();
84     m_token.m_location.startOffset = source.startOffset();
85     m_token.m_location.endOffset = source.startOffset();
86     m_token.m_location.lineStartOffset = source.startOffset();
87     m_functionCache = vm->addSourceProviderCache(source.provider());
88     ScopeRef scope = pushScope();
89     if (parserMode == JSParseFunctionCode)
90         scope->setIsFunction();
91     if (strictness == JSParseStrict)
92         scope->setStrictMode();
93     if (parameters) {
94         for (unsigned i = 0; i < parameters->size(); i++) {
95             auto parameter = parameters->at(i);
96             if (!parameter->isBindingNode())
97                 continue;
98             scope->declareParameter(&static_cast<BindingNode*>(parameter)->boundProperty());
99         }
100     }
101     if (!name.isNull())
102         scope->declareCallee(&name);
103     next();
104 }
105
106 template <typename LexerType>
107 Parser<LexerType>::~Parser()
108 {
109 }
110
111 template <typename LexerType>
112 String Parser<LexerType>::parseInner()
113 {
114     String parseError = String();
115     
116     ASTBuilder context(const_cast<VM*>(m_vm), const_cast<SourceCode*>(m_source));
117     if (m_lexer->isReparsing())
118         m_statementDepth--;
119     ScopeRef scope = currentScope();
120     SourceElements* sourceElements = parseSourceElements<CheckForStrictMode>(context);
121     if (!sourceElements || !consume(EOFTOK)) {
122         if (hasError())
123             parseError = m_errorMessage;
124         else
125             parseError = ASCIILiteral("Parser error");
126     }
127
128     IdentifierSet capturedVariables;
129     bool modifiedParameter = false;
130     scope->getCapturedVariables(capturedVariables, modifiedParameter);
131     CodeFeatures features = context.features();
132     if (scope->strictMode())
133         features |= StrictModeFeature;
134     if (scope->shadowsArguments())
135         features |= ShadowsArgumentsFeature;
136     if (modifiedParameter)
137         features |= ModifiedParameterFeature;
138
139     didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), features,
140         context.numConstants(), capturedVariables);
141
142     return parseError;
143 }
144
145 template <typename LexerType>
146 void Parser<LexerType>::didFinishParsing(SourceElements* sourceElements, ParserArenaData<DeclarationStacks::VarStack>* varStack, 
147     ParserArenaData<DeclarationStacks::FunctionStack>* funcStack, CodeFeatures features, int numConstants, IdentifierSet& capturedVars)
148 {
149     m_sourceElements = sourceElements;
150     m_varDeclarations = varStack;
151     m_funcDeclarations = funcStack;
152     m_capturedVariables.swap(capturedVars);
153     m_features = features;
154     m_numConstants = numConstants;
155 }
156
157 template <typename LexerType>
158 bool Parser<LexerType>::allowAutomaticSemicolon()
159 {
160     return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator();
161 }
162
163 template <typename LexerType>
164 template <SourceElementsMode mode, class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceElements(TreeBuilder& context)
165 {
166     const unsigned lengthOfUseStrictLiteral = 12; // "use strict".length
167     TreeSourceElements sourceElements = context.createSourceElements();
168     bool seenNonDirective = false;
169     const Identifier* directive = 0;
170     unsigned directiveLiteralLength = 0;
171     unsigned startOffset = m_token.m_location.startOffset;
172     unsigned startLineStartOffset = m_token.m_location.lineStartOffset;
173     unsigned oldLastLineNumber = m_lexer->lastLineNumber();
174     unsigned oldLineNumber = m_lexer->lineNumber();
175     bool hasSetStrict = false;
176     while (TreeStatement statement = parseStatement(context, directive, &directiveLiteralLength)) {
177         if (mode == CheckForStrictMode && !seenNonDirective) {
178             if (directive) {
179                 // "use strict" must be the exact literal without escape sequences or line continuation.
180                 if (!hasSetStrict && directiveLiteralLength == lengthOfUseStrictLiteral && m_vm->propertyNames->useStrictIdentifier == *directive) {
181                     setStrictMode();
182                     hasSetStrict = true;
183                     failIfFalse(isValidStrictMode());
184                     m_lexer->setOffset(startOffset, startLineStartOffset);
185                     next();
186                     m_lexer->setLastLineNumber(oldLastLineNumber);
187                     m_lexer->setLineNumber(oldLineNumber);
188                     failIfTrue(hasError());
189                     continue;
190                 }
191             } else
192                 seenNonDirective = true;
193         }
194         context.appendStatement(sourceElements, statement);
195     }
196
197     failIfTrue(hasError());
198     return sourceElements;
199 }
200
201 template <typename LexerType>
202 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVarDeclaration(TreeBuilder& context)
203 {
204     ASSERT(match(VAR));
205     JSTokenLocation location(tokenLocation());
206     int start = tokenLine();
207     int end = 0;
208     int scratch;
209     TreeDeconstructionPattern scratch1 = 0;
210     TreeExpression scratch2 = 0;
211     JSTextPosition scratch3;
212     TreeExpression varDecls = parseVarDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3);
213     failIfTrue(hasError());
214     failIfFalse(autoSemiColon());
215     
216     return context.createVarStatement(location, varDecls, start, end);
217 }
218
219 template <typename LexerType>
220 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseConstDeclaration(TreeBuilder& context)
221 {
222     ASSERT(match(CONSTTOKEN));
223     JSTokenLocation location(tokenLocation());
224     int start = tokenLine();
225     int end = 0;
226     TreeConstDeclList constDecls = parseConstDeclarationList(context);
227     failIfTrue(hasError());
228     failIfFalse(autoSemiColon());
229     
230     return context.createConstStatement(location, constDecls, start, end);
231 }
232
233 template <typename LexerType>
234 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDoWhileStatement(TreeBuilder& context)
235 {
236     ASSERT(match(DO));
237     int startLine = tokenLine();
238     next();
239     const Identifier* unused = 0;
240     startLoop();
241     TreeStatement statement = parseStatement(context, unused);
242     endLoop();
243     failIfFalse(statement);
244     int endLine = tokenLine();
245     JSTokenLocation location(tokenLocation());
246     consumeOrFail(WHILE);
247     consumeOrFail(OPENPAREN);
248     TreeExpression expr = parseExpression(context);
249     failIfFalse(expr);
250     consumeOrFail(CLOSEPAREN);
251     if (match(SEMICOLON))
252         next(); // Always performs automatic semicolon insertion.
253     return context.createDoWhileStatement(location, statement, expr, startLine, endLine);
254 }
255
256 template <typename LexerType>
257 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWhileStatement(TreeBuilder& context)
258 {
259     ASSERT(match(WHILE));
260     JSTokenLocation location(tokenLocation());
261     int startLine = tokenLine();
262     next();
263     consumeOrFail(OPENPAREN);
264     TreeExpression expr = parseExpression(context);
265     failIfFalse(expr);
266     int endLine = tokenLine();
267     consumeOrFail(CLOSEPAREN);
268     const Identifier* unused = 0;
269     startLoop();
270     TreeStatement statement = parseStatement(context, unused);
271     endLoop();
272     failIfFalse(statement);
273     return context.createWhileStatement(location, expr, statement, startLine, endLine);
274 }
275
276 template <typename LexerType>
277 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarationList(TreeBuilder& context, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd)
278 {
279     TreeExpression varDecls = 0;
280     const Identifier* lastIdent;
281     do {
282         lastIdent = 0;
283         lastPattern = 0;
284         JSTokenLocation location(tokenLocation());
285         next();
286         TreeExpression node = 0;
287         declarations++;
288         bool hasInitializer = false;
289         if (match(IDENT)) {
290             JSTextPosition varStart = tokenStartPosition();
291             identStart = varStart;
292             const Identifier* name = m_token.m_data.ident;
293             lastIdent = name;
294             next();
295             hasInitializer = match(EQUAL);
296             failIfFalseIfStrictWithNameAndMessage(declareVariable(name), "Cannot declare a variable named", name->impl(), "in strict mode.");
297             context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0);
298             if (hasInitializer) {
299                 JSTextPosition varDivot = tokenStartPosition() + 1;
300                 initStart = tokenStartPosition();
301                 next(TreeBuilder::DontBuildStrings); // consume '='
302                 TreeExpression initializer = parseAssignmentExpression(context);
303                 initEnd = lastTokenEndPosition();
304                 lastInitializer = initializer;
305                 failIfFalse(initializer);
306                 
307                 node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEndPosition());
308             }
309         } else {
310             lastIdent = 0;
311             auto pattern = parseDeconstructionPattern<DeconstructToVariables>(context);
312             failIfFalse(pattern);
313             hasInitializer = match(EQUAL);
314             lastPattern = pattern;
315             if (hasInitializer) {
316                 next(TreeBuilder::DontBuildStrings); // consume '='
317                 TreeExpression rhs = parseExpression(context);
318                 node = context.createDeconstructingAssignment(location, pattern, rhs);
319             }
320             ASSERT(node);
321         }
322         
323         if (hasInitializer) {
324             if (!varDecls)
325                 varDecls = node;
326             else
327                 varDecls = context.combineCommaNodes(location, varDecls, node);
328         }
329     } while (match(COMMA));
330     if (lastIdent)
331         lastPattern = createBindingPattern<DeconstructToVariables>(context, *lastIdent, 0);
332     return varDecls;
333 }
334
335 template <typename LexerType>
336 template <DeconstructionKind kind, class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, const Identifier& name, int depth)
337 {
338     ASSERT(!name.isEmpty());
339     ASSERT(!name.isNull());
340     
341     ASSERT(name.impl()->isIdentifier());
342     if (depth) {
343         if (kind == DeconstructToVariables)
344             failIfFalseIfStrictWithNameAndMessage(declareVariable(&name), "Cannot deconstruct to a variable named", name.impl(), ".");
345         if (kind == DeconstructToParameters) {
346             auto bindingResult = declareBoundParameter(&name);
347             failIfFalseIfStrictWithNameAndMessage(bindingResult != Scope::StrictBindingFailed, "Cannot deconstruct to a parameter named", name.impl(), "in strict mode.");
348             failIfFalseWithNameAndMessage(bindingResult != Scope::BindingFailed, "Cannot deconstruct to a parameter named", name.impl(), ".");
349         }
350         context.addVar(&name, kind == DeconstructToParameters ? 0 : DeclarationStacks::HasInitializer);
351     } else {
352         if (kind == DeconstructToVariables) {
353             failIfFalseIfStrictWithNameAndMessage(declareVariable(&name), "Cannot declare a variable named", name.impl(), "in strict mode.");
354             context.addVar(&name, DeclarationStacks::HasInitializer);
355         }
356         
357         if (kind == DeconstructToParameters)
358             failIfFalseIfStrictWithNameAndMessage(declareParameter(&name), "Cannot declare a parameter named", name.impl(), "in strict mode.");
359     }
360     return context.createBindingLocation(m_token.m_location, name, m_token.m_endPosition, m_token.m_startPosition, m_token.m_endPosition);
361 }
362
363 template <typename LexerType>
364 template <DeconstructionKind kind, class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::parseDeconstructionPattern(TreeBuilder& context, int depth)
365 {
366     failIfStackOverflow();
367     int nonLHSCount = m_nonLHSCount;
368     TreeDeconstructionPattern pattern;
369     switch (m_token.m_type) {
370     case OPENBRACKET: {
371         auto arrayPattern = context.createArrayPattern(m_token.m_location);
372         next();
373         do {
374             while (match(COMMA)) {
375                 context.appendArrayPatternSkipEntry(arrayPattern, m_token.m_location);
376                 next();
377             }
378             failIfTrue(hasError());
379             JSTokenLocation location = m_token.m_location;
380             auto innerPattern = parseDeconstructionPattern<kind>(context, depth + 1);
381             failIfFalse(innerPattern);
382             context.appendArrayPatternEntry(arrayPattern, location, innerPattern);
383         } while (consume(COMMA));
384         consumeOrFail(CLOSEBRACKET);
385         pattern = arrayPattern;
386         break;
387     }
388     case OPENBRACE: {
389         next();
390         auto objectPattern = context.createObjectPattern(m_token.m_location);
391         bool wasString = false;
392         do {
393             Identifier propertyName;
394             TreeDeconstructionPattern innerPattern = 0;
395             JSTokenLocation location = m_token.m_location;
396             if (match(IDENT)) {
397                 propertyName = *m_token.m_data.ident;
398                 next();
399                 if (consume(COLON))
400                     innerPattern = parseDeconstructionPattern<kind>(context, depth + 1);
401                 else
402                     innerPattern = createBindingPattern<kind>(context, propertyName, depth);
403             } else {
404                 switch (m_token.m_type) {
405                 case NUMBER:
406                     propertyName = Identifier::from(m_vm, m_token.m_data.doubleValue);
407                     break;
408                 case STRING:
409                     propertyName = *m_token.m_data.ident;
410                     wasString = true;
411                     break;
412                 default:
413                     failIfTrue(!(m_token.m_type & KeywordTokenFlag));
414                     propertyName = *m_token.m_data.ident;
415                     break;
416                 }
417                 next();
418                 consumeOrFail(COLON);
419                 innerPattern = parseDeconstructionPattern<kind>(context, depth + 1);
420             }
421             failIfFalse(innerPattern);
422             context.appendObjectPatternEntry(objectPattern, location, wasString, propertyName, innerPattern);
423         } while (consume(COMMA));
424         consumeOrFail(CLOSEBRACE);
425         pattern = objectPattern;
426         break;
427     }
428
429     default: {
430         matchOrFail(IDENT);
431         pattern = createBindingPattern<kind>(context, *m_token.m_data.ident, depth);
432         next();
433         break;
434     }
435     }
436     m_nonLHSCount = nonLHSCount;
437     return pattern;
438 }
439
440 template <typename LexerType>
441 template <class TreeBuilder> TreeConstDeclList Parser<LexerType>::parseConstDeclarationList(TreeBuilder& context)
442 {
443     failIfTrue(strictMode());
444     TreeConstDeclList constDecls = 0;
445     TreeConstDeclList tail = 0;
446     do {
447         JSTokenLocation location(tokenLocation());
448         next();
449         matchOrFail(IDENT);
450         const Identifier* name = m_token.m_data.ident;
451         next();
452         bool hasInitializer = match(EQUAL);
453         declareVariable(name);
454         context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));
455
456         TreeExpression initializer = 0;
457         if (hasInitializer) {
458             next(TreeBuilder::DontBuildStrings); // consume '='
459             initializer = parseAssignmentExpression(context);
460         }
461         tail = context.appendConstDecl(location, tail, name, initializer);
462         if (!constDecls)
463             constDecls = tail;
464     } while (match(COMMA));
465     return constDecls;
466 }
467
468 template <typename LexerType>
469 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement(TreeBuilder& context)
470 {
471     ASSERT(match(FOR));
472     JSTokenLocation location(tokenLocation());
473     int startLine = tokenLine();
474     next();
475     consumeOrFail(OPENPAREN);
476     int nonLHSCount = m_nonLHSCount;
477     int declarations = 0;
478     JSTextPosition declsStart;
479     JSTextPosition declsEnd;
480     TreeExpression decls = 0;
481     if (match(VAR)) {
482         /*
483          for (var IDENT in expression) statement
484          for (var varDeclarationList; expressionOpt; expressionOpt)
485          */
486         TreeDeconstructionPattern forInTarget = 0;
487         TreeExpression forInInitializer = 0;
488         m_allowsIn = false;
489         JSTextPosition initStart;
490         JSTextPosition initEnd;
491         decls = parseVarDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd);
492         m_allowsIn = true;
493         failIfTrue(hasError());
494
495         // Remainder of a standard for loop is handled identically
496         if (match(SEMICOLON))
497             goto standardForLoop;
498         
499         failIfFalse(declarations == 1);
500         failIfTrueWithMessage(forInInitializer, "Cannot use initialiser syntax in a for-in loop");
501         
502         // Handle for-in with var declaration
503         JSTextPosition inLocation = tokenStartPosition();
504         consumeOrFail(INTOKEN);
505         
506         TreeExpression expr = parseExpression(context);
507         failIfFalse(expr);
508         JSTextPosition exprEnd = lastTokenEndPosition();
509         
510         int endLine = tokenLine();
511         consumeOrFail(CLOSEPAREN);
512         
513         const Identifier* unused = 0;
514         startLoop();
515         TreeStatement statement = parseStatement(context, unused);
516         endLoop();
517         failIfFalse(statement);
518         return context.createForInLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine);
519     }
520     
521     if (!match(SEMICOLON)) {
522         m_allowsIn = false;
523         declsStart = tokenStartPosition();
524         decls = parseExpression(context);
525         declsEnd = lastTokenEndPosition();
526         m_allowsIn = true;
527         failIfFalse(decls);
528     }
529     
530     if (match(SEMICOLON)) {
531     standardForLoop:
532         // Standard for loop
533         next();
534         TreeExpression condition = 0;
535         
536         if (!match(SEMICOLON)) {
537             condition = parseExpression(context);
538             failIfFalse(condition);
539         }
540         consumeOrFail(SEMICOLON);
541         
542         TreeExpression increment = 0;
543         if (!match(CLOSEPAREN)) {
544             increment = parseExpression(context);
545             failIfFalse(increment);
546         }
547         int endLine = tokenLine();
548         consumeOrFail(CLOSEPAREN);
549         const Identifier* unused = 0;
550         startLoop();
551         TreeStatement statement = parseStatement(context, unused);
552         endLoop();
553         failIfFalse(statement);
554         return context.createForLoop(location, decls, condition, increment, statement, startLine, endLine);
555     }
556     
557     // For-in loop
558     failIfFalse(nonLHSCount == m_nonLHSCount);
559     consumeOrFail(INTOKEN);
560     TreeExpression expr = parseExpression(context);
561     failIfFalse(expr);
562     JSTextPosition exprEnd = lastTokenEndPosition();
563     int endLine = tokenLine();
564     consumeOrFail(CLOSEPAREN);
565     const Identifier* unused = 0;
566     startLoop();
567     TreeStatement statement = parseStatement(context, unused);
568     endLoop();
569     failIfFalse(statement);
570     
571     return context.createForInLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
572 }
573
574 template <typename LexerType>
575 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBreakStatement(TreeBuilder& context)
576 {
577     ASSERT(match(BREAK));
578     JSTokenLocation location(tokenLocation());
579     JSTextPosition start = tokenStartPosition();
580     JSTextPosition end = tokenEndPosition();
581     next();
582     
583     if (autoSemiColon()) {
584         failIfFalseWithMessage(breakIsValid(), "'break' is only valid inside a switch or loop statement");
585         return context.createBreakStatement(location, start, end);
586     }
587     matchOrFail(IDENT);
588     const Identifier* ident = m_token.m_data.ident;
589     failIfFalseWithNameAndMessage(getLabel(ident), "Label", ident->impl(), "is not defined");
590     end = tokenEndPosition();
591     next();
592     failIfFalse(autoSemiColon());
593     return context.createBreakStatement(location, ident, start, end);
594 }
595
596 template <typename LexerType>
597 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseContinueStatement(TreeBuilder& context)
598 {
599     ASSERT(match(CONTINUE));
600     JSTokenLocation location(tokenLocation());
601     JSTextPosition start = tokenStartPosition();
602     JSTextPosition end = tokenEndPosition();
603     next();
604     
605     if (autoSemiColon()) {
606         failIfFalseWithMessage(continueIsValid(), "'continue' is only valid inside a loop statement");
607         return context.createContinueStatement(location, start, end);
608     }
609     matchOrFail(IDENT);
610     const Identifier* ident = m_token.m_data.ident;
611     ScopeLabelInfo* label = getLabel(ident);
612     failIfFalseWithNameAndMessage(label, "Label", ident->impl(), "is not defined");
613     failIfFalseWithMessage(label->m_isLoop, "'continue' is only valid inside a loop statement");
614     end = tokenEndPosition();
615     next();
616     failIfFalse(autoSemiColon());
617     return context.createContinueStatement(location, ident, start, end);
618 }
619
620 template <typename LexerType>
621 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseReturnStatement(TreeBuilder& context)
622 {
623     ASSERT(match(RETURN));
624     JSTokenLocation location(tokenLocation());
625     failIfFalse(currentScope()->isFunction());
626     JSTextPosition start = tokenStartPosition();
627     JSTextPosition end = tokenEndPosition();
628     next();
629     // We do the auto semicolon check before attempting to parse an expression
630     // as we need to ensure the a line break after the return correctly terminates
631     // the statement
632     if (match(SEMICOLON))
633         end = tokenEndPosition();
634
635     if (autoSemiColon())
636         return context.createReturnStatement(location, 0, start, end);
637     TreeExpression expr = parseExpression(context);
638     failIfFalse(expr);
639     end = lastTokenEndPosition();
640     if (match(SEMICOLON))
641         end  = tokenEndPosition();
642     failIfFalse(autoSemiColon());
643     return context.createReturnStatement(location, expr, start, end);
644 }
645
646 template <typename LexerType>
647 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseThrowStatement(TreeBuilder& context)
648 {
649     ASSERT(match(THROW));
650     JSTokenLocation location(tokenLocation());
651     JSTextPosition start = tokenStartPosition();
652     next();
653     
654     failIfTrue(autoSemiColon());
655     
656     TreeExpression expr = parseExpression(context);
657     failIfFalse(expr);
658     JSTextPosition end = lastTokenEndPosition();
659     failIfFalse(autoSemiColon());
660     
661     return context.createThrowStatement(location, expr, start, end);
662 }
663
664 template <typename LexerType>
665 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWithStatement(TreeBuilder& context)
666 {
667     ASSERT(match(WITH));
668     JSTokenLocation location(tokenLocation());
669     failIfTrueWithMessage(strictMode(), "'with' statements are not valid in strict mode");
670     currentScope()->setNeedsFullActivation();
671     int startLine = tokenLine();
672     next();
673     consumeOrFail(OPENPAREN);
674     int start = tokenStart();
675     TreeExpression expr = parseExpression(context);
676     failIfFalse(expr);
677     JSTextPosition end = lastTokenEndPosition();
678     int endLine = tokenLine();
679     consumeOrFail(CLOSEPAREN);
680     const Identifier* unused = 0;
681     TreeStatement statement = parseStatement(context, unused);
682     failIfFalse(statement);
683     
684     return context.createWithStatement(location, expr, statement, start, end, startLine, endLine);
685 }
686
687 template <typename LexerType>
688 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStatement(TreeBuilder& context)
689 {
690     ASSERT(match(SWITCH));
691     JSTokenLocation location(tokenLocation());
692     int startLine = tokenLine();
693     next();
694     consumeOrFail(OPENPAREN);
695     TreeExpression expr = parseExpression(context);
696     failIfFalse(expr);
697     int endLine = tokenLine();
698     consumeOrFail(CLOSEPAREN);
699     consumeOrFail(OPENBRACE);
700     startSwitch();
701     TreeClauseList firstClauses = parseSwitchClauses(context);
702     failIfTrue(hasError());
703     
704     TreeClause defaultClause = parseSwitchDefaultClause(context);
705     failIfTrue(hasError());
706     
707     TreeClauseList secondClauses = parseSwitchClauses(context);
708     failIfTrue(hasError());
709     endSwitch();
710     consumeOrFail(CLOSEBRACE);
711     
712     return context.createSwitchStatement(location, expr, firstClauses, defaultClause, secondClauses, startLine, endLine);
713     
714 }
715
716 template <typename LexerType>
717 template <class TreeBuilder> TreeClauseList Parser<LexerType>::parseSwitchClauses(TreeBuilder& context)
718 {
719     if (!match(CASE))
720         return 0;
721     next();
722     TreeExpression condition = parseExpression(context);
723     failIfFalse(condition);
724     consumeOrFail(COLON);
725     TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
726     failIfFalse(statements);
727     TreeClause clause = context.createClause(condition, statements);
728     TreeClauseList clauseList = context.createClauseList(clause);
729     TreeClauseList tail = clauseList;
730     
731     while (match(CASE)) {
732         next();
733         TreeExpression condition = parseExpression(context);
734         failIfFalse(condition);
735         consumeOrFail(COLON);
736         TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
737         failIfFalse(statements);
738         clause = context.createClause(condition, statements);
739         tail = context.createClauseList(tail, clause);
740     }
741     return clauseList;
742 }
743
744 template <typename LexerType>
745 template <class TreeBuilder> TreeClause Parser<LexerType>::parseSwitchDefaultClause(TreeBuilder& context)
746 {
747     if (!match(DEFAULT))
748         return 0;
749     next();
750     consumeOrFail(COLON);
751     TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
752     failIfFalse(statements);
753     return context.createClause(0, statements);
754 }
755
756 template <typename LexerType>
757 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement(TreeBuilder& context)
758 {
759     ASSERT(match(TRY));
760     JSTokenLocation location(tokenLocation());
761     TreeStatement tryBlock = 0;
762     const Identifier* ident = &m_vm->propertyNames->nullIdentifier;
763     TreeStatement catchBlock = 0;
764     TreeStatement finallyBlock = 0;
765     int firstLine = tokenLine();
766     next();
767     matchOrFail(OPENBRACE);
768     
769     tryBlock = parseBlockStatement(context);
770     failIfFalse(tryBlock);
771     int lastLine = m_lastTokenEndPosition.line;
772     
773     if (match(CATCH)) {
774         currentScope()->setNeedsFullActivation();
775         next();
776         consumeOrFail(OPENPAREN);
777         matchOrFail(IDENT);
778         ident = m_token.m_data.ident;
779         next();
780         AutoPopScopeRef catchScope(this, pushScope());
781         failIfFalseIfStrictWithNameAndMessage(declareVariable(ident), "Cannot declare a variable named", ident->impl(), "in strict mode");
782         catchScope->preventNewDecls();
783         consumeOrFail(CLOSEPAREN);
784         matchOrFail(OPENBRACE);
785         catchBlock = parseBlockStatement(context);
786         failIfFalseWithMessage(catchBlock, "'try' must have a catch or finally block");
787         failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo));
788     }
789     
790     if (match(FINALLY)) {
791         next();
792         matchOrFail(OPENBRACE);
793         finallyBlock = parseBlockStatement(context);
794         failIfFalse(finallyBlock);
795     }
796     failIfFalse(catchBlock || finallyBlock);
797     return context.createTryStatement(location, tryBlock, ident, catchBlock, finallyBlock, firstLine, lastLine);
798 }
799
800 template <typename LexerType>
801 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDebuggerStatement(TreeBuilder& context)
802 {
803     ASSERT(match(DEBUGGER));
804     JSTokenLocation location(tokenLocation());
805     int startLine = tokenLine();
806     int endLine = startLine;
807     next();
808     if (match(SEMICOLON))
809         startLine = tokenLine();
810     failIfFalse(autoSemiColon());
811     return context.createDebugger(location, startLine, endLine);
812 }
813
814 template <typename LexerType>
815 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context)
816 {
817     ASSERT(match(OPENBRACE));
818     JSTokenLocation location(tokenLocation());
819     int start = tokenLine();
820     next();
821     if (match(CLOSEBRACE)) {
822         next();
823         return context.createBlockStatement(location, 0, start, m_lastTokenEndPosition.line);
824     }
825     TreeSourceElements subtree = parseSourceElements<DontCheckForStrictMode>(context);
826     failIfFalse(subtree);
827     matchOrFail(CLOSEBRACE);
828     next();
829     return context.createBlockStatement(location, subtree, start, m_lastTokenEndPosition.line);
830 }
831
832 template <typename LexerType>
833 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatement(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength)
834 {
835     DepthManager statementDepth(&m_statementDepth);
836     m_statementDepth++;
837     directive = 0;
838     int nonTrivialExpressionCount = 0;
839     failIfStackOverflow();
840     switch (m_token.m_type) {
841     case OPENBRACE:
842         return parseBlockStatement(context);
843     case VAR:
844         return parseVarDeclaration(context);
845     case CONSTTOKEN:
846         return parseConstDeclaration(context);
847     case FUNCTION:
848         failIfFalseIfStrictWithMessage(m_statementDepth == 1, "Functions cannot be declared in a nested block in strict mode");
849         return parseFunctionDeclaration(context);
850     case SEMICOLON: {
851         JSTokenLocation location(tokenLocation());
852         next();
853         return context.createEmptyStatement(location);
854     }
855     case IF:
856         return parseIfStatement(context);
857     case DO:
858         return parseDoWhileStatement(context);
859     case WHILE:
860         return parseWhileStatement(context);
861     case FOR:
862         return parseForStatement(context);
863     case CONTINUE:
864         return parseContinueStatement(context);
865     case BREAK:
866         return parseBreakStatement(context);
867     case RETURN:
868         return parseReturnStatement(context);
869     case WITH:
870         return parseWithStatement(context);
871     case SWITCH:
872         return parseSwitchStatement(context);
873     case THROW:
874         return parseThrowStatement(context);
875     case TRY:
876         return parseTryStatement(context);
877     case DEBUGGER:
878         return parseDebuggerStatement(context);
879     case EOFTOK:
880     case CASE:
881     case CLOSEBRACE:
882     case DEFAULT:
883         // These tokens imply the end of a set of source elements
884         return 0;
885     case IDENT:
886         return parseExpressionOrLabelStatement(context);
887     case STRING:
888         directive = m_token.m_data.ident;
889         if (directiveLiteralLength)
890             *directiveLiteralLength = m_token.m_location.endOffset - m_token.m_location.startOffset;
891         nonTrivialExpressionCount = m_nonTrivialExpressionCount;
892     default:
893         TreeStatement exprStatement = parseExpressionStatement(context);
894         if (directive && nonTrivialExpressionCount != m_nonTrivialExpressionCount)
895             directive = 0;
896         return exprStatement;
897     }
898 }
899
900 template <typename LexerType>
901 template <class TreeBuilder> TreeFormalParameterList Parser<LexerType>::parseFormalParameters(TreeBuilder& context)
902 {
903     auto parameter = parseDeconstructionPattern<DeconstructToParameters>(context);
904     failIfFalse(parameter);
905     TreeFormalParameterList list = context.createFormalParameterList(parameter);
906     TreeFormalParameterList tail = list;
907     while (consume(COMMA)) {
908         parameter = parseDeconstructionPattern<DeconstructToParameters>(context);
909         failIfFalse(parameter);
910         tail = context.createFormalParameterList(tail, parameter);
911     }
912     return list;
913 }
914
915 template <typename LexerType>
916 template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(TreeBuilder& context)
917 {
918     JSTokenLocation startLocation(tokenLocation());
919     unsigned startColumn = tokenColumn();
920     next();
921
922     if (match(CLOSEBRACE))
923         return context.createFunctionBody(startLocation, tokenLocation(), startColumn, strictMode());
924     DepthManager statementDepth(&m_statementDepth);
925     m_statementDepth = 0;
926     typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<VM*>(m_vm), m_lexer.get());
927     failIfFalse(parseSourceElements<CheckForStrictMode>(bodyBuilder));
928     return context.createFunctionBody(startLocation, tokenLocation(), startColumn, strictMode());
929 }
930
931 template <typename LexerType>
932 template <FunctionRequirements requirements, bool nameIsInContainingScope, class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, const Identifier*& name, TreeFormalParameterList& parameters, TreeFunctionBody& body, unsigned& openBraceOffset, unsigned& closeBraceOffset, int& bodyStartLine, unsigned& bodyStartColumn)
933 {
934     AutoPopScopeRef functionScope(this, pushScope());
935     functionScope->setIsFunction();
936     int functionStart = m_token.m_location.startOffset;
937     if (match(IDENT)) {
938         name = m_token.m_data.ident;
939         next();
940         if (!nameIsInContainingScope)
941             failIfFalseIfStrict(functionScope->declareVariable(name));
942     } else if (requirements == FunctionNeedsName)
943         return false;
944     consumeOrFail(OPENPAREN);
945     if (!match(CLOSEPAREN)) {
946         parameters = parseFormalParameters(context);
947         failIfFalse(parameters);
948     }
949     consumeOrFail(CLOSEPAREN);
950     matchOrFail(OPENBRACE);
951     
952     openBraceOffset = m_token.m_data.offset;
953     bodyStartLine = tokenLine();
954     bodyStartColumn = m_token.m_data.offset - m_token.m_data.lineStartOffset;
955     JSTokenLocation startLocation(tokenLocation());
956     
957     // If we know about this function already, we can use the cached info and skip the parser to the end of the function.
958     if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBraceOffset) : 0) {
959         // If we're in a strict context, the cached function info must say it was strict too.
960         ASSERT(!strictMode() || cachedInfo->strictMode);
961         JSTokenLocation endLocation;
962
963         endLocation.line = cachedInfo->closeBraceLine;
964         endLocation.startOffset = cachedInfo->closeBraceOffset;
965         endLocation.lineStartOffset = cachedInfo->closeBraceLineStartOffset;
966         ASSERT(endLocation.startOffset >= endLocation.lineStartOffset);
967
968         body = context.createFunctionBody(startLocation, endLocation, bodyStartColumn, cachedInfo->strictMode);
969         
970         functionScope->restoreFromSourceProviderCache(cachedInfo);
971         failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
972         
973         closeBraceOffset = cachedInfo->closeBraceOffset;
974
975         context.setFunctionStart(body, functionStart);
976         m_token = cachedInfo->closeBraceToken();
977
978         m_lexer->setOffset(m_token.m_location.endOffset, m_token.m_location.lineStartOffset);
979         m_lexer->setLineNumber(m_token.m_location.line);
980         
981         next();
982         return true;
983     }
984     
985     body = parseFunctionBody(context);
986     failIfFalse(body);
987     if (functionScope->strictMode() && name) {
988         failIfTrueWithNameAndMessage(m_vm->propertyNames->arguments == *name, "Function name", name->impl(), "is not valid in strict mode");
989         failIfTrueWithNameAndMessage(m_vm->propertyNames->eval == *name, "Function name", name->impl(), "is not valid in strict mode");
990     }
991     closeBraceOffset = m_token.m_data.offset;
992     unsigned closeBraceLine = m_token.m_data.line;
993     unsigned closeBraceLineStartOffset = m_token.m_data.lineStartOffset;
994     
995     // Cache the tokenizer state and the function scope the first time the function is parsed.
996     // Any future reparsing can then skip the function.
997     static const int minimumFunctionLengthToCache = 16;
998     std::unique_ptr<SourceProviderCacheItem> newInfo;
999     int functionLength = closeBraceOffset - openBraceOffset;
1000     if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) {
1001         SourceProviderCacheItemCreationParameters parameters;
1002         parameters.functionStart = functionStart;
1003         parameters.closeBraceLine = closeBraceLine;
1004         parameters.closeBraceOffset = closeBraceOffset;
1005         parameters.closeBraceLineStartOffset = closeBraceLineStartOffset;
1006         functionScope->fillParametersForSourceProviderCache(parameters);
1007         newInfo = SourceProviderCacheItem::create(parameters);
1008
1009     }
1010     context.setFunctionStart(body, functionStart);
1011     
1012     failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
1013     matchOrFail(CLOSEBRACE);
1014     
1015     if (newInfo)
1016         m_functionCache->add(openBraceOffset, std::move(newInfo));
1017     
1018     next();
1019     return true;
1020 }
1021
1022 template <typename LexerType>
1023 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context)
1024 {
1025     ASSERT(match(FUNCTION));
1026     JSTokenLocation location(tokenLocation());
1027     next();
1028     const Identifier* name = 0;
1029     TreeFormalParameterList parameters = 0;
1030     TreeFunctionBody body = 0;
1031     unsigned openBraceOffset = 0;
1032     unsigned closeBraceOffset = 0;
1033     int bodyStartLine = 0;
1034     unsigned bodyStartColumn = 0;
1035     failIfFalse((parseFunctionInfo<FunctionNeedsName, true>(context, name, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)));
1036     failIfFalse(name);
1037     failIfFalseIfStrict(declareVariable(name));
1038     return context.createFuncDeclStatement(location, name, body, parameters, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastTokenEndPosition.line, bodyStartColumn);
1039 }
1040
1041 struct LabelInfo {
1042     LabelInfo(const Identifier* ident, const JSTextPosition& start, const JSTextPosition& end)
1043     : m_ident(ident)
1044     , m_start(start)
1045     , m_end(end)
1046     {
1047     }
1048     
1049     const Identifier* m_ident;
1050     JSTextPosition m_start;
1051     JSTextPosition m_end;
1052 };
1053
1054 template <typename LexerType>
1055 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrLabelStatement(TreeBuilder& context)
1056 {
1057     
1058     /* Expression and Label statements are ambiguous at LL(1), so we have a
1059      * special case that looks for a colon as the next character in the input.
1060      */
1061     Vector<LabelInfo> labels;
1062     JSTokenLocation location;
1063     do {
1064         JSTextPosition start = tokenStartPosition();
1065         location = tokenLocation();
1066         if (!nextTokenIsColon()) {
1067             // If we hit this path we're making a expression statement, which
1068             // by definition can't make use of continue/break so we can just
1069             // ignore any labels we might have accumulated.
1070             TreeExpression expression = parseExpression(context);
1071             failIfFalse(expression);
1072             failIfFalse(autoSemiColon());
1073             return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
1074         }
1075         const Identifier* ident = m_token.m_data.ident;
1076         JSTextPosition end = tokenEndPosition();
1077         next();
1078         consumeOrFail(COLON);
1079         if (!m_syntaxAlreadyValidated) {
1080             // This is O(N^2) over the current list of consecutive labels, but I
1081             // have never seen more than one label in a row in the real world.
1082             for (size_t i = 0; i < labels.size(); i++)
1083                 failIfTrue(ident->impl() == labels[i].m_ident->impl());
1084             failIfTrue(getLabel(ident));
1085             labels.append(LabelInfo(ident, start, end));
1086         }
1087     } while (match(IDENT));
1088     bool isLoop = false;
1089     switch (m_token.m_type) {
1090     case FOR:
1091     case WHILE:
1092     case DO:
1093         isLoop = true;
1094         break;
1095         
1096     default:
1097         break;
1098     }
1099     const Identifier* unused = 0;
1100     if (!m_syntaxAlreadyValidated) {
1101         for (size_t i = 0; i < labels.size(); i++)
1102             pushLabel(labels[i].m_ident, isLoop);
1103     }
1104     TreeStatement statement = parseStatement(context, unused);
1105     if (!m_syntaxAlreadyValidated) {
1106         for (size_t i = 0; i < labels.size(); i++)
1107             popLabel();
1108     }
1109     failIfFalse(statement);
1110     for (size_t i = 0; i < labels.size(); i++) {
1111         const LabelInfo& info = labels[labels.size() - i - 1];
1112         statement = context.createLabelStatement(location, info.m_ident, statement, info.m_start, info.m_end);
1113     }
1114     return statement;
1115 }
1116
1117 template <typename LexerType>
1118 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionStatement(TreeBuilder& context)
1119 {
1120     JSTextPosition start = tokenStartPosition();
1121     JSTokenLocation location(tokenLocation());
1122     TreeExpression expression = parseExpression(context);
1123     failIfFalse(expression);
1124     failIfFalse(autoSemiColon());
1125     return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
1126 }
1127
1128 template <typename LexerType>
1129 template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(TreeBuilder& context)
1130 {
1131     ASSERT(match(IF));
1132     JSTokenLocation ifLocation(tokenLocation());
1133     int start = tokenLine();
1134     next();
1135
1136     consumeOrFail(OPENPAREN);
1137
1138     TreeExpression condition = parseExpression(context);
1139     failIfFalse(condition);
1140     int end = tokenLine();
1141     consumeOrFail(CLOSEPAREN);
1142
1143     const Identifier* unused = 0;
1144     TreeStatement trueBlock = parseStatement(context, unused);
1145     failIfFalse(trueBlock);
1146
1147     if (!match(ELSE))
1148         return context.createIfStatement(ifLocation, condition, trueBlock, 0, start, end);
1149
1150     Vector<TreeExpression> exprStack;
1151     Vector<pair<int, int> > posStack;
1152     Vector<JSTokenLocation> tokenLocationStack;
1153     Vector<TreeStatement> statementStack;
1154     bool trailingElse = false;
1155     do {
1156         JSTokenLocation tempLocation = tokenLocation();
1157         next();
1158         if (!match(IF)) {
1159             const Identifier* unused = 0;
1160             TreeStatement block = parseStatement(context, unused);
1161             failIfFalse(block);
1162             statementStack.append(block);
1163             trailingElse = true;
1164             break;
1165         }
1166         int innerStart = tokenLine();
1167         next();
1168
1169         consumeOrFail(OPENPAREN);
1170
1171         TreeExpression innerCondition = parseExpression(context);
1172         failIfFalse(innerCondition);
1173         int innerEnd = tokenLine();
1174         consumeOrFail(CLOSEPAREN);
1175         const Identifier* unused = 0;
1176         TreeStatement innerTrueBlock = parseStatement(context, unused);
1177         failIfFalse(innerTrueBlock);
1178         tokenLocationStack.append(tempLocation);
1179         exprStack.append(innerCondition);
1180         posStack.append(make_pair(innerStart, innerEnd));
1181         statementStack.append(innerTrueBlock);
1182     } while (match(ELSE));
1183
1184     if (!trailingElse) {
1185         TreeExpression condition = exprStack.last();
1186         exprStack.removeLast();
1187         TreeStatement trueBlock = statementStack.last();
1188         statementStack.removeLast();
1189         pair<int, int> pos = posStack.last();
1190         posStack.removeLast();
1191         JSTokenLocation elseLocation = tokenLocationStack.last();
1192         tokenLocationStack.removeLast();
1193         statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, 0, pos.first, pos.second));
1194     }
1195
1196     while (!exprStack.isEmpty()) {
1197         TreeExpression condition = exprStack.last();
1198         exprStack.removeLast();
1199         TreeStatement falseBlock = statementStack.last();
1200         statementStack.removeLast();
1201         TreeStatement trueBlock = statementStack.last();
1202         statementStack.removeLast();
1203         pair<int, int> pos = posStack.last();
1204         posStack.removeLast();
1205         JSTokenLocation elseLocation = tokenLocationStack.last();
1206         tokenLocationStack.removeLast();
1207         statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, falseBlock, pos.first, pos.second));
1208     }
1209
1210     return context.createIfStatement(ifLocation, condition, trueBlock, statementStack.last(), start, end);
1211 }
1212
1213 template <typename LexerType>
1214 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseExpression(TreeBuilder& context)
1215 {
1216     failIfStackOverflow();
1217     JSTokenLocation location(tokenLocation());
1218     TreeExpression node = parseAssignmentExpression(context);
1219     failIfFalse(node);
1220     if (!match(COMMA))
1221         return node;
1222     next();
1223     m_nonTrivialExpressionCount++;
1224     m_nonLHSCount++;
1225     TreeExpression right = parseAssignmentExpression(context);
1226     failIfFalse(right);
1227     typename TreeBuilder::Comma commaNode = context.createCommaExpr(location, node, right);
1228     while (match(COMMA)) {
1229         next(TreeBuilder::DontBuildStrings);
1230         right = parseAssignmentExpression(context);
1231         failIfFalse(right);
1232         context.appendToComma(commaNode, right);
1233     }
1234     return commaNode;
1235 }
1236
1237 template <typename LexerType>
1238 template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpression(TreeBuilder& context)
1239 {
1240     failIfStackOverflow();
1241     JSTextPosition start = tokenStartPosition();
1242     JSTokenLocation location(tokenLocation());
1243     int initialAssignmentCount = m_assignmentCount;
1244     int initialNonLHSCount = m_nonLHSCount;
1245     TreeExpression lhs = parseConditionalExpression(context);
1246     failIfFalse(lhs);
1247     if (initialNonLHSCount != m_nonLHSCount)
1248         return lhs;
1249     
1250     int assignmentStack = 0;
1251     Operator op;
1252     bool hadAssignment = false;
1253     while (true) {
1254         switch (m_token.m_type) {
1255         case EQUAL: op = OpEqual; break;
1256         case PLUSEQUAL: op = OpPlusEq; break;
1257         case MINUSEQUAL: op = OpMinusEq; break;
1258         case MULTEQUAL: op = OpMultEq; break;
1259         case DIVEQUAL: op = OpDivEq; break;
1260         case LSHIFTEQUAL: op = OpLShift; break;
1261         case RSHIFTEQUAL: op = OpRShift; break;
1262         case URSHIFTEQUAL: op = OpURShift; break;
1263         case ANDEQUAL: op = OpAndEq; break;
1264         case XOREQUAL: op = OpXOrEq; break;
1265         case OREQUAL: op = OpOrEq; break;
1266         case MODEQUAL: op = OpModEq; break;
1267         default:
1268             goto end;
1269         }
1270         m_nonTrivialExpressionCount++;
1271         hadAssignment = true;
1272         context.assignmentStackAppend(assignmentStack, lhs, start, tokenStartPosition(), m_assignmentCount, op);
1273         start = tokenStartPosition();
1274         m_assignmentCount++;
1275         next(TreeBuilder::DontBuildStrings);
1276         if (strictMode() && m_lastIdentifier && context.isResolve(lhs)) {
1277             failIfTrueIfStrictWithMessage(m_vm->propertyNames->eval == *m_lastIdentifier, "'eval' cannot be modified in strict mode");
1278             failIfTrueIfStrictWithMessage(m_vm->propertyNames->arguments == *m_lastIdentifier, "'arguments' cannot be modified in strict mode");
1279             declareWrite(m_lastIdentifier);
1280             m_lastIdentifier = 0;
1281         }
1282         lhs = parseAssignmentExpression(context);
1283         failIfFalse(lhs);
1284         if (initialNonLHSCount != m_nonLHSCount)
1285             break;
1286     }
1287 end:
1288     if (hadAssignment)
1289         m_nonLHSCount++;
1290     
1291     if (!TreeBuilder::CreatesAST)
1292         return lhs;
1293     
1294     while (assignmentStack)
1295         lhs = context.createAssignment(location, assignmentStack, lhs, initialAssignmentCount, m_assignmentCount, lastTokenEndPosition());
1296     
1297     return lhs;
1298 }
1299
1300 template <typename LexerType>
1301 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalExpression(TreeBuilder& context)
1302 {
1303     JSTokenLocation location(tokenLocation());
1304     TreeExpression cond = parseBinaryExpression(context);
1305     failIfFalse(cond);
1306     if (!match(QUESTION))
1307         return cond;
1308     m_nonTrivialExpressionCount++;
1309     m_nonLHSCount++;
1310     next(TreeBuilder::DontBuildStrings);
1311     TreeExpression lhs = parseAssignmentExpression(context);
1312     consumeOrFailWithFlags(COLON, TreeBuilder::DontBuildStrings);
1313     
1314     TreeExpression rhs = parseAssignmentExpression(context);
1315     failIfFalse(rhs);
1316     return context.createConditionalExpr(location, cond, lhs, rhs);
1317 }
1318
1319 ALWAYS_INLINE static bool isUnaryOp(JSTokenType token)
1320 {
1321     return token & UnaryOpTokenFlag;
1322 }
1323
1324 template <typename LexerType>
1325 int Parser<LexerType>::isBinaryOperator(JSTokenType token)
1326 {
1327     if (m_allowsIn)
1328         return token & (BinaryOpTokenPrecedenceMask << BinaryOpTokenAllowsInPrecedenceAdditionalShift);
1329     return token & BinaryOpTokenPrecedenceMask;
1330 }
1331
1332 template <typename LexerType>
1333 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseBinaryExpression(TreeBuilder& context)
1334 {
1335     
1336     int operandStackDepth = 0;
1337     int operatorStackDepth = 0;
1338     typename TreeBuilder::BinaryExprContext binaryExprContext(context);
1339     JSTokenLocation location(tokenLocation());
1340     while (true) {
1341         JSTextPosition exprStart = tokenStartPosition();
1342         int initialAssignments = m_assignmentCount;
1343         TreeExpression current = parseUnaryExpression(context);
1344         failIfFalse(current);
1345         
1346         context.appendBinaryExpressionInfo(operandStackDepth, current, exprStart, lastTokenEndPosition(), lastTokenEndPosition(), initialAssignments != m_assignmentCount);
1347         int precedence = isBinaryOperator(m_token.m_type);
1348         if (!precedence)
1349             break;
1350         m_nonTrivialExpressionCount++;
1351         m_nonLHSCount++;
1352         int operatorToken = m_token.m_type;
1353         next(TreeBuilder::DontBuildStrings);
1354         
1355         while (operatorStackDepth &&  context.operatorStackHasHigherPrecedence(operatorStackDepth, precedence)) {
1356             ASSERT(operandStackDepth > 1);
1357             
1358             typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
1359             typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
1360             context.shrinkOperandStackBy(operandStackDepth, 2);
1361             context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
1362             context.operatorStackPop(operatorStackDepth);
1363         }
1364         context.operatorStackAppend(operatorStackDepth, operatorToken, precedence);
1365     }
1366     while (operatorStackDepth) {
1367         ASSERT(operandStackDepth > 1);
1368         
1369         typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
1370         typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
1371         context.shrinkOperandStackBy(operandStackDepth, 2);
1372         context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
1373         context.operatorStackPop(operatorStackDepth);
1374     }
1375     return context.popOperandStack(operandStackDepth);
1376 }
1377
1378 template <typename LexerType>
1379 template <bool complete, class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeBuilder& context)
1380 {
1381     bool wasIdent = false;
1382     switch (m_token.m_type) {
1383     namedProperty:
1384     case IDENT:
1385         wasIdent = true;
1386     case STRING: {
1387         const Identifier* ident = m_token.m_data.ident;
1388         if (complete || (wasIdent && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set)))
1389             nextExpectIdentifier(LexerFlagsIgnoreReservedWords);
1390         else
1391             nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
1392         
1393         if (match(COLON)) {
1394             next();
1395             TreeExpression node = parseAssignmentExpression(context);
1396             failIfFalse(node);
1397             return context.template createProperty<complete>(ident, node, PropertyNode::Constant);
1398         }
1399         failIfFalse(wasIdent);
1400         const Identifier* accessorName = 0;
1401         TreeFormalParameterList parameters = 0;
1402         TreeFunctionBody body = 0;
1403         unsigned openBraceOffset = 0;
1404         unsigned closeBraceOffset = 0;
1405         int bodyStartLine = 0;
1406         unsigned bodyStartColumn = 0;
1407         PropertyNode::Type type;
1408         if (*ident == m_vm->propertyNames->get)
1409             type = PropertyNode::Getter;
1410         else if (*ident == m_vm->propertyNames->set)
1411             type = PropertyNode::Setter;
1412         else
1413             fail();
1414         const Identifier* stringPropertyName = 0;
1415         double numericPropertyName = 0;
1416         if (m_token.m_type == IDENT || m_token.m_type == STRING)
1417             stringPropertyName = m_token.m_data.ident;
1418         else if (m_token.m_type == NUMBER)
1419             numericPropertyName = m_token.m_data.doubleValue;
1420         else
1421             fail();
1422         JSTokenLocation location(tokenLocation());
1423         next();
1424         failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, accessorName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)));
1425         if (stringPropertyName)
1426             return context.template createGetterOrSetterProperty<complete>(location, type, stringPropertyName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastTokenEndPosition.line, bodyStartColumn);
1427         return context.template createGetterOrSetterProperty<complete>(const_cast<VM*>(m_vm), location, type, numericPropertyName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastTokenEndPosition.line, bodyStartColumn);
1428     }
1429     case NUMBER: {
1430         double propertyName = m_token.m_data.doubleValue;
1431         next();
1432         consumeOrFail(COLON);
1433         TreeExpression node = parseAssignmentExpression(context);
1434         failIfFalse(node);
1435         return context.template createProperty<complete>(const_cast<VM*>(m_vm), propertyName, node, PropertyNode::Constant);
1436     }
1437     default:
1438         failIfFalse(m_token.m_type & KeywordTokenFlag);
1439         goto namedProperty;
1440     }
1441 }
1442
1443 template <typename LexerType>
1444 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseObjectLiteral(TreeBuilder& context)
1445 {
1446     int startOffset = m_token.m_data.offset;
1447     unsigned oldLineStartOffset = m_lexer->currentLineStartOffset();
1448     unsigned oldLastLineNumber = m_lexer->lastLineNumber();
1449     unsigned oldLineNumber = m_lexer->lineNumber();
1450     consumeOrFailWithFlags(OPENBRACE, TreeBuilder::DontBuildStrings);
1451     JSTokenLocation location(tokenLocation());
1452
1453     int oldNonLHSCount = m_nonLHSCount;
1454     
1455     if (match(CLOSEBRACE)) {
1456         next();
1457         return context.createObjectLiteral(location);
1458     }
1459     
1460     TreeProperty property = parseProperty<false>(context);
1461     failIfFalse(property);
1462     if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
1463         m_lexer->setOffset(startOffset, oldLineStartOffset);
1464         next();
1465         m_lexer->setLastLineNumber(oldLastLineNumber);
1466         m_lexer->setLineNumber(oldLineNumber);
1467         return parseStrictObjectLiteral(context);
1468     }
1469     TreePropertyList propertyList = context.createPropertyList(location, property);
1470     TreePropertyList tail = propertyList;
1471     while (match(COMMA)) {
1472         next(TreeBuilder::DontBuildStrings);
1473         // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
1474         if (match(CLOSEBRACE))
1475             break;
1476         JSTokenLocation propertyLocation(tokenLocation());
1477         property = parseProperty<false>(context);
1478         failIfFalse(property);
1479         if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
1480             m_lexer->setOffset(startOffset, oldLineStartOffset);
1481             next();
1482             m_lexer->setLastLineNumber(oldLastLineNumber);
1483             m_lexer->setLineNumber(oldLineNumber);
1484             return parseStrictObjectLiteral(context);
1485         }
1486         tail = context.createPropertyList(propertyLocation, property, tail);
1487     }
1488
1489     location = tokenLocation();
1490     consumeOrFail(CLOSEBRACE);
1491     
1492     m_nonLHSCount = oldNonLHSCount;
1493     
1494     return context.createObjectLiteral(location, propertyList);
1495 }
1496
1497 template <typename LexerType>
1498 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseStrictObjectLiteral(TreeBuilder& context)
1499 {
1500     consumeOrFail(OPENBRACE);
1501     
1502     int oldNonLHSCount = m_nonLHSCount;
1503
1504     JSTokenLocation location(tokenLocation());
1505     if (match(CLOSEBRACE)) {
1506         next();
1507         return context.createObjectLiteral(location);
1508     }
1509     
1510     TreeProperty property = parseProperty<true>(context);
1511     failIfFalse(property);
1512     
1513     typedef HashMap<RefPtr<StringImpl>, unsigned, IdentifierRepHash> ObjectValidationMap;
1514     ObjectValidationMap objectValidator;
1515     // Add the first property
1516     if (!m_syntaxAlreadyValidated)
1517         objectValidator.add(context.getName(property).impl(), context.getType(property));
1518     
1519     TreePropertyList propertyList = context.createPropertyList(location, property);
1520     TreePropertyList tail = propertyList;
1521     while (match(COMMA)) {
1522         next();
1523         // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
1524         if (match(CLOSEBRACE))
1525             break;
1526         JSTokenLocation propertyLocation(tokenLocation());
1527         property = parseProperty<true>(context);
1528         failIfFalse(property);
1529         if (!m_syntaxAlreadyValidated) {
1530             ObjectValidationMap::AddResult propertyEntry = objectValidator.add(context.getName(property).impl(), context.getType(property));
1531             if (!propertyEntry.isNewEntry) {
1532                 failIfTrue(propertyEntry.iterator->value == PropertyNode::Constant);
1533                 failIfTrue(context.getType(property) == PropertyNode::Constant);
1534                 failIfTrue(context.getType(property) & propertyEntry.iterator->value);
1535                 propertyEntry.iterator->value |= context.getType(property);
1536             }
1537         }
1538         tail = context.createPropertyList(propertyLocation, property, tail);
1539     }
1540
1541     location = tokenLocation();
1542     consumeOrFail(CLOSEBRACE);
1543
1544     m_nonLHSCount = oldNonLHSCount;
1545
1546     return context.createObjectLiteral(location, propertyList);
1547 }
1548
1549 template <typename LexerType>
1550 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrayLiteral(TreeBuilder& context)
1551 {
1552     consumeOrFailWithFlags(OPENBRACKET, TreeBuilder::DontBuildStrings);
1553     
1554     int oldNonLHSCount = m_nonLHSCount;
1555     
1556     int elisions = 0;
1557     while (match(COMMA)) {
1558         next(TreeBuilder::DontBuildStrings);
1559         elisions++;
1560     }
1561     if (match(CLOSEBRACKET)) {
1562         JSTokenLocation location(tokenLocation());
1563         next(TreeBuilder::DontBuildStrings);
1564         return context.createArray(location, elisions);
1565     }
1566     
1567     TreeExpression elem = parseAssignmentExpression(context);
1568     failIfFalse(elem);
1569     typename TreeBuilder::ElementList elementList = context.createElementList(elisions, elem);
1570     typename TreeBuilder::ElementList tail = elementList;
1571     elisions = 0;
1572     while (match(COMMA)) {
1573         next(TreeBuilder::DontBuildStrings);
1574         elisions = 0;
1575         
1576         while (match(COMMA)) {
1577             next();
1578             elisions++;
1579         }
1580         
1581         if (match(CLOSEBRACKET)) {
1582             JSTokenLocation location(tokenLocation());
1583             next(TreeBuilder::DontBuildStrings);
1584             return context.createArray(location, elisions, elementList);
1585         }
1586         TreeExpression elem = parseAssignmentExpression(context);
1587         failIfFalse(elem);
1588         tail = context.createElementList(tail, elisions, elem);
1589     }
1590
1591     JSTokenLocation location(tokenLocation());
1592     consumeOrFail(CLOSEBRACKET);
1593     
1594     m_nonLHSCount = oldNonLHSCount;
1595     
1596     return context.createArray(location, elementList);
1597 }
1598
1599 template <typename LexerType>
1600 template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpression(TreeBuilder& context)
1601 {
1602     failIfStackOverflow();
1603     switch (m_token.m_type) {
1604     case OPENBRACE:
1605         if (strictMode())
1606             return parseStrictObjectLiteral(context);
1607         return parseObjectLiteral(context);
1608     case OPENBRACKET:
1609         return parseArrayLiteral(context);
1610     case OPENPAREN: {
1611         next();
1612         int oldNonLHSCount = m_nonLHSCount;
1613         TreeExpression result = parseExpression(context);
1614         m_nonLHSCount = oldNonLHSCount;
1615         consumeOrFail(CLOSEPAREN);
1616         
1617         return result;
1618     }
1619     case THISTOKEN: {
1620         JSTokenLocation location(tokenLocation());
1621         next();
1622         return context.thisExpr(location);
1623     }
1624     case IDENT: {
1625         JSTextPosition start = tokenStartPosition();
1626         const Identifier* ident = m_token.m_data.ident;
1627         JSTokenLocation location(tokenLocation());
1628         next();
1629         currentScope()->useVariable(ident, m_vm->propertyNames->eval == *ident);
1630         m_lastIdentifier = ident;
1631         return context.createResolve(location, ident, start);
1632     }
1633     case STRING: {
1634         const Identifier* ident = m_token.m_data.ident;
1635         JSTokenLocation location(tokenLocation());
1636         next();
1637         return context.createString(location, ident);
1638     }
1639     case NUMBER: {
1640         double d = m_token.m_data.doubleValue;
1641         JSTokenLocation location(tokenLocation());
1642         next();
1643         return context.createNumberExpr(location, d);
1644     }
1645     case NULLTOKEN: {
1646         JSTokenLocation location(tokenLocation());
1647         next();
1648         return context.createNull(location);
1649     }
1650     case TRUETOKEN: {
1651         JSTokenLocation location(tokenLocation());
1652         next();
1653         return context.createBoolean(location, true);
1654     }
1655     case FALSETOKEN: {
1656         JSTokenLocation location(tokenLocation());
1657         next();
1658         return context.createBoolean(location, false);
1659     }
1660     case DIVEQUAL:
1661     case DIVIDE: {
1662         /* regexp */
1663         const Identifier* pattern;
1664         const Identifier* flags;
1665         if (match(DIVEQUAL))
1666             failIfFalse(m_lexer->scanRegExp(pattern, flags, '='));
1667         else
1668             failIfFalse(m_lexer->scanRegExp(pattern, flags));
1669         
1670         JSTextPosition start = tokenStartPosition();
1671         JSTokenLocation location(tokenLocation());
1672         next();
1673         TreeExpression re = context.createRegExp(location, *pattern, *flags, start);
1674         if (!re) {
1675             const char* yarrErrorMsg = Yarr::checkSyntax(pattern->string());
1676             failWithMessage(yarrErrorMsg);
1677         }
1678         return re;
1679     }
1680     default:
1681         fail();
1682     }
1683 }
1684
1685 template <typename LexerType>
1686 template <class TreeBuilder> TreeArguments Parser<LexerType>::parseArguments(TreeBuilder& context)
1687 {
1688     consumeOrFailWithFlags(OPENPAREN, TreeBuilder::DontBuildStrings);
1689     JSTokenLocation location(tokenLocation());
1690     if (match(CLOSEPAREN)) {
1691         next(TreeBuilder::DontBuildStrings);
1692         return context.createArguments();
1693     }
1694     TreeExpression firstArg = parseAssignmentExpression(context);
1695     failIfFalse(firstArg);
1696     
1697     TreeArgumentsList argList = context.createArgumentsList(location, firstArg);
1698     TreeArgumentsList tail = argList;
1699     while (match(COMMA)) {
1700         JSTokenLocation argumentLocation(tokenLocation());
1701         next(TreeBuilder::DontBuildStrings);
1702         TreeExpression arg = parseAssignmentExpression(context);
1703         failIfFalse(arg);
1704         tail = context.createArgumentsList(argumentLocation, tail, arg);
1705     }
1706     consumeOrFail(CLOSEPAREN);
1707     return context.createArguments(argList);
1708 }
1709
1710 template <typename LexerType>
1711 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpression(TreeBuilder& context)
1712 {
1713     TreeExpression base = 0;
1714     JSTextPosition expressionStart = tokenStartPosition();
1715     int newCount = 0;
1716     JSTokenLocation location;
1717     while (match(NEW)) {
1718         next();
1719         newCount++;
1720     }
1721     
1722     if (match(FUNCTION)) {
1723         const Identifier* name = &m_vm->propertyNames->nullIdentifier;
1724         TreeFormalParameterList parameters = 0;
1725         TreeFunctionBody body = 0;
1726         unsigned openBraceOffset = 0;
1727         unsigned closeBraceOffset = 0;
1728         int bodyStartLine = 0;
1729         unsigned bodyStartColumn = 0;
1730         location = tokenLocation();
1731         next();
1732         failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, name, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)));
1733         base = context.createFunctionExpr(location, name, body, parameters, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastTokenEndPosition.line, bodyStartColumn);
1734     } else
1735         base = parsePrimaryExpression(context);
1736     
1737     failIfFalse(base);
1738     while (true) {
1739         location = tokenLocation();
1740         switch (m_token.m_type) {
1741         case OPENBRACKET: {
1742             m_nonTrivialExpressionCount++;
1743             JSTextPosition expressionEnd = lastTokenEndPosition();
1744             next();
1745             int nonLHSCount = m_nonLHSCount;
1746             int initialAssignments = m_assignmentCount;
1747             TreeExpression property = parseExpression(context);
1748             failIfFalse(property);
1749             base = context.createBracketAccess(location, base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEndPosition());
1750             consumeOrFail(CLOSEBRACKET);
1751             m_nonLHSCount = nonLHSCount;
1752             break;
1753         }
1754         case OPENPAREN: {
1755             m_nonTrivialExpressionCount++;
1756             int nonLHSCount = m_nonLHSCount;
1757             if (newCount) {
1758                 newCount--;
1759                 JSTextPosition expressionEnd = lastTokenEndPosition();
1760                 TreeArguments arguments = parseArguments(context);
1761                 failIfFalse(arguments);
1762                 base = context.createNewExpr(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition());
1763             } else {
1764                 JSTextPosition expressionEnd = lastTokenEndPosition();
1765                 TreeArguments arguments = parseArguments(context);
1766                 failIfFalse(arguments);
1767                 base = context.makeFunctionCallNode(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition());
1768             }
1769             m_nonLHSCount = nonLHSCount;
1770             break;
1771         }
1772         case DOT: {
1773             m_nonTrivialExpressionCount++;
1774             JSTextPosition expressionEnd = lastTokenEndPosition();
1775             nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
1776             matchOrFail(IDENT);
1777             base = context.createDotAccess(location, base, m_token.m_data.ident, expressionStart, expressionEnd, tokenEndPosition());
1778             next();
1779             break;
1780         }
1781         default:
1782             goto endMemberExpression;
1783         }
1784     }
1785 endMemberExpression:
1786     while (newCount--)
1787         base = context.createNewExpr(location, base, expressionStart, lastTokenEndPosition());
1788     return base;
1789 }
1790
1791 template <typename LexerType>
1792 template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpression(TreeBuilder& context)
1793 {
1794     typename TreeBuilder::UnaryExprContext unaryExprContext(context);
1795     AllowInOverride allowInOverride(this);
1796     int tokenStackDepth = 0;
1797     bool modifiesExpr = false;
1798     bool requiresLExpr = false;
1799     while (isUnaryOp(m_token.m_type)) {
1800         if (strictMode()) {
1801             switch (m_token.m_type) {
1802             case PLUSPLUS:
1803             case MINUSMINUS:
1804             case AUTOPLUSPLUS:
1805             case AUTOMINUSMINUS:
1806                 failIfTrue(requiresLExpr);
1807                 modifiesExpr = true;
1808                 requiresLExpr = true;
1809                 break;
1810             case DELETETOKEN:
1811                 failIfTrue(requiresLExpr);
1812                 requiresLExpr = true;
1813                 break;
1814             default:
1815                 failIfTrue(requiresLExpr);
1816                 break;
1817             }
1818         }
1819         m_nonLHSCount++;
1820         context.appendUnaryToken(tokenStackDepth, m_token.m_type, tokenStartPosition());
1821         next();
1822         m_nonTrivialExpressionCount++;
1823     }
1824     JSTextPosition subExprStart = tokenStartPosition();
1825     ASSERT(subExprStart.offset >= subExprStart.lineStartOffset);
1826     JSTokenLocation location(tokenLocation());
1827     TreeExpression expr = parseMemberExpression(context);
1828     failIfFalse(expr);
1829     bool isEvalOrArguments = false;
1830     if (strictMode() && !m_syntaxAlreadyValidated) {
1831         if (context.isResolve(expr))
1832             isEvalOrArguments = *m_lastIdentifier == m_vm->propertyNames->eval || *m_lastIdentifier == m_vm->propertyNames->arguments;
1833     }
1834     failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments && modifiesExpr, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
1835     switch (m_token.m_type) {
1836     case PLUSPLUS:
1837         m_nonTrivialExpressionCount++;
1838         m_nonLHSCount++;
1839         expr = context.makePostfixNode(location, expr, OpPlusPlus, subExprStart, lastTokenEndPosition(), tokenEndPosition());
1840         m_assignmentCount++;
1841         failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
1842         failIfTrueIfStrict(requiresLExpr);
1843         next();
1844         break;
1845     case MINUSMINUS:
1846         m_nonTrivialExpressionCount++;
1847         m_nonLHSCount++;
1848         expr = context.makePostfixNode(location, expr, OpMinusMinus, subExprStart, lastTokenEndPosition(), tokenEndPosition());
1849         m_assignmentCount++;
1850         failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
1851         failIfTrueIfStrict(requiresLExpr);
1852         next();
1853         break;
1854     default:
1855         break;
1856     }
1857     
1858     JSTextPosition end = lastTokenEndPosition();
1859
1860     if (!TreeBuilder::CreatesAST && (m_syntaxAlreadyValidated || !strictMode()))
1861         return expr;
1862
1863     location = tokenLocation();
1864     location.line = m_lexer->lastLineNumber();
1865     while (tokenStackDepth) {
1866         switch (context.unaryTokenStackLastType(tokenStackDepth)) {
1867         case EXCLAMATION:
1868             expr = context.createLogicalNot(location, expr);
1869             break;
1870         case TILDE:
1871             expr = context.makeBitwiseNotNode(location, expr);
1872             break;
1873         case MINUS:
1874             expr = context.makeNegateNode(location, expr);
1875             break;
1876         case PLUS:
1877             expr = context.createUnaryPlus(location, expr);
1878             break;
1879         case PLUSPLUS:
1880         case AUTOPLUSPLUS:
1881             expr = context.makePrefixNode(location, expr, OpPlusPlus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
1882             m_assignmentCount++;
1883             break;
1884         case MINUSMINUS:
1885         case AUTOMINUSMINUS:
1886             expr = context.makePrefixNode(location, expr, OpMinusMinus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
1887             m_assignmentCount++;
1888             break;
1889         case TYPEOF:
1890             expr = context.makeTypeOfNode(location, expr);
1891             break;
1892         case VOIDTOKEN:
1893             expr = context.createVoid(location, expr);
1894             break;
1895         case DELETETOKEN:
1896             failIfTrueIfStrictWithNameAndMessage(context.isResolve(expr), "Cannot delete unqualified property", m_lastIdentifier->impl(), "in strict mode");
1897             expr = context.makeDeleteNode(location, expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end);
1898             break;
1899         default:
1900             // If we get here something has gone horribly horribly wrong
1901             CRASH();
1902         }
1903         subExprStart = context.unaryTokenStackLastStart(tokenStackDepth);
1904         context.unaryTokenStackRemoveLast(tokenStackDepth);
1905     }
1906     return expr;
1907 }
1908
1909 // Instantiate the two flavors of Parser we need instead of putting most of this file in Parser.h
1910 template class Parser< Lexer<LChar> >;
1911 template class Parser< Lexer<UChar> >;
1912
1913 } // namespace JSC