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