Source/JavaScriptCore/parser/Parser.cpp

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