/*
* Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
* Copyright (C) 2001 Peter Kelly (pmk@post.com)
- * Copyright (C) 2003, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
#include "config.h"
#include "Parser.h"
+#include "ASTBuilder.h"
+#include "CodeBlock.h"
#include "Debugger.h"
+#include "JSCJSValueInlines.h"
#include "Lexer.h"
-#include <wtf/HashSet.h>
-#include <wtf/Vector.h>
-#include <memory>
+#include "NodeInfo.h"
+#include "JSCInlines.h"
+#include "SourceProvider.h"
+#include "VM.h"
+#include <utility>
+#include <wtf/HashFunctions.h>
+#include <wtf/OwnPtr.h>
+#include <wtf/StringPrintStream.h>
+#include <wtf/WTFThreadData.h>
-using std::auto_ptr;
-#ifndef yyparse
-extern int jscyyparse(void*);
-#endif
+#define updateErrorMessage(shouldPrintToken, ...) do {\
+ propagateError(); \
+ logError(shouldPrintToken, __VA_ARGS__); \
+} while (0)
+
+#define propagateError() do { if (hasError()) return 0; } while (0)
+#define internalFailWithMessage(shouldPrintToken, ...) do { updateErrorMessage(shouldPrintToken, __VA_ARGS__); return 0; } while (0)
+#define handleErrorToken() do { if (m_token.m_type == EOFTOK || m_token.m_type & ErrorTokenFlag) { failDueToUnexpectedToken(); } } while (0)
+#define failWithMessage(...) do { { handleErrorToken(); updateErrorMessage(true, __VA_ARGS__); } return 0; } while (0)
+#define failWithStackOverflow() do { updateErrorMessage(false, "Stack exhausted"); m_hasStackOverflow = true; return 0; } while (0)
+#define failIfFalse(cond, ...) do { if (!(cond)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
+#define failIfTrue(cond, ...) do { if (cond) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
+#define failIfTrueIfStrict(cond, ...) do { if ((cond) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)
+#define failIfFalseIfStrict(cond, ...) do { if ((!(cond)) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)
+#define consumeOrFail(tokenType, ...) do { if (!consume(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
+#define consumeOrFailWithFlags(tokenType, flags, ...) do { if (!consume(tokenType, flags)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
+#define matchOrFail(tokenType, ...) do { if (!match(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)
+#define failIfStackOverflow() do { if (!canRecurse()) failWithStackOverflow(); } while (0)
+#define semanticFail(...) do { internalFailWithMessage(false, __VA_ARGS__); } while (0)
+#define semanticFailIfTrue(cond, ...) do { if (cond) internalFailWithMessage(false, __VA_ARGS__); } while (0)
+#define semanticFailIfFalse(cond, ...) do { if (!(cond)) internalFailWithMessage(false, __VA_ARGS__); } while (0)
+#define regexFail(failure) do { setErrorMessage(failure); return 0; } while (0)
+#define failDueToUnexpectedToken() do {\
+ logError(true);\
+ return 0;\
+} while (0)
+
+#define handleProductionOrFail(token, tokenString, operation, production) do {\
+ consumeOrFail(token, "Expected '", tokenString, "' to ", operation, " a ", production);\
+} while (0)
+
+#define semanticFailureDueToKeyword(...) do { \
+ if (strictMode() && m_token.m_type == RESERVED_IF_STRICT) \
+ semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__, " in strict mode"); \
+ if (m_token.m_type == RESERVED || m_token.m_type == RESERVED_IF_STRICT) \
+ semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__); \
+ if (m_token.m_type & KeywordTokenFlag) \
+ semanticFail("Cannot use the keyword '", getToken(), "' as a ", __VA_ARGS__); \
+} while (0)
+
+using namespace std;
namespace JSC {
-void Parser::parse(JSGlobalData* globalData, int* errLine, UString* errMsg)
+template <typename LexerType>
+void Parser<LexerType>::logError(bool)
{
- ASSERT(!m_sourceElements);
+ if (hasError())
+ return;
+ StringPrintStream stream;
+ printUnexpectedTokenText(stream);
+ setErrorMessage(stream.toString());
+}
- int defaultErrLine;
- UString defaultErrMsg;
+template <typename LexerType> template <typename A>
+void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1)
+{
+ if (hasError())
+ return;
+ StringPrintStream stream;
+ if (shouldPrintToken) {
+ printUnexpectedTokenText(stream);
+ stream.print(". ");
+ }
+ stream.print(value1, ".");
+ setErrorMessage(stream.toString());
+}
- if (!errLine)
- errLine = &defaultErrLine;
- if (!errMsg)
- errMsg = &defaultErrMsg;
+template <typename LexerType> template <typename A, typename B>
+void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2)
+{
+ if (hasError())
+ return;
+ StringPrintStream stream;
+ if (shouldPrintToken) {
+ printUnexpectedTokenText(stream);
+ stream.print(". ");
+ }
+ stream.print(value1, value2, ".");
+ setErrorMessage(stream.toString());
+}
- *errLine = -1;
- *errMsg = 0;
+template <typename LexerType> template <typename A, typename B, typename C>
+void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2, const C& value3)
+{
+ if (hasError())
+ return;
+ StringPrintStream stream;
+ if (shouldPrintToken) {
+ printUnexpectedTokenText(stream);
+ stream.print(". ");
+ }
+ stream.print(value1, value2, value3, ".");
+ setErrorMessage(stream.toString());
+}
- Lexer& lexer = *globalData->lexer;
- lexer.setCode(*m_source);
+template <typename LexerType> template <typename A, typename B, typename C, typename D>
+void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2, const C& value3, const D& value4)
+{
+ if (hasError())
+ return;
+ StringPrintStream stream;
+ if (shouldPrintToken) {
+ printUnexpectedTokenText(stream);
+ stream.print(". ");
+ }
+ stream.print(value1, value2, value3, value4, ".");
+ setErrorMessage(stream.toString());
+}
+
+template <typename LexerType> template <typename A, typename B, typename C, typename D, typename E>
+void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2, const C& value3, const D& value4, const E& value5)
+{
+ if (hasError())
+ return;
+ StringPrintStream stream;
+ if (shouldPrintToken) {
+ printUnexpectedTokenText(stream);
+ stream.print(". ");
+ }
+ stream.print(value1, value2, value3, value4, value5, ".");
+ setErrorMessage(stream.toString());
+}
- int parseError = jscyyparse(globalData);
- bool lexError = lexer.sawError();
- lexer.clear();
+template <typename LexerType> template <typename A, typename B, typename C, typename D, typename E, typename F>
+void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B& value2, const C& value3, const D& value4, const E& value5, const F& value6)
+{
+ if (hasError())
+ return;
+ StringPrintStream stream;
+ if (shouldPrintToken) {
+ printUnexpectedTokenText(stream);
+ stream.print(". ");
+ }
+ stream.print(value1, value2, value3, value4, value5, value6, ".");
+ setErrorMessage(stream.toString());
+}
- ParserRefCounted::deleteNewObjects(globalData);
+template <typename LexerType> template <typename A, typename B, typename C, typename D, typename E, typename F, typename G>
+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)
+{
+ if (hasError())
+ return;
+ StringPrintStream stream;
+ if (shouldPrintToken) {
+ printUnexpectedTokenText(stream);
+ stream.print(". ");
+ }
+ stream.print(value1, value2, value3, value4, value5, value6, value7, ".");
+ setErrorMessage(stream.toString());
+}
- if (parseError || lexError) {
- *errLine = lexer.lineNo();
- *errMsg = "Parse error";
- m_sourceElements.clear();
+template <typename LexerType>
+Parser<LexerType>::Parser(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name, JSParserStrictness strictness, JSParserMode parserMode)
+ : m_vm(vm)
+ , m_source(&source)
+ , m_hasStackOverflow(false)
+ , m_allowsIn(true)
+ , m_assignmentCount(0)
+ , m_nonLHSCount(0)
+ , m_syntaxAlreadyValidated(source.provider()->isValid())
+ , m_statementDepth(0)
+ , m_nonTrivialExpressionCount(0)
+ , m_lastIdentifier(0)
+ , m_lastFunctionName(nullptr)
+ , m_sourceElements(0)
+ , m_parsingBuiltin(strictness == JSParseBuiltin)
+{
+ m_lexer = adoptPtr(new LexerType(vm, strictness));
+ m_arena = m_vm->parserArena.get();
+ m_lexer->setCode(source, m_arena);
+ m_token.m_location.line = source.firstLine();
+ m_token.m_location.startOffset = source.startOffset();
+ m_token.m_location.endOffset = source.startOffset();
+ m_token.m_location.lineStartOffset = source.startOffset();
+ m_functionCache = vm->addSourceProviderCache(source.provider());
+ ScopeRef scope = pushScope();
+ if (parserMode == JSParseFunctionCode)
+ scope->setIsFunction();
+ if (strictness == JSParseStrict)
+ scope->setStrictMode();
+ if (parameters) {
+ bool hadBindingParameters = false;
+ for (unsigned i = 0; i < parameters->size(); i++) {
+ auto parameter = parameters->at(i);
+ if (!parameter->isBindingNode()) {
+ hadBindingParameters = true;
+ continue;
+ }
+ scope->declareParameter(&static_cast<BindingNode*>(parameter)->boundProperty());
+ }
+ if (hadBindingParameters) {
+ Vector<Identifier> boundParameterNames;
+ for (unsigned i = 0; i < parameters->size(); i++) {
+ auto parameter = parameters->at(i);
+ if (parameter->isBindingNode())
+ continue;
+ parameter->collectBoundIdentifiers(boundParameterNames);
+ }
+ for (auto& boundParameterName : boundParameterNames)
+ scope->declareVariable(&boundParameterName);
+ }
}
+ if (!name.isNull())
+ scope->declareCallee(&name);
+ next();
}
-void Parser::reparseInPlace(JSGlobalData* globalData, FunctionBodyNode* functionBodyNode)
+template <typename LexerType>
+Parser<LexerType>::~Parser()
{
- ASSERT(!functionBodyNode->data());
+}
- m_source = &functionBodyNode->source();
- globalData->lexer->setIsReparsing();
- parse(globalData, 0, 0);
- ASSERT(m_sourceElements);
+template <typename LexerType>
+String Parser<LexerType>::parseInner()
+{
+ String parseError = String();
+
+ ASTBuilder context(const_cast<VM*>(m_vm), const_cast<SourceCode*>(m_source));
+ if (m_lexer->isReparsing())
+ m_statementDepth--;
+ ScopeRef scope = currentScope();
+ SourceElements* sourceElements = parseSourceElements(context, CheckForStrictMode);
+ if (!sourceElements || !consume(EOFTOK)) {
+ if (hasError())
+ parseError = m_errorMessage;
+ else
+ parseError = ASCIILiteral("Parser error");
+ }
- functionBodyNode->adoptData(std::auto_ptr<ScopeNodeData>(new ScopeNodeData(m_sourceElements.get(),
- m_varDeclarations ? &m_varDeclarations->data : 0,
- m_funcDeclarations ? &m_funcDeclarations->data : 0,
- m_numConstants)));
- bool usesArguments = functionBodyNode->usesArguments();
- functionBodyNode->setFeatures(m_features);
- if (usesArguments && !functionBodyNode->usesArguments())
- functionBodyNode->setUsesArguments();
+ IdentifierSet capturedVariables;
+ bool modifiedParameter = false;
+ scope->getCapturedVariables(capturedVariables, modifiedParameter);
+
+ CodeFeatures features = context.features();
+ if (scope->strictMode())
+ features |= StrictModeFeature;
+ if (scope->shadowsArguments())
+ features |= ShadowsArgumentsFeature;
+ if (modifiedParameter)
+ features |= ModifiedParameterFeature;
+
+ Vector<RefPtr<StringImpl>> closedVariables;
+ if (m_parsingBuiltin) {
+ RELEASE_ASSERT(!capturedVariables.size());
+ IdentifierSet usedVariables;
+ scope->getUsedVariables(usedVariables);
+ for (const auto& variable : usedVariables) {
+ if (scope->hasDeclaredVariable(Identifier(m_vm, variable.get())))
+ continue;
+
+ if (scope->hasDeclaredParameter(Identifier(m_vm, variable.get())))
+ continue;
+ closedVariables.append(variable);
+ }
+ }
+ didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), features,
+ context.numConstants(), capturedVariables, WTF::move(closedVariables));
- m_source = 0;
- m_sourceElements = 0;
- m_varDeclarations = 0;
- m_funcDeclarations = 0;
+ return parseError;
}
-void Parser::didFinishParsing(SourceElements* sourceElements, ParserRefCountedData<DeclarationStacks::VarStack>* varStack,
- ParserRefCountedData<DeclarationStacks::FunctionStack>* funcStack, CodeFeatures features, int lastLine, int numConstants)
+template <typename LexerType>
+void Parser<LexerType>::didFinishParsing(SourceElements* sourceElements, ParserArenaData<DeclarationStacks::VarStack>* varStack,
+ ParserArenaData<DeclarationStacks::FunctionStack>* funcStack, CodeFeatures features, int numConstants, IdentifierSet& capturedVars, const Vector<RefPtr<StringImpl>>&& closedVariables)
{
m_sourceElements = sourceElements;
m_varDeclarations = varStack;
m_funcDeclarations = funcStack;
+ m_capturedVariables.swap(capturedVars);
+ m_closedVariables = closedVariables;
m_features = features;
- m_lastLine = lastLine;
m_numConstants = numConstants;
}
+template <typename LexerType>
+bool Parser<LexerType>::allowAutomaticSemicolon()
+{
+ return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator();
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceElements(TreeBuilder& context, SourceElementsMode mode)
+{
+ const unsigned lengthOfUseStrictLiteral = 12; // "use strict".length
+ TreeSourceElements sourceElements = context.createSourceElements();
+ bool seenNonDirective = false;
+ const Identifier* directive = 0;
+ unsigned directiveLiteralLength = 0;
+ auto savePoint = createSavePoint();
+ bool hasSetStrict = false;
+ while (TreeStatement statement = parseStatement(context, directive, &directiveLiteralLength)) {
+ if (mode == CheckForStrictMode && !seenNonDirective) {
+ if (directive) {
+ // "use strict" must be the exact literal without escape sequences or line continuation.
+ if (!hasSetStrict && directiveLiteralLength == lengthOfUseStrictLiteral && m_vm->propertyNames->useStrictIdentifier == *directive) {
+ setStrictMode();
+ hasSetStrict = true;
+ if (!isValidStrictMode()) {
+ if (m_lastFunctionName) {
+ if (m_vm->propertyNames->arguments == *m_lastFunctionName)
+ semanticFail("Cannot name a function 'arguments' in strict mode");
+ if (m_vm->propertyNames->eval == *m_lastFunctionName)
+ semanticFail("Cannot name a function 'eval' in strict mode");
+ }
+ if (hasDeclaredVariable(m_vm->propertyNames->arguments))
+ semanticFail("Cannot declare a variable named 'arguments' in strict mode");
+ if (hasDeclaredVariable(m_vm->propertyNames->eval))
+ semanticFail("Cannot declare a variable named 'eval' in strict mode");
+ semanticFailIfFalse(isValidStrictMode(), "Invalid parameters or function name in strict mode");
+ }
+ restoreSavePoint(savePoint);
+ propagateError();
+ continue;
+ }
+ } else
+ seenNonDirective = true;
+ }
+ context.appendStatement(sourceElements, statement);
+ }
+
+ propagateError();
+ return sourceElements;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVarDeclaration(TreeBuilder& context)
+{
+ ASSERT(match(VAR));
+ JSTokenLocation location(tokenLocation());
+ int start = tokenLine();
+ int end = 0;
+ int scratch;
+ TreeDeconstructionPattern scratch1 = 0;
+ TreeExpression scratch2 = 0;
+ JSTextPosition scratch3;
+ TreeExpression varDecls = parseVarDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3);
+ propagateError();
+ failIfFalse(autoSemiColon(), "Expected ';' after var declaration");
+
+ return context.createVarStatement(location, varDecls, start, end);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseConstDeclaration(TreeBuilder& context)
+{
+ ASSERT(match(CONSTTOKEN));
+ JSTokenLocation location(tokenLocation());
+ int start = tokenLine();
+ int end = 0;
+ TreeConstDeclList constDecls = parseConstDeclarationList(context);
+ propagateError();
+ failIfFalse(autoSemiColon(), "Expected ';' after const declaration");
+
+ return context.createConstStatement(location, constDecls, start, end);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDoWhileStatement(TreeBuilder& context)
+{
+ ASSERT(match(DO));
+ int startLine = tokenLine();
+ next();
+ const Identifier* unused = 0;
+ startLoop();
+ TreeStatement statement = parseStatement(context, unused);
+ endLoop();
+ failIfFalse(statement, "Expected a statement following 'do'");
+ int endLine = tokenLine();
+ JSTokenLocation location(tokenLocation());
+ handleProductionOrFail(WHILE, "while", "end", "do-while loop");
+ handleProductionOrFail(OPENPAREN, "(", "start", "do-while loop condition");
+ semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a do-while loop condition");
+ TreeExpression expr = parseExpression(context);
+ failIfFalse(expr, "Unable to parse do-while loop condition");
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "do-while loop condition");
+ if (match(SEMICOLON))
+ next(); // Always performs automatic semicolon insertion.
+ return context.createDoWhileStatement(location, statement, expr, startLine, endLine);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWhileStatement(TreeBuilder& context)
+{
+ ASSERT(match(WHILE));
+ JSTokenLocation location(tokenLocation());
+ int startLine = tokenLine();
+ next();
+
+ handleProductionOrFail(OPENPAREN, "(", "start", "while loop condition");
+ semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a while loop condition");
+ TreeExpression expr = parseExpression(context);
+ failIfFalse(expr, "Unable to parse while loop condition");
+ int endLine = tokenLine();
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "while loop condition");
+
+ const Identifier* unused = 0;
+ startLoop();
+ TreeStatement statement = parseStatement(context, unused);
+ endLoop();
+ failIfFalse(statement, "Expected a statement as the body of a while loop");
+ return context.createWhileStatement(location, expr, statement, startLine, endLine);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarationList(TreeBuilder& context, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd)
+{
+ TreeExpression varDecls = 0;
+ const Identifier* lastIdent;
+ do {
+ lastIdent = 0;
+ lastPattern = 0;
+ JSTokenLocation location(tokenLocation());
+ next();
+ TreeExpression node = 0;
+ declarations++;
+ bool hasInitializer = false;
+ if (match(IDENT)) {
+ JSTextPosition varStart = tokenStartPosition();
+ identStart = varStart;
+ const Identifier* name = m_token.m_data.ident;
+ lastIdent = name;
+ next();
+ hasInitializer = match(EQUAL);
+ failIfFalseIfStrict(declareVariable(name), "Cannot declare a variable named ", name->impl(), " in strict mode");
+ context.addVar(name, (hasInitializer || (!m_allowsIn && (match(INTOKEN) || isofToken()))) ? DeclarationStacks::HasInitializer : 0);
+ if (hasInitializer) {
+ JSTextPosition varDivot = tokenStartPosition() + 1;
+ initStart = tokenStartPosition();
+ next(TreeBuilder::DontBuildStrings); // consume '='
+ TreeExpression initializer = parseAssignmentExpression(context);
+ initEnd = lastTokenEndPosition();
+ lastInitializer = initializer;
+ failIfFalse(initializer, "Expected expression as the intializer for the variable '", name->impl(), "'");
+
+ node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEndPosition());
+ }
+ } else {
+ lastIdent = 0;
+ auto pattern = parseDeconstructionPattern(context, DeconstructToVariables);
+ failIfFalse(pattern, "Cannot parse this deconstruction pattern");
+ hasInitializer = match(EQUAL);
+ lastPattern = pattern;
+ if (hasInitializer) {
+ next(TreeBuilder::DontBuildStrings); // consume '='
+ TreeExpression rhs = parseExpression(context);
+ node = context.createDeconstructingAssignment(location, pattern, rhs);
+ lastInitializer = rhs;
+ }
+ }
+
+ if (hasInitializer) {
+ if (!varDecls)
+ varDecls = node;
+ else
+ varDecls = context.combineCommaNodes(location, varDecls, node);
+ }
+ } while (match(COMMA));
+ if (lastIdent)
+ lastPattern = createBindingPattern(context, DeconstructToVariables, *lastIdent, 0);
+ return varDecls;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, DeconstructionKind kind, const Identifier& name, int depth)
+{
+ ASSERT(!name.isEmpty());
+ ASSERT(!name.isNull());
+
+ ASSERT(name.impl()->isAtomic());
+ if (depth) {
+ if (kind == DeconstructToVariables)
+ failIfFalseIfStrict(declareVariable(&name), "Cannot deconstruct to a variable named '", name.impl(), "' in strict mode");
+ if (kind == DeconstructToParameters) {
+ auto bindingResult = declareBoundParameter(&name);
+ if (bindingResult == Scope::StrictBindingFailed && strictMode()) {
+ semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot deconstruct to a parameter name '", name.impl(), "' in strict mode");
+ if (m_lastFunctionName && name == *m_lastFunctionName)
+ semanticFail("Cannot deconstruct to '", name.impl(), "' as it shadows the name of a strict mode function");
+ semanticFailureDueToKeyword("bound parameter name");
+ if (hasDeclaredParameter(name))
+ semanticFail("Cannot deconstruct to '", name.impl(), "' as it has already been declared");
+ semanticFail("Cannot bind to a parameter named '", name.impl(), "' in strict mode");
+ }
+ if (bindingResult == Scope::BindingFailed) {
+ semanticFailureDueToKeyword("bound parameter name");
+ if (hasDeclaredParameter(name))
+ semanticFail("Cannot deconstruct to '", name.impl(), "' as it has already been declared");
+ semanticFail("Cannot deconstruct to a parameter named '", name.impl(), "'");
+ }
+ }
+ if (kind != DeconstructToExpressions)
+ context.addVar(&name, DeclarationStacks::HasInitializer);
+
+ } else {
+ if (kind == DeconstructToVariables) {
+ failIfFalseIfStrict(declareVariable(&name), "Cannot declare a variable named '", name.impl(), "' in strict mode");
+ context.addVar(&name, DeclarationStacks::HasInitializer);
+ }
+
+ if (kind == DeconstructToParameters) {
+ bool declarationResult = declareParameter(&name);
+ if (!declarationResult && strictMode()) {
+ semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot deconstruct to a parameter name '", name.impl(), "' in strict mode");
+ if (m_lastFunctionName && name == *m_lastFunctionName)
+ semanticFail("Cannot declare a parameter named '", name.impl(), "' as it shadows the name of a strict mode function");
+ semanticFailureDueToKeyword("parameter name");
+ if (hasDeclaredParameter(name))
+ semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode as it has already been declared");
+ semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode");
+ }
+ }
+ }
+ return context.createBindingLocation(m_token.m_location, name, m_token.m_startPosition, m_token.m_endPosition);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::tryParseDeconstructionPatternExpression(TreeBuilder& context)
+{
+ return parseDeconstructionPattern(context, DeconstructToExpressions);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::parseDeconstructionPattern(TreeBuilder& context, DeconstructionKind kind, int depth)
+{
+ failIfStackOverflow();
+ int nonLHSCount = m_nonLHSCount;
+ TreeDeconstructionPattern pattern;
+ switch (m_token.m_type) {
+ case OPENBRACKET: {
+ auto arrayPattern = context.createArrayPattern(m_token.m_location);
+ next();
+ if (kind == DeconstructToExpressions && match(CLOSEBRACKET))
+ return 0;
+ failIfTrue(match(CLOSEBRACKET), "There must be at least one bound property in an array deconstruction pattern");
+ do {
+ while (match(COMMA)) {
+ context.appendArrayPatternSkipEntry(arrayPattern, m_token.m_location);
+ next();
+ }
+ propagateError();
+ JSTokenLocation location = m_token.m_location;
+ auto innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
+ if (kind == DeconstructToExpressions && !innerPattern)
+ return 0;
+ failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");
+ context.appendArrayPatternEntry(arrayPattern, location, innerPattern);
+ } while (consume(COMMA));
+
+ if (kind == DeconstructToExpressions && !match(CLOSEBRACKET))
+ return 0;
+
+ consumeOrFail(CLOSEBRACKET, "Expected either a closing ']' or a ',' following an element deconstruction pattern");
+ pattern = arrayPattern;
+ break;
+ }
+ case OPENBRACE: {
+ next();
+
+ if (kind == DeconstructToExpressions && match(CLOSEBRACE))
+ return 0;
+
+ failIfTrue(match(CLOSEBRACE), "There must be at least one bound property in an object deconstruction pattern");
+ auto objectPattern = context.createObjectPattern(m_token.m_location);
+ bool wasString = false;
+ do {
+ Identifier propertyName;
+ TreeDeconstructionPattern innerPattern = 0;
+ JSTokenLocation location = m_token.m_location;
+ if (match(IDENT)) {
+ propertyName = *m_token.m_data.ident;
+ next();
+ if (consume(COLON))
+ innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
+ else
+ innerPattern = createBindingPattern(context, kind, propertyName, depth);
+ } else {
+ JSTokenType tokenType = m_token.m_type;
+ switch (m_token.m_type) {
+ case NUMBER:
+ propertyName = Identifier::from(m_vm, m_token.m_data.doubleValue);
+ break;
+ case STRING:
+ propertyName = *m_token.m_data.ident;
+ wasString = true;
+ break;
+ default:
+ if (m_token.m_type != RESERVED && m_token.m_type != RESERVED_IF_STRICT && !(m_token.m_type & KeywordTokenFlag)) {
+ if (kind == DeconstructToExpressions)
+ return 0;
+ failWithMessage("Expected a property name");
+ }
+ propertyName = *m_token.m_data.ident;
+ break;
+ }
+ next();
+ if (!consume(COLON)) {
+ if (kind == DeconstructToExpressions)
+ return 0;
+ semanticFailIfTrue(tokenType == RESERVED, "Cannot use abbreviated deconstruction syntax for reserved name '", propertyName.impl(), "'");
+ semanticFailIfTrue(tokenType == RESERVED_IF_STRICT, "Cannot use abbreviated deconstruction syntax for reserved name '", propertyName.impl(), "' in strict mode");
+ semanticFailIfTrue(tokenType & KeywordTokenFlag, "Cannot use abbreviated deconstruction syntax for keyword '", propertyName.impl(), "'");
+
+ failWithMessage("Expected a ':' prior to named property deconstruction");
+ }
+ innerPattern = parseDeconstructionPattern(context, kind, depth + 1);
+ }
+ if (kind == DeconstructToExpressions && !innerPattern)
+ return 0;
+ failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");
+ context.appendObjectPatternEntry(objectPattern, location, wasString, propertyName, innerPattern);
+ } while (consume(COMMA));
+ if (kind == DeconstructToExpressions && !match(CLOSEBRACE))
+ return 0;
+ consumeOrFail(CLOSEBRACE, "Expected either a closing '}' or an ',' after a property deconstruction pattern");
+ pattern = objectPattern;
+ break;
+ }
+
+ default: {
+ if (!match(IDENT)) {
+ if (kind == DeconstructToExpressions)
+ return 0;
+ semanticFailureDueToKeyword("variable name");
+ failWithMessage("Expected a parameter pattern or a ')' in parameter list");
+ }
+ pattern = createBindingPattern(context, kind, *m_token.m_data.ident, depth);
+ next();
+ break;
+ }
+ }
+ m_nonLHSCount = nonLHSCount;
+ return pattern;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeConstDeclList Parser<LexerType>::parseConstDeclarationList(TreeBuilder& context)
+{
+ failIfTrue(strictMode(), "Const declarations are not supported in strict mode");
+ TreeConstDeclList constDecls = 0;
+ TreeConstDeclList tail = 0;
+ do {
+ JSTokenLocation location(tokenLocation());
+ next();
+ matchOrFail(IDENT, "Expected an identifier name in const declaration");
+ const Identifier* name = m_token.m_data.ident;
+ next();
+ bool hasInitializer = match(EQUAL);
+ declareVariable(name);
+ context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));
+
+ TreeExpression initializer = 0;
+ if (hasInitializer) {
+ next(TreeBuilder::DontBuildStrings); // consume '='
+ initializer = parseAssignmentExpression(context);
+ failIfFalse(!!initializer, "Unable to parse initializer");
+ }
+ tail = context.appendConstDecl(location, tail, name, initializer);
+ if (!constDecls)
+ constDecls = tail;
+ } while (match(COMMA));
+ return constDecls;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement(TreeBuilder& context)
+{
+ ASSERT(match(FOR));
+ JSTokenLocation location(tokenLocation());
+ int startLine = tokenLine();
+ next();
+ handleProductionOrFail(OPENPAREN, "(", "start", "for-loop header");
+ int nonLHSCount = m_nonLHSCount;
+ int declarations = 0;
+ JSTextPosition declsStart;
+ JSTextPosition declsEnd;
+ TreeExpression decls = 0;
+ TreeDeconstructionPattern pattern = 0;
+ if (match(VAR)) {
+ /*
+ for (var IDENT in expression) statement
+ for (var varDeclarationList; expressionOpt; expressionOpt)
+ */
+ TreeDeconstructionPattern forInTarget = 0;
+ TreeExpression forInInitializer = 0;
+ m_allowsIn = false;
+ JSTextPosition initStart;
+ JSTextPosition initEnd;
+ decls = parseVarDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd);
+ m_allowsIn = true;
+ propagateError();
+
+ // Remainder of a standard for loop is handled identically
+ if (match(SEMICOLON))
+ goto standardForLoop;
+
+ failIfFalse(declarations == 1, "can only declare a single variable in an enumeration");
+ failIfTrueIfStrict(forInInitializer, "Cannot use initialiser syntax in a strict mode enumeration");
+
+ if (forInInitializer)
+ failIfFalse(context.isBindingNode(forInTarget), "Cannot use initialiser syntax when binding to a pattern during enumeration");
+
+ // Handle for-in with var declaration
+ JSTextPosition inLocation = tokenStartPosition();
+ bool isOfEnumeration = false;
+ if (!consume(INTOKEN)) {
+ failIfFalse(match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of, "Expected either 'in' or 'of' in enumeration syntax");
+ isOfEnumeration = true;
+ failIfTrue(forInInitializer, "Cannot use initialiser syntax in a for-of enumeration");
+ next();
+ }
+ TreeExpression expr = parseExpression(context);
+ failIfFalse(expr, "Expected expression to enumerate");
+ JSTextPosition exprEnd = lastTokenEndPosition();
+
+ int endLine = tokenLine();
+
+ handleProductionOrFail(CLOSEPAREN, ")", "end", (isOfEnumeration ? "for-of header" : "for-in header"));
+
+ const Identifier* unused = 0;
+ startLoop();
+ TreeStatement statement = parseStatement(context, unused);
+ endLoop();
+ failIfFalse(statement, "Expected statement as body of for-", isOfEnumeration ? "of" : "in", " statement");
+ if (isOfEnumeration)
+ return context.createForOfLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine);
+ return context.createForInLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine);
+ }
+
+ if (!match(SEMICOLON)) {
+ if (match(OPENBRACE) || match(OPENBRACKET)) {
+ SavePoint savePoint = createSavePoint();
+ declsStart = tokenStartPosition();
+ pattern = tryParseDeconstructionPatternExpression(context);
+ declsEnd = lastTokenEndPosition();
+ if (pattern && (match(INTOKEN) || (match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of)))
+ goto enumerationLoop;
+ pattern = 0;
+ restoreSavePoint(savePoint);
+ }
+ m_allowsIn = false;
+ declsStart = tokenStartPosition();
+ decls = parseExpression(context);
+ declsEnd = lastTokenEndPosition();
+ m_allowsIn = true;
+ failIfFalse(decls, "Cannot parse for loop declarations");
+ }
+
+ if (match(SEMICOLON)) {
+ standardForLoop:
+ // Standard for loop
+ next();
+ TreeExpression condition = 0;
+
+ if (!match(SEMICOLON)) {
+ condition = parseExpression(context);
+ failIfFalse(condition, "Cannot parse for loop condition expression");
+ }
+ consumeOrFail(SEMICOLON, "Expected a ';' after the for loop condition expression");
+
+ TreeExpression increment = 0;
+ if (!match(CLOSEPAREN)) {
+ increment = parseExpression(context);
+ failIfFalse(increment, "Cannot parse for loop iteration expression");
+ }
+ int endLine = tokenLine();
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "for-loop header");
+ const Identifier* unused = 0;
+ startLoop();
+ TreeStatement statement = parseStatement(context, unused);
+ endLoop();
+ failIfFalse(statement, "Expected a statement as the body of a for loop");
+ return context.createForLoop(location, decls, condition, increment, statement, startLine, endLine);
+ }
+
+ // For-in loop
+enumerationLoop:
+ failIfFalse(nonLHSCount == m_nonLHSCount, "Expected a reference on the left hand side of an enumeration statement");
+ bool isOfEnumeration = false;
+ if (!consume(INTOKEN)) {
+ failIfFalse(match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of, "Expected either 'in' or 'of' in enumeration syntax");
+ isOfEnumeration = true;
+ next();
+ }
+ TreeExpression expr = parseExpression(context);
+ failIfFalse(expr, "Cannot parse subject for-", isOfEnumeration ? "of" : "in", " statement");
+ JSTextPosition exprEnd = lastTokenEndPosition();
+ int endLine = tokenLine();
+
+ handleProductionOrFail(CLOSEPAREN, ")", "end", (isOfEnumeration ? "for-of header" : "for-in header"));
+ const Identifier* unused = 0;
+ startLoop();
+ TreeStatement statement = parseStatement(context, unused);
+ endLoop();
+ failIfFalse(statement, "Expected a statement as the body of a for-", isOfEnumeration ? "of" : "in", "loop");
+ if (pattern) {
+ ASSERT(!decls);
+ if (isOfEnumeration)
+ return context.createForOfLoop(location, pattern, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
+ return context.createForInLoop(location, pattern, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
+ }
+ if (isOfEnumeration)
+ return context.createForOfLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
+ return context.createForInLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBreakStatement(TreeBuilder& context)
+{
+ ASSERT(match(BREAK));
+ JSTokenLocation location(tokenLocation());
+ JSTextPosition start = tokenStartPosition();
+ JSTextPosition end = tokenEndPosition();
+ next();
+
+ if (autoSemiColon()) {
+ semanticFailIfFalse(breakIsValid(), "'break' is only valid inside a switch or loop statement");
+ return context.createBreakStatement(location, start, end);
+ }
+ matchOrFail(IDENT, "Expected an identifier as the target for a break statement");
+ const Identifier* ident = m_token.m_data.ident;
+ semanticFailIfFalse(getLabel(ident), "Cannot use the undeclared label '", ident->impl(), "'");
+ end = tokenEndPosition();
+ next();
+ failIfFalse(autoSemiColon(), "Expected a ';' following a targeted break statement");
+ return context.createBreakStatement(location, ident, start, end);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseContinueStatement(TreeBuilder& context)
+{
+ ASSERT(match(CONTINUE));
+ JSTokenLocation location(tokenLocation());
+ JSTextPosition start = tokenStartPosition();
+ JSTextPosition end = tokenEndPosition();
+ next();
+
+ if (autoSemiColon()) {
+ semanticFailIfFalse(continueIsValid(), "'continue' is only valid inside a loop statement");
+ return context.createContinueStatement(location, start, end);
+ }
+ matchOrFail(IDENT, "Expected an identifier as the target for a continue statement");
+ const Identifier* ident = m_token.m_data.ident;
+ ScopeLabelInfo* label = getLabel(ident);
+ semanticFailIfFalse(label, "Cannot use the undeclared label '", ident->impl(), "'");
+ semanticFailIfFalse(label->m_isLoop, "Cannot continue to the label '", ident->impl(), "' as it is not targeting a loop");
+ end = tokenEndPosition();
+ next();
+ failIfFalse(autoSemiColon(), "Expected a ';' following a targeted continue statement");
+ return context.createContinueStatement(location, ident, start, end);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseReturnStatement(TreeBuilder& context)
+{
+ ASSERT(match(RETURN));
+ JSTokenLocation location(tokenLocation());
+ semanticFailIfFalse(currentScope()->isFunction(), "Return statements are only valid inside functions");
+ JSTextPosition start = tokenStartPosition();
+ JSTextPosition end = tokenEndPosition();
+ next();
+ // We do the auto semicolon check before attempting to parse expression
+ // as we need to ensure the a line break after the return correctly terminates
+ // the statement
+ if (match(SEMICOLON))
+ end = tokenEndPosition();
+
+ if (autoSemiColon())
+ return context.createReturnStatement(location, 0, start, end);
+ TreeExpression expr = parseExpression(context);
+ failIfFalse(expr, "Cannot parse the return expression");
+ end = lastTokenEndPosition();
+ if (match(SEMICOLON))
+ end = tokenEndPosition();
+ if (!autoSemiColon())
+ failWithMessage("Expected a ';' following a return statement");
+ return context.createReturnStatement(location, expr, start, end);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseThrowStatement(TreeBuilder& context)
+{
+ ASSERT(match(THROW));
+ JSTokenLocation location(tokenLocation());
+ JSTextPosition start = tokenStartPosition();
+ next();
+ failIfTrue(match(SEMICOLON), "Expected expression after 'throw'");
+ semanticFailIfTrue(autoSemiColon(), "Cannot have a newline after 'throw'");
+
+ TreeExpression expr = parseExpression(context);
+ failIfFalse(expr, "Cannot parse expression for throw statement");
+ JSTextPosition end = lastTokenEndPosition();
+ failIfFalse(autoSemiColon(), "Expected a ';' after a throw statement");
+
+ return context.createThrowStatement(location, expr, start, end);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWithStatement(TreeBuilder& context)
+{
+ ASSERT(match(WITH));
+ JSTokenLocation location(tokenLocation());
+ semanticFailIfTrue(strictMode(), "'with' statements are not valid in strict mode");
+ currentScope()->setNeedsFullActivation();
+ int startLine = tokenLine();
+ next();
+
+ handleProductionOrFail(OPENPAREN, "(", "start", "subject of a 'with' statement");
+ int start = tokenStart();
+ TreeExpression expr = parseExpression(context);
+ failIfFalse(expr, "Cannot parse 'with' subject expression");
+ JSTextPosition end = lastTokenEndPosition();
+ int endLine = tokenLine();
+ handleProductionOrFail(CLOSEPAREN, ")", "start", "subject of a 'with' statement");
+ const Identifier* unused = 0;
+ TreeStatement statement = parseStatement(context, unused);
+ failIfFalse(statement, "A 'with' statement must have a body");
+
+ return context.createWithStatement(location, expr, statement, start, end, startLine, endLine);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStatement(TreeBuilder& context)
+{
+ ASSERT(match(SWITCH));
+ JSTokenLocation location(tokenLocation());
+ int startLine = tokenLine();
+ next();
+ handleProductionOrFail(OPENPAREN, "(", "start", "subject of a 'switch'");
+ TreeExpression expr = parseExpression(context);
+ failIfFalse(expr, "Cannot parse switch subject expression");
+ int endLine = tokenLine();
+
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "subject of a 'switch'");
+ handleProductionOrFail(OPENBRACE, "{", "start", "body of a 'switch'");
+ startSwitch();
+ TreeClauseList firstClauses = parseSwitchClauses(context);
+ propagateError();
+
+ TreeClause defaultClause = parseSwitchDefaultClause(context);
+ propagateError();
+
+ TreeClauseList secondClauses = parseSwitchClauses(context);
+ propagateError();
+ endSwitch();
+ handleProductionOrFail(CLOSEBRACE, "}", "end", "body of a 'switch'");
+
+ return context.createSwitchStatement(location, expr, firstClauses, defaultClause, secondClauses, startLine, endLine);
+
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeClauseList Parser<LexerType>::parseSwitchClauses(TreeBuilder& context)
+{
+ if (!match(CASE))
+ return 0;
+ next();
+ TreeExpression condition = parseExpression(context);
+ failIfFalse(condition, "Cannot parse switch clause");
+ consumeOrFail(COLON, "Expected a ':' after switch clause expression");
+ TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
+ failIfFalse(statements, "Cannot parse the body of a switch clause");
+ TreeClause clause = context.createClause(condition, statements);
+ TreeClauseList clauseList = context.createClauseList(clause);
+ TreeClauseList tail = clauseList;
+
+ while (match(CASE)) {
+ next();
+ TreeExpression condition = parseExpression(context);
+ failIfFalse(condition, "Cannot parse switch case expression");
+ consumeOrFail(COLON, "Expected a ':' after switch clause expression");
+ TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
+ failIfFalse(statements, "Cannot parse the body of a switch clause");
+ clause = context.createClause(condition, statements);
+ tail = context.createClauseList(tail, clause);
+ }
+ return clauseList;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeClause Parser<LexerType>::parseSwitchDefaultClause(TreeBuilder& context)
+{
+ if (!match(DEFAULT))
+ return 0;
+ next();
+ consumeOrFail(COLON, "Expected a ':' after switch default clause");
+ TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode);
+ failIfFalse(statements, "Cannot parse the body of a switch default clause");
+ return context.createClause(0, statements);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement(TreeBuilder& context)
+{
+ ASSERT(match(TRY));
+ JSTokenLocation location(tokenLocation());
+ TreeStatement tryBlock = 0;
+ const Identifier* ident = &m_vm->propertyNames->nullIdentifier;
+ TreeStatement catchBlock = 0;
+ TreeStatement finallyBlock = 0;
+ int firstLine = tokenLine();
+ next();
+ matchOrFail(OPENBRACE, "Expected a block statement as body of a try statement");
+
+ tryBlock = parseBlockStatement(context);
+ failIfFalse(tryBlock, "Cannot parse the body of try block");
+ int lastLine = m_lastTokenEndPosition.line;
+
+ if (match(CATCH)) {
+ currentScope()->setNeedsFullActivation();
+ next();
+
+ handleProductionOrFail(OPENPAREN, "(", "start", "'catch' target");
+ if (!match(IDENT)) {
+ semanticFailureDueToKeyword("catch variable name");
+ failWithMessage("Expected identifier name as catch target");
+ }
+ ident = m_token.m_data.ident;
+ next();
+ AutoPopScopeRef catchScope(this, pushScope());
+ failIfFalseIfStrict(declareVariable(ident), "Cannot declare a catch variable named '", ident->impl(), "' in strict mode");
+ catchScope->preventNewDecls();
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "'catch' target");
+ matchOrFail(OPENBRACE, "Expected exception handler to be a block statement");
+ catchBlock = parseBlockStatement(context);
+ failIfFalse(catchBlock, "Unable to parse 'catch' block");
+ failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo), "Parse error");
+ }
+
+ if (match(FINALLY)) {
+ next();
+ matchOrFail(OPENBRACE, "Expected block statement for finally body");
+ finallyBlock = parseBlockStatement(context);
+ failIfFalse(finallyBlock, "Cannot parse finally body");
+ }
+ failIfFalse(catchBlock || finallyBlock, "Try statements must have at least a catch or finally block");
+ return context.createTryStatement(location, tryBlock, ident, catchBlock, finallyBlock, firstLine, lastLine);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDebuggerStatement(TreeBuilder& context)
+{
+ ASSERT(match(DEBUGGER));
+ JSTokenLocation location(tokenLocation());
+ int startLine = tokenLine();
+ int endLine = startLine;
+ next();
+ if (match(SEMICOLON))
+ startLine = tokenLine();
+ failIfFalse(autoSemiColon(), "Debugger keyword must be followed by a ';'");
+ return context.createDebugger(location, startLine, endLine);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context)
+{
+ ASSERT(match(OPENBRACE));
+ JSTokenLocation location(tokenLocation());
+ int start = tokenLine();
+ next();
+ if (match(CLOSEBRACE)) {
+ next();
+ return context.createBlockStatement(location, 0, start, m_lastTokenEndPosition.line);
+ }
+ TreeSourceElements subtree = parseSourceElements(context, DontCheckForStrictMode);
+ failIfFalse(subtree, "Cannot parse the body of the block statement");
+ matchOrFail(CLOSEBRACE, "Expected a closing '}' at the end of a block statement");
+ next();
+ return context.createBlockStatement(location, subtree, start, m_lastTokenEndPosition.line);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatement(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength)
+{
+ DepthManager statementDepth(&m_statementDepth);
+ m_statementDepth++;
+ directive = 0;
+ int nonTrivialExpressionCount = 0;
+ failIfStackOverflow();
+ switch (m_token.m_type) {
+ case OPENBRACE:
+ return parseBlockStatement(context);
+ case VAR:
+ return parseVarDeclaration(context);
+ case CONSTTOKEN:
+ return parseConstDeclaration(context);
+ case FUNCTION:
+ failIfFalseIfStrict(m_statementDepth == 1, "Strict mode does not allow function declarations in a lexically nested statement");
+ return parseFunctionDeclaration(context);
+ case SEMICOLON: {
+ JSTokenLocation location(tokenLocation());
+ next();
+ return context.createEmptyStatement(location);
+ }
+ case IF:
+ return parseIfStatement(context);
+ case DO:
+ return parseDoWhileStatement(context);
+ case WHILE:
+ return parseWhileStatement(context);
+ case FOR:
+ return parseForStatement(context);
+ case CONTINUE:
+ return parseContinueStatement(context);
+ case BREAK:
+ return parseBreakStatement(context);
+ case RETURN:
+ return parseReturnStatement(context);
+ case WITH:
+ return parseWithStatement(context);
+ case SWITCH:
+ return parseSwitchStatement(context);
+ case THROW:
+ return parseThrowStatement(context);
+ case TRY:
+ return parseTryStatement(context);
+ case DEBUGGER:
+ return parseDebuggerStatement(context);
+ case EOFTOK:
+ case CASE:
+ case CLOSEBRACE:
+ case DEFAULT:
+ // These tokens imply the end of a set of source elements
+ return 0;
+ case IDENT:
+ return parseExpressionOrLabelStatement(context);
+ case STRING:
+ directive = m_token.m_data.ident;
+ if (directiveLiteralLength)
+ *directiveLiteralLength = m_token.m_location.endOffset - m_token.m_location.startOffset;
+ nonTrivialExpressionCount = m_nonTrivialExpressionCount;
+ FALLTHROUGH;
+ default:
+ TreeStatement exprStatement = parseExpressionStatement(context);
+ if (directive && nonTrivialExpressionCount != m_nonTrivialExpressionCount)
+ directive = 0;
+ return exprStatement;
+ }
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeFormalParameterList Parser<LexerType>::parseFormalParameters(TreeBuilder& context)
+{
+ auto parameter = parseDeconstructionPattern(context, DeconstructToParameters);
+ failIfFalse(parameter, "Cannot parse parameter pattern");
+ TreeFormalParameterList list = context.createFormalParameterList(parameter);
+ TreeFormalParameterList tail = list;
+ while (consume(COMMA)) {
+ parameter = parseDeconstructionPattern(context, DeconstructToParameters);
+ failIfFalse(parameter, "Cannot parse parameter pattern");
+ tail = context.createFormalParameterList(tail, parameter);
+ }
+ return list;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(TreeBuilder& context)
+{
+ JSTokenLocation startLocation(tokenLocation());
+ unsigned startColumn = tokenColumn();
+ next();
+
+ if (match(CLOSEBRACE)) {
+ unsigned endColumn = tokenColumn();
+ return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, strictMode());
+ }
+ DepthManager statementDepth(&m_statementDepth);
+ m_statementDepth = 0;
+ typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<VM*>(m_vm), m_lexer.get());
+ failIfFalse(parseSourceElements(bodyBuilder, CheckForStrictMode), "Cannot parse body of this function");
+ unsigned endColumn = tokenColumn();
+ return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, strictMode());
+}
+
+static const char* stringForFunctionMode(FunctionParseMode mode)
+{
+ switch (mode) {
+ case GetterMode:
+ return "getter";
+ case SetterMode:
+ return "setter";
+ case FunctionMode:
+ return "function";
+ }
+ RELEASE_ASSERT_NOT_REACHED();
+ return nullptr;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, FunctionRequirements requirements, FunctionParseMode mode, bool nameIsInContainingScope, const Identifier*& name, TreeFormalParameterList& parameters, TreeFunctionBody& body, unsigned& openBraceOffset, unsigned& closeBraceOffset, int& bodyStartLine, unsigned& bodyStartColumn)
+{
+ AutoPopScopeRef functionScope(this, pushScope());
+ functionScope->setIsFunction();
+ int functionNameStart = m_token.m_location.startOffset;
+ const Identifier* lastFunctionName = m_lastFunctionName;
+ m_lastFunctionName = nullptr;
+ if (match(IDENT)) {
+ name = m_token.m_data.ident;
+ m_lastFunctionName = name;
+ next();
+ if (!nameIsInContainingScope)
+ failIfFalseIfStrict(functionScope->declareVariable(name), "'", name->impl(), "' is not a valid ", stringForFunctionMode(mode), " name in strict mode");
+ } else if (requirements == FunctionNeedsName) {
+ if (match(OPENPAREN) && mode == FunctionMode)
+ semanticFail("Function statements must have a name");
+ semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
+ failDueToUnexpectedToken();
+ return false;
+ }
+ if (!consume(OPENPAREN)) {
+ semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");
+ failWithMessage("Expected an opening '(' before a ", stringForFunctionMode(mode), "'s parameter list");
+ }
+ if (!match(CLOSEPAREN)) {
+ parameters = parseFormalParameters(context);
+ failIfFalse(parameters, "Cannot parse parameters for this ", stringForFunctionMode(mode));
+ }
+ consumeOrFail(CLOSEPAREN, "Expected a ')' or a ',' after a parameter declaration");
+ matchOrFail(OPENBRACE, "Expected an opening '{' at the start of a ", stringForFunctionMode(mode), " body");
+
+ openBraceOffset = m_token.m_data.offset;
+ bodyStartLine = tokenLine();
+ bodyStartColumn = m_token.m_data.offset - m_token.m_data.lineStartOffset;
+ JSTokenLocation startLocation(tokenLocation());
+
+ // If we know about this function already, we can use the cached info and skip the parser to the end of the function.
+ if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBraceOffset) : 0) {
+ // If we're in a strict context, the cached function info must say it was strict too.
+ ASSERT(!strictMode() || cachedInfo->strictMode);
+ JSTokenLocation endLocation;
+
+ endLocation.line = cachedInfo->closeBraceLine;
+ endLocation.startOffset = cachedInfo->closeBraceOffset;
+ endLocation.lineStartOffset = cachedInfo->closeBraceLineStartOffset;
+
+ bool endColumnIsOnStartLine = (endLocation.line == bodyStartLine);
+ ASSERT(endLocation.startOffset >= endLocation.lineStartOffset);
+ unsigned bodyEndColumn = endColumnIsOnStartLine ?
+ endLocation.startOffset - m_token.m_data.lineStartOffset :
+ endLocation.startOffset - endLocation.lineStartOffset;
+
+ body = context.createFunctionBody(startLocation, endLocation, bodyStartColumn, bodyEndColumn, cachedInfo->strictMode);
+
+ functionScope->restoreFromSourceProviderCache(cachedInfo);
+ failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo), "Parser error");
+
+ closeBraceOffset = cachedInfo->closeBraceOffset;
+
+ context.setFunctionNameStart(body, functionNameStart);
+ m_token = cachedInfo->closeBraceToken();
+
+ m_lexer->setOffset(m_token.m_location.endOffset, m_token.m_location.lineStartOffset);
+ m_lexer->setLineNumber(m_token.m_location.line);
+
+ next();
+ return true;
+ }
+ m_lastFunctionName = lastFunctionName;
+ ParserState oldState = saveState();
+ body = parseFunctionBody(context);
+ restoreState(oldState);
+ failIfFalse(body, "Cannot parse the body of this ", stringForFunctionMode(mode));
+ if (functionScope->strictMode() && name) {
+ RELEASE_ASSERT(mode == FunctionMode);
+ semanticFailIfTrue(m_vm->propertyNames->arguments == *name, "'", name->impl(), "' is not a valid function name in strict mode");
+ semanticFailIfTrue(m_vm->propertyNames->eval == *name, "'", name->impl(), "' is not a valid function name in strict mode");
+ }
+ closeBraceOffset = m_token.m_data.offset;
+ unsigned closeBraceLine = m_token.m_data.line;
+ unsigned closeBraceLineStartOffset = m_token.m_data.lineStartOffset;
+
+ // Cache the tokenizer state and the function scope the first time the function is parsed.
+ // Any future reparsing can then skip the function.
+ static const int minimumFunctionLengthToCache = 16;
+ std::unique_ptr<SourceProviderCacheItem> newInfo;
+ int functionLength = closeBraceOffset - openBraceOffset;
+ if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) {
+ SourceProviderCacheItemCreationParameters parameters;
+ parameters.functionNameStart = functionNameStart;
+ parameters.closeBraceLine = closeBraceLine;
+ parameters.closeBraceOffset = closeBraceOffset;
+ parameters.closeBraceLineStartOffset = closeBraceLineStartOffset;
+ functionScope->fillParametersForSourceProviderCache(parameters);
+ newInfo = SourceProviderCacheItem::create(parameters);
+
+ }
+ context.setFunctionNameStart(body, functionNameStart);
+
+ failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo), "Parser error");
+ matchOrFail(CLOSEBRACE, "Expected a closing '}' after a ", stringForFunctionMode(mode), " body");
+
+ if (newInfo)
+ m_functionCache->add(openBraceOffset, WTF::move(newInfo));
+
+ next();
+ return true;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context)
+{
+ ASSERT(match(FUNCTION));
+ JSTokenLocation location(tokenLocation());
+ next();
+ const Identifier* name = 0;
+ TreeFormalParameterList parameters = 0;
+ TreeFunctionBody body = 0;
+ unsigned openBraceOffset = 0;
+ unsigned closeBraceOffset = 0;
+ int bodyStartLine = 0;
+ unsigned bodyStartColumn = 0;
+ failIfFalse((parseFunctionInfo(context, FunctionNeedsName, FunctionMode, true, name, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)), "Cannot parse this function");
+ failIfFalse(name, "Function statements must have a name");
+ failIfFalseIfStrict(declareVariable(name), "Cannot declare a function named '", name->impl(), "' in strict mode");
+ return context.createFuncDeclStatement(location, name, body, parameters, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastTokenEndPosition.line, bodyStartColumn);
+}
+
+struct LabelInfo {
+ LabelInfo(const Identifier* ident, const JSTextPosition& start, const JSTextPosition& end)
+ : m_ident(ident)
+ , m_start(start)
+ , m_end(end)
+ {
+ }
+
+ const Identifier* m_ident;
+ JSTextPosition m_start;
+ JSTextPosition m_end;
+};
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrLabelStatement(TreeBuilder& context)
+{
+
+ /* Expression and Label statements are ambiguous at LL(1), so we have a
+ * special case that looks for a colon as the next character in the input.
+ */
+ Vector<LabelInfo> labels;
+ JSTokenLocation location;
+ do {
+ JSTextPosition start = tokenStartPosition();
+ location = tokenLocation();
+ if (!nextTokenIsColon()) {
+ // If we hit this path we're making a expression statement, which
+ // by definition can't make use of continue/break so we can just
+ // ignore any labels we might have accumulated.
+ TreeExpression expression = parseExpression(context);
+ failIfFalse(expression, "Cannot parse expression statement");
+ if (!autoSemiColon())
+ failDueToUnexpectedToken();
+ return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
+ }
+ const Identifier* ident = m_token.m_data.ident;
+ JSTextPosition end = tokenEndPosition();
+ next();
+ consumeOrFail(COLON, "Labels must be followed by a ':'");
+ if (!m_syntaxAlreadyValidated) {
+ // This is O(N^2) over the current list of consecutive labels, but I
+ // have never seen more than one label in a row in the real world.
+ for (size_t i = 0; i < labels.size(); i++)
+ failIfTrue(ident->impl() == labels[i].m_ident->impl(), "Attempted to redeclare the label '", ident->impl(), "'");
+ failIfTrue(getLabel(ident), "Cannot find scope for the label '", ident->impl(), "'");
+ labels.append(LabelInfo(ident, start, end));
+ }
+ } while (match(IDENT));
+ bool isLoop = false;
+ switch (m_token.m_type) {
+ case FOR:
+ case WHILE:
+ case DO:
+ isLoop = true;
+ break;
+
+ default:
+ break;
+ }
+ const Identifier* unused = 0;
+ if (!m_syntaxAlreadyValidated) {
+ for (size_t i = 0; i < labels.size(); i++)
+ pushLabel(labels[i].m_ident, isLoop);
+ }
+ TreeStatement statement = parseStatement(context, unused);
+ if (!m_syntaxAlreadyValidated) {
+ for (size_t i = 0; i < labels.size(); i++)
+ popLabel();
+ }
+ failIfFalse(statement, "Cannot parse statement");
+ for (size_t i = 0; i < labels.size(); i++) {
+ const LabelInfo& info = labels[labels.size() - i - 1];
+ statement = context.createLabelStatement(location, info.m_ident, statement, info.m_start, info.m_end);
+ }
+ return statement;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionStatement(TreeBuilder& context)
+{
+ JSTextPosition start = tokenStartPosition();
+ JSTokenLocation location(tokenLocation());
+ TreeExpression expression = parseExpression(context);
+ failIfFalse(expression, "Cannot parse expression statement");
+ failIfFalse(autoSemiColon(), "Parse error");
+ return context.createExprStatement(location, expression, start, m_lastTokenEndPosition.line);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(TreeBuilder& context)
+{
+ ASSERT(match(IF));
+ JSTokenLocation ifLocation(tokenLocation());
+ int start = tokenLine();
+ next();
+ handleProductionOrFail(OPENPAREN, "(", "start", "'if' condition");
+
+ TreeExpression condition = parseExpression(context);
+ failIfFalse(condition, "Expected a expression as the condition for an if statement");
+ int end = tokenLine();
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "'if' condition");
+
+ const Identifier* unused = 0;
+ TreeStatement trueBlock = parseStatement(context, unused);
+ failIfFalse(trueBlock, "Expected a statement as the body of an if block");
+
+ if (!match(ELSE))
+ return context.createIfStatement(ifLocation, condition, trueBlock, 0, start, end);
+
+ Vector<TreeExpression> exprStack;
+ Vector<std::pair<int, int>> posStack;
+ Vector<JSTokenLocation> tokenLocationStack;
+ Vector<TreeStatement> statementStack;
+ bool trailingElse = false;
+ do {
+ JSTokenLocation tempLocation = tokenLocation();
+ next();
+ if (!match(IF)) {
+ const Identifier* unused = 0;
+ TreeStatement block = parseStatement(context, unused);
+ failIfFalse(block, "Expected a statement as the body of an else block");
+ statementStack.append(block);
+ trailingElse = true;
+ break;
+ }
+ int innerStart = tokenLine();
+ next();
+
+ handleProductionOrFail(OPENPAREN, "(", "start", "'if' condition");
+
+ TreeExpression innerCondition = parseExpression(context);
+ failIfFalse(innerCondition, "Expected a expression as the condition for an if statement");
+ int innerEnd = tokenLine();
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "'if' condition");
+ const Identifier* unused = 0;
+ TreeStatement innerTrueBlock = parseStatement(context, unused);
+ failIfFalse(innerTrueBlock, "Expected a statement as the body of an if block");
+ tokenLocationStack.append(tempLocation);
+ exprStack.append(innerCondition);
+ posStack.append(std::make_pair(innerStart, innerEnd));
+ statementStack.append(innerTrueBlock);
+ } while (match(ELSE));
+
+ if (!trailingElse) {
+ TreeExpression condition = exprStack.last();
+ exprStack.removeLast();
+ TreeStatement trueBlock = statementStack.last();
+ statementStack.removeLast();
+ std::pair<int, int> pos = posStack.last();
+ posStack.removeLast();
+ JSTokenLocation elseLocation = tokenLocationStack.last();
+ tokenLocationStack.removeLast();
+ statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, 0, pos.first, pos.second));
+ }
+
+ while (!exprStack.isEmpty()) {
+ TreeExpression condition = exprStack.last();
+ exprStack.removeLast();
+ TreeStatement falseBlock = statementStack.last();
+ statementStack.removeLast();
+ TreeStatement trueBlock = statementStack.last();
+ statementStack.removeLast();
+ std::pair<int, int> pos = posStack.last();
+ posStack.removeLast();
+ JSTokenLocation elseLocation = tokenLocationStack.last();
+ tokenLocationStack.removeLast();
+ statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, falseBlock, pos.first, pos.second));
+ }
+
+ return context.createIfStatement(ifLocation, condition, trueBlock, statementStack.last(), start, end);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseExpression(TreeBuilder& context)
+{
+ failIfStackOverflow();
+ JSTokenLocation location(tokenLocation());
+ TreeExpression node = parseAssignmentExpression(context);
+ failIfFalse(node, "Cannot parse expression");
+ if (!match(COMMA))
+ return node;
+ next();
+ m_nonTrivialExpressionCount++;
+ m_nonLHSCount++;
+ TreeExpression right = parseAssignmentExpression(context);
+ failIfFalse(right, "Cannot parse expression in a comma expression");
+ typename TreeBuilder::Comma commaNode = context.createCommaExpr(location, node, right);
+ while (match(COMMA)) {
+ next(TreeBuilder::DontBuildStrings);
+ right = parseAssignmentExpression(context);
+ failIfFalse(right, "Cannot parse expression in a comma expression");
+ context.appendToComma(commaNode, right);
+ }
+ return commaNode;
+}
+
+template <typename LexerType>
+template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpression(TreeBuilder& context)
+{
+ failIfStackOverflow();
+ JSTextPosition start = tokenStartPosition();
+ JSTokenLocation location(tokenLocation());
+ int initialAssignmentCount = m_assignmentCount;
+ int initialNonLHSCount = m_nonLHSCount;
+ if (match(OPENBRACE) || match(OPENBRACKET)) {
+ SavePoint savePoint = createSavePoint();
+ auto pattern = tryParseDeconstructionPatternExpression(context);
+ if (pattern && consume(EQUAL)) {
+ auto rhs = parseAssignmentExpression(context);
+ if (rhs)
+ return context.createDeconstructingAssignment(location, pattern, rhs);
+ }
+ restoreSavePoint(savePoint);
+ }
+ TreeExpression lhs = parseConditionalExpression(context);
+ failIfFalse(lhs, "Cannot parse expression");
+ if (initialNonLHSCount != m_nonLHSCount) {
+ if (m_token.m_type >= EQUAL && m_token.m_type <= OREQUAL)
+ semanticFail("Left hand side of operator '", getToken(), "' must be a reference");
+
+ return lhs;
+ }
+
+ int assignmentStack = 0;
+ Operator op;
+ bool hadAssignment = false;
+ while (true) {
+ switch (m_token.m_type) {
+ case EQUAL: op = OpEqual; break;
+ case PLUSEQUAL: op = OpPlusEq; break;
+ case MINUSEQUAL: op = OpMinusEq; break;
+ case MULTEQUAL: op = OpMultEq; break;
+ case DIVEQUAL: op = OpDivEq; break;
+ case LSHIFTEQUAL: op = OpLShift; break;
+ case RSHIFTEQUAL: op = OpRShift; break;
+ case URSHIFTEQUAL: op = OpURShift; break;
+ case ANDEQUAL: op = OpAndEq; break;
+ case XOREQUAL: op = OpXOrEq; break;
+ case OREQUAL: op = OpOrEq; break;
+ case MODEQUAL: op = OpModEq; break;
+ default:
+ goto end;
+ }
+ m_nonTrivialExpressionCount++;
+ hadAssignment = true;
+ context.assignmentStackAppend(assignmentStack, lhs, start, tokenStartPosition(), m_assignmentCount, op);
+ start = tokenStartPosition();
+ m_assignmentCount++;
+ next(TreeBuilder::DontBuildStrings);
+ if (strictMode() && m_lastIdentifier && context.isResolve(lhs)) {
+ failIfTrueIfStrict(m_vm->propertyNames->eval == *m_lastIdentifier, "Cannot modify 'eval' in strict mode");
+ failIfTrueIfStrict(m_vm->propertyNames->arguments == *m_lastIdentifier, "Cannot modify 'arguments' in strict mode");
+ declareWrite(m_lastIdentifier);
+ m_lastIdentifier = 0;
+ }
+ lhs = parseAssignmentExpression(context);
+ failIfFalse(lhs, "Cannot parse the right hand side of an assignment expression");
+ if (initialNonLHSCount != m_nonLHSCount) {
+ if (m_token.m_type >= EQUAL && m_token.m_type <= OREQUAL)
+ semanticFail("Left hand side of operator '", getToken(), "' must be a reference");
+ break;
+ }
+ }
+end:
+ if (hadAssignment)
+ m_nonLHSCount++;
+
+ if (!TreeBuilder::CreatesAST)
+ return lhs;
+
+ while (assignmentStack)
+ lhs = context.createAssignment(location, assignmentStack, lhs, initialAssignmentCount, m_assignmentCount, lastTokenEndPosition());
+
+ return lhs;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalExpression(TreeBuilder& context)
+{
+ JSTokenLocation location(tokenLocation());
+ TreeExpression cond = parseBinaryExpression(context);
+ failIfFalse(cond, "Cannot parse expression");
+ if (!match(QUESTION))
+ return cond;
+ m_nonTrivialExpressionCount++;
+ m_nonLHSCount++;
+ next(TreeBuilder::DontBuildStrings);
+ TreeExpression lhs = parseAssignmentExpression(context);
+ failIfFalse(lhs, "Cannot parse left hand side of ternary operator");
+ consumeOrFailWithFlags(COLON, TreeBuilder::DontBuildStrings, "Expected ':' in ternary operator");
+
+ TreeExpression rhs = parseAssignmentExpression(context);
+ failIfFalse(rhs, "Cannot parse right hand side of ternary operator");
+ return context.createConditionalExpr(location, cond, lhs, rhs);
+}
+
+ALWAYS_INLINE static bool isUnaryOp(JSTokenType token)
+{
+ return token & UnaryOpTokenFlag;
+}
+
+template <typename LexerType>
+int Parser<LexerType>::isBinaryOperator(JSTokenType token)
+{
+ if (m_allowsIn)
+ return token & (BinaryOpTokenPrecedenceMask << BinaryOpTokenAllowsInPrecedenceAdditionalShift);
+ return token & BinaryOpTokenPrecedenceMask;
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseBinaryExpression(TreeBuilder& context)
+{
+
+ int operandStackDepth = 0;
+ int operatorStackDepth = 0;
+ typename TreeBuilder::BinaryExprContext binaryExprContext(context);
+ JSTokenLocation location(tokenLocation());
+ while (true) {
+ JSTextPosition exprStart = tokenStartPosition();
+ int initialAssignments = m_assignmentCount;
+ TreeExpression current = parseUnaryExpression(context);
+ failIfFalse(current, "Cannot parse expression");
+
+ context.appendBinaryExpressionInfo(operandStackDepth, current, exprStart, lastTokenEndPosition(), lastTokenEndPosition(), initialAssignments != m_assignmentCount);
+ int precedence = isBinaryOperator(m_token.m_type);
+ if (!precedence)
+ break;
+ m_nonTrivialExpressionCount++;
+ m_nonLHSCount++;
+ int operatorToken = m_token.m_type;
+ next(TreeBuilder::DontBuildStrings);
+
+ while (operatorStackDepth && context.operatorStackHasHigherPrecedence(operatorStackDepth, precedence)) {
+ ASSERT(operandStackDepth > 1);
+
+ typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
+ typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
+ context.shrinkOperandStackBy(operandStackDepth, 2);
+ context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
+ context.operatorStackPop(operatorStackDepth);
+ }
+ context.operatorStackAppend(operatorStackDepth, operatorToken, precedence);
+ }
+ while (operatorStackDepth) {
+ ASSERT(operandStackDepth > 1);
+
+ typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
+ typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
+ context.shrinkOperandStackBy(operandStackDepth, 2);
+ context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
+ context.operatorStackPop(operatorStackDepth);
+ }
+ return context.popOperandStack(operandStackDepth);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeBuilder& context, bool complete)
+{
+ bool wasIdent = false;
+ switch (m_token.m_type) {
+ namedProperty:
+ case IDENT:
+ wasIdent = true;
+ FALLTHROUGH;
+ case STRING: {
+ const Identifier* ident = m_token.m_data.ident;
+ if (complete || (wasIdent && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set)))
+ nextExpectIdentifier(LexerFlagsIgnoreReservedWords);
+ else
+ nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
+
+ if (match(COLON)) {
+ next();
+ TreeExpression node = parseAssignmentExpression(context);
+ failIfFalse(node, "Cannot parse expression for property declaration");
+ return context.createProperty(ident, node, PropertyNode::Constant, complete);
+ }
+ failIfFalse(wasIdent, "Expected an identifier as property name");
+ const Identifier* accessorName = 0;
+ TreeFormalParameterList parameters = 0;
+ TreeFunctionBody body = 0;
+ unsigned openBraceOffset = 0;
+ unsigned closeBraceOffset = 0;
+ int bodyStartLine = 0;
+ unsigned bodyStartColumn = 0;
+ PropertyNode::Type type;
+ if (*ident == m_vm->propertyNames->get)
+ type = PropertyNode::Getter;
+ else if (*ident == m_vm->propertyNames->set)
+ type = PropertyNode::Setter;
+ else
+ failWithMessage("Expected a ':' following the property name '", ident->impl(), "'");
+ const Identifier* stringPropertyName = 0;
+ double numericPropertyName = 0;
+ if (m_token.m_type == IDENT || m_token.m_type == STRING)
+ stringPropertyName = m_token.m_data.ident;
+ else if (m_token.m_type == NUMBER)
+ numericPropertyName = m_token.m_data.doubleValue;
+ else
+ failDueToUnexpectedToken();
+ JSTokenLocation location(tokenLocation());
+ next();
+ if (type == PropertyNode::Getter) {
+ failIfFalse(match(OPENPAREN), "Expected a parameter list for getter definition");
+ failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, GetterMode, false, accessorName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)), "Cannot parse getter definition");
+ } else {
+ failIfFalse(match(OPENPAREN), "Expected a parameter list for setter definition");
+ failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SetterMode, false, accessorName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)), "Cannot parse setter definition");
+ }
+ if (stringPropertyName)
+ return context.createGetterOrSetterProperty(location, type, complete, stringPropertyName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastTokenEndPosition.line, bodyStartColumn);
+ return context.createGetterOrSetterProperty(const_cast<VM*>(m_vm), location, type, complete, numericPropertyName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastTokenEndPosition.line, bodyStartColumn);
+ }
+ case NUMBER: {
+ double propertyName = m_token.m_data.doubleValue;
+ next();
+ consumeOrFail(COLON, "Expected ':' after property name");
+ TreeExpression node = parseAssignmentExpression(context);
+ failIfFalse(node, "Cannot parse expression for property declaration");
+ return context.createProperty(const_cast<VM*>(m_vm), propertyName, node, PropertyNode::Constant, complete);
+ }
+ case OPENBRACKET: {
+ next();
+ auto propertyName = parseExpression(context);
+ failIfFalse(propertyName, "Cannot parse computed property name");
+
+ handleProductionOrFail(CLOSEBRACKET, "]", "end", "computed property name");
+ consumeOrFail(COLON, "Expected ':' after property name");
+ TreeExpression node = parseAssignmentExpression(context);
+ failIfFalse(node, "Cannot parse expression for property declaration");
+ return context.createProperty(const_cast<VM*>(m_vm), propertyName, node, PropertyNode::Constant, complete);
+ }
+ default:
+ failIfFalse(m_token.m_type & KeywordTokenFlag, "Expected a property name");
+ goto namedProperty;
+ }
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseObjectLiteral(TreeBuilder& context)
+{
+ auto savePoint = createSavePoint();
+ consumeOrFailWithFlags(OPENBRACE, TreeBuilder::DontBuildStrings, "Expected opening '{' at the start of an object literal");
+ JSTokenLocation location(tokenLocation());
+
+ int oldNonLHSCount = m_nonLHSCount;
+
+ if (match(CLOSEBRACE)) {
+ next();
+ return context.createObjectLiteral(location);
+ }
+
+ TreeProperty property = parseProperty(context, false);
+ failIfFalse(property, "Cannot parse object literal property");
+ if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
+ restoreSavePoint(savePoint);
+ return parseStrictObjectLiteral(context);
+ }
+ TreePropertyList propertyList = context.createPropertyList(location, property);
+ TreePropertyList tail = propertyList;
+ while (match(COMMA)) {
+ next(TreeBuilder::DontBuildStrings);
+ // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
+ if (match(CLOSEBRACE))
+ break;
+ JSTokenLocation propertyLocation(tokenLocation());
+ property = parseProperty(context, false);
+ failIfFalse(property, "Cannot parse object literal property");
+ if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
+ restoreSavePoint(savePoint);
+ return parseStrictObjectLiteral(context);
+ }
+ tail = context.createPropertyList(propertyLocation, property, tail);
+ }
+
+ location = tokenLocation();
+ handleProductionOrFail(CLOSEBRACE, "}", "end", "object literal");
+
+ m_nonLHSCount = oldNonLHSCount;
+
+ return context.createObjectLiteral(location, propertyList);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseStrictObjectLiteral(TreeBuilder& context)
+{
+ consumeOrFail(OPENBRACE, "Expected opening '{' at the start of an object literal");
+
+ int oldNonLHSCount = m_nonLHSCount;
+
+ JSTokenLocation location(tokenLocation());
+ if (match(CLOSEBRACE)) {
+ next();
+ return context.createObjectLiteral(location);
+ }
+
+ TreeProperty property = parseProperty(context, true);
+ failIfFalse(property, "Cannot parse object literal property");
+
+ typedef HashMap<RefPtr<StringImpl>, unsigned, IdentifierRepHash> ObjectValidationMap;
+ ObjectValidationMap objectValidator;
+ // Add the first property
+ if (!m_syntaxAlreadyValidated && context.getName(property))
+ objectValidator.add(context.getName(property)->impl(), context.getType(property));
+
+ TreePropertyList propertyList = context.createPropertyList(location, property);
+ TreePropertyList tail = propertyList;
+ while (match(COMMA)) {
+ next();
+ // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
+ if (match(CLOSEBRACE))
+ break;
+ JSTokenLocation propertyLocation(tokenLocation());
+ property = parseProperty(context, true);
+ failIfFalse(property, "Cannot parse object literal property");
+ if (!m_syntaxAlreadyValidated && context.getName(property)) {
+ ObjectValidationMap::AddResult propertyEntry = objectValidator.add(context.getName(property)->impl(), context.getType(property));
+ if (!propertyEntry.isNewEntry) {
+ semanticFailIfTrue(propertyEntry.iterator->value == PropertyNode::Constant, "Attempted to redefine property '", propertyEntry.iterator->key.get(), "'");
+ semanticFailIfTrue(context.getType(property) == PropertyNode::Constant, "Attempted to redefine property '", propertyEntry.iterator->key.get(), "'");
+ semanticFailIfTrue(context.getType(property) & propertyEntry.iterator->value, "Attempted to redefine property '", propertyEntry.iterator->key.get(), "'");
+ propertyEntry.iterator->value |= context.getType(property);
+ }
+ }
+ tail = context.createPropertyList(propertyLocation, property, tail);
+ }
+
+ location = tokenLocation();
+ handleProductionOrFail(CLOSEBRACE, "}", "end", "object literal");
+
+ m_nonLHSCount = oldNonLHSCount;
+
+ return context.createObjectLiteral(location, propertyList);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrayLiteral(TreeBuilder& context)
+{
+ consumeOrFailWithFlags(OPENBRACKET, TreeBuilder::DontBuildStrings, "Expected an opening '[' at the beginning of an array literal");
+
+ int oldNonLHSCount = m_nonLHSCount;
+
+ int elisions = 0;
+ while (match(COMMA)) {
+ next(TreeBuilder::DontBuildStrings);
+ elisions++;
+ }
+ if (match(CLOSEBRACKET)) {
+ JSTokenLocation location(tokenLocation());
+ next(TreeBuilder::DontBuildStrings);
+ return context.createArray(location, elisions);
+ }
+
+ TreeExpression elem;
+ if (UNLIKELY(match(DOTDOTDOT))) {
+ auto spreadLocation = m_token.m_location;
+ auto start = m_token.m_startPosition;
+ auto divot = m_token.m_endPosition;
+ next();
+ auto spreadExpr = parseAssignmentExpression(context);
+ failIfFalse(spreadExpr, "Cannot parse subject of a spread operation");
+ elem = context.createSpreadExpression(spreadLocation, spreadExpr, start, divot, m_lastTokenEndPosition);
+ } else
+ elem = parseAssignmentExpression(context);
+ failIfFalse(elem, "Cannot parse array literal element");
+ typename TreeBuilder::ElementList elementList = context.createElementList(elisions, elem);
+ typename TreeBuilder::ElementList tail = elementList;
+ elisions = 0;
+ while (match(COMMA)) {
+ next(TreeBuilder::DontBuildStrings);
+ elisions = 0;
+
+ while (match(COMMA)) {
+ next();
+ elisions++;
+ }
+
+ if (match(CLOSEBRACKET)) {
+ JSTokenLocation location(tokenLocation());
+ next(TreeBuilder::DontBuildStrings);
+ return context.createArray(location, elisions, elementList);
+ }
+ if (UNLIKELY(match(DOTDOTDOT))) {
+ auto spreadLocation = m_token.m_location;
+ auto start = m_token.m_startPosition;
+ auto divot = m_token.m_endPosition;
+ next();
+ TreeExpression elem = parseAssignmentExpression(context);
+ failIfFalse(elem, "Cannot parse subject of a spread operation");
+ auto spread = context.createSpreadExpression(spreadLocation, elem, start, divot, m_lastTokenEndPosition);
+ tail = context.createElementList(tail, elisions, spread);
+ continue;
+ }
+ TreeExpression elem = parseAssignmentExpression(context);
+ failIfFalse(elem, "Cannot parse array literal element");
+ tail = context.createElementList(tail, elisions, elem);
+ }
+
+ JSTokenLocation location(tokenLocation());
+ if (!consume(CLOSEBRACKET)) {
+ failIfFalse(match(DOTDOTDOT), "Expected either a closing ']' or a ',' following an array element");
+ semanticFail("The '...' operator should come before a target expression");
+ }
+
+ m_nonLHSCount = oldNonLHSCount;
+
+ return context.createArray(location, elementList);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpression(TreeBuilder& context)
+{
+ failIfStackOverflow();
+ switch (m_token.m_type) {
+ case OPENBRACE:
+ if (strictMode())
+ return parseStrictObjectLiteral(context);
+ return parseObjectLiteral(context);
+ case OPENBRACKET:
+ return parseArrayLiteral(context);
+ case OPENPAREN: {
+ next();
+ int oldNonLHSCount = m_nonLHSCount;
+ TreeExpression result = parseExpression(context);
+ m_nonLHSCount = oldNonLHSCount;
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "compound expression");
+ return result;
+ }
+ case THISTOKEN: {
+ JSTokenLocation location(tokenLocation());
+ next();
+ return context.thisExpr(location);
+ }
+ case IDENT: {
+ JSTextPosition start = tokenStartPosition();
+ const Identifier* ident = m_token.m_data.ident;
+ JSTokenLocation location(tokenLocation());
+ next();
+ currentScope()->useVariable(ident, m_vm->propertyNames->eval == *ident);
+ m_lastIdentifier = ident;
+ return context.createResolve(location, ident, start);
+ }
+ case STRING: {
+ const Identifier* ident = m_token.m_data.ident;
+ JSTokenLocation location(tokenLocation());
+ next();
+ return context.createString(location, ident);
+ }
+ case NUMBER: {
+ double d = m_token.m_data.doubleValue;
+ JSTokenLocation location(tokenLocation());
+ next();
+ return context.createNumberExpr(location, d);
+ }
+ case NULLTOKEN: {
+ JSTokenLocation location(tokenLocation());
+ next();
+ return context.createNull(location);
+ }
+ case TRUETOKEN: {
+ JSTokenLocation location(tokenLocation());
+ next();
+ return context.createBoolean(location, true);
+ }
+ case FALSETOKEN: {
+ JSTokenLocation location(tokenLocation());
+ next();
+ return context.createBoolean(location, false);
+ }
+ case DIVEQUAL:
+ case DIVIDE: {
+ /* regexp */
+ const Identifier* pattern;
+ const Identifier* flags;
+ if (match(DIVEQUAL))
+ failIfFalse(m_lexer->scanRegExp(pattern, flags, '='), "Invalid regular expression");
+ else
+ failIfFalse(m_lexer->scanRegExp(pattern, flags), "Invalid regular expression");
+
+ JSTextPosition start = tokenStartPosition();
+ JSTokenLocation location(tokenLocation());
+ next();
+ TreeExpression re = context.createRegExp(location, *pattern, *flags, start);
+ if (!re) {
+ const char* yarrErrorMsg = Yarr::checkSyntax(pattern->string());
+ regexFail(yarrErrorMsg);
+ }
+ return re;
+ }
+ default:
+ failDueToUnexpectedToken();
+ }
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeArguments Parser<LexerType>::parseArguments(TreeBuilder& context, SpreadMode mode)
+{
+ consumeOrFailWithFlags(OPENPAREN, TreeBuilder::DontBuildStrings, "Expected opening '(' at start of argument list");
+ JSTokenLocation location(tokenLocation());
+ if (match(CLOSEPAREN)) {
+ next(TreeBuilder::DontBuildStrings);
+ return context.createArguments();
+ }
+ if (match(DOTDOTDOT) && mode == AllowSpread) {
+ JSTokenLocation spreadLocation(tokenLocation());
+ auto start = m_token.m_startPosition;
+ auto divot = m_token.m_endPosition;
+ next();
+ auto spreadExpr = parseAssignmentExpression(context);
+ auto end = m_lastTokenEndPosition;
+ if (!spreadExpr)
+ failWithMessage("Cannot parse spread expression");
+ if (!consume(CLOSEPAREN)) {
+ if (match(COMMA))
+ semanticFail("Spread operator may only be applied to the last argument passed to a function");
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "argument list");
+ }
+ auto spread = context.createSpreadExpression(spreadLocation, spreadExpr, start, divot, end);
+ TreeArgumentsList argList = context.createArgumentsList(location, spread);
+ return context.createArguments(argList);
+ }
+ TreeExpression firstArg = parseAssignmentExpression(context);
+ failIfFalse(firstArg, "Cannot parse function argument");
+
+ TreeArgumentsList argList = context.createArgumentsList(location, firstArg);
+ TreeArgumentsList tail = argList;
+ while (match(COMMA)) {
+ JSTokenLocation argumentLocation(tokenLocation());
+ next(TreeBuilder::DontBuildStrings);
+ TreeExpression arg = parseAssignmentExpression(context);
+ failIfFalse(arg, "Cannot parse function argument");
+ tail = context.createArgumentsList(argumentLocation, tail, arg);
+ }
+ semanticFailIfTrue(match(DOTDOTDOT), "The '...' operator should come before the target expression");
+ handleProductionOrFail(CLOSEPAREN, ")", "end", "argument list");
+ return context.createArguments(argList);
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpression(TreeBuilder& context)
+{
+ TreeExpression base = 0;
+ JSTextPosition expressionStart = tokenStartPosition();
+ int newCount = 0;
+ JSTokenLocation location;
+ while (match(NEW)) {
+ next();
+ newCount++;
+ }
+
+ if (match(FUNCTION)) {
+ const Identifier* name = &m_vm->propertyNames->nullIdentifier;
+ TreeFormalParameterList parameters = 0;
+ TreeFunctionBody body = 0;
+ unsigned openBraceOffset = 0;
+ unsigned closeBraceOffset = 0;
+ int bodyStartLine = 0;
+ unsigned bodyStartColumn = 0;
+ location = tokenLocation();
+ next();
+ failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, FunctionMode, false, name, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)), "Cannot parse function expression");
+ base = context.createFunctionExpr(location, name, body, parameters, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastTokenEndPosition.line, bodyStartColumn);
+ } else
+ base = parsePrimaryExpression(context);
+
+ failIfFalse(base, "Cannot parse base expression");
+ while (true) {
+ location = tokenLocation();
+ switch (m_token.m_type) {
+ case OPENBRACKET: {
+ m_nonTrivialExpressionCount++;
+ JSTextPosition expressionEnd = lastTokenEndPosition();
+ next();
+ int nonLHSCount = m_nonLHSCount;
+ int initialAssignments = m_assignmentCount;
+ TreeExpression property = parseExpression(context);
+ failIfFalse(property, "Cannot parse subscript expression");
+ base = context.createBracketAccess(location, base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEndPosition());
+ handleProductionOrFail(CLOSEBRACKET, "]", "end", "subscript expression");
+ m_nonLHSCount = nonLHSCount;
+ break;
+ }
+ case OPENPAREN: {
+ m_nonTrivialExpressionCount++;
+ int nonLHSCount = m_nonLHSCount;
+ if (newCount) {
+ newCount--;
+ JSTextPosition expressionEnd = lastTokenEndPosition();
+ TreeArguments arguments = parseArguments(context, AllowSpread);
+ failIfFalse(arguments, "Cannot parse call arguments");
+ base = context.createNewExpr(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition());
+ } else {
+ JSTextPosition expressionEnd = lastTokenEndPosition();
+ TreeArguments arguments = parseArguments(context, AllowSpread);
+ failIfFalse(arguments, "Cannot parse call arguments");
+ base = context.makeFunctionCallNode(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition());
+ }
+ m_nonLHSCount = nonLHSCount;
+ break;
+ }
+ case DOT: {
+ m_nonTrivialExpressionCount++;
+ JSTextPosition expressionEnd = lastTokenEndPosition();
+ nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
+ matchOrFail(IDENT, "Expected a property name after '.'");
+ base = context.createDotAccess(location, base, m_token.m_data.ident, expressionStart, expressionEnd, tokenEndPosition());
+ next();
+ break;
+ }
+ default:
+ goto endMemberExpression;
+ }
+ }
+endMemberExpression:
+ while (newCount--)
+ base = context.createNewExpr(location, base, expressionStart, lastTokenEndPosition());
+ return base;
+}
+
+static const char* operatorString(bool prefix, unsigned tok)
+{
+ switch (tok) {
+ case MINUSMINUS:
+ case AUTOMINUSMINUS:
+ return prefix ? "prefix-decrement" : "decrement";
+
+ case PLUSPLUS:
+ case AUTOPLUSPLUS:
+ return prefix ? "prefix-increment" : "increment";
+
+ case EXCLAMATION:
+ return "logical-not";
+
+ case TILDE:
+ return "bitwise-not";
+
+ case TYPEOF:
+ return "typeof";
+
+ case VOIDTOKEN:
+ return "void";
+
+ case DELETETOKEN:
+ return "delete";
+ }
+ RELEASE_ASSERT_NOT_REACHED();
+ return "error";
+}
+
+template <typename LexerType>
+template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpression(TreeBuilder& context)
+{
+ typename TreeBuilder::UnaryExprContext unaryExprContext(context);
+ AllowInOverride allowInOverride(this);
+ int tokenStackDepth = 0;
+ bool modifiesExpr = false;
+ bool requiresLExpr = false;
+ unsigned lastOperator = 0;
+ while (isUnaryOp(m_token.m_type)) {
+ if (strictMode()) {
+ switch (m_token.m_type) {
+ case PLUSPLUS:
+ case MINUSMINUS:
+ case AUTOPLUSPLUS:
+ case AUTOMINUSMINUS:
+ semanticFailIfTrue(requiresLExpr, "The ", operatorString(true, lastOperator), " operator requires a reference expression");
+ modifiesExpr = true;
+ requiresLExpr = true;
+ break;
+ case DELETETOKEN:
+ semanticFailIfTrue(requiresLExpr, "The ", operatorString(true, lastOperator), " operator requires a reference expression");
+ requiresLExpr = true;
+ break;
+ default:
+ semanticFailIfTrue(requiresLExpr, "The ", operatorString(true, lastOperator), " operator requires a reference expression");
+ break;
+ }
+ }
+ lastOperator = m_token.m_type;
+ m_nonLHSCount++;
+ context.appendUnaryToken(tokenStackDepth, m_token.m_type, tokenStartPosition());
+ next();
+ m_nonTrivialExpressionCount++;
+ }
+ JSTextPosition subExprStart = tokenStartPosition();
+ ASSERT(subExprStart.offset >= subExprStart.lineStartOffset);
+ JSTokenLocation location(tokenLocation());
+ TreeExpression expr = parseMemberExpression(context);
+ if (!expr) {
+ if (lastOperator)
+ failWithMessage("Cannot parse subexpression of ", operatorString(true, lastOperator), "operator");
+ failWithMessage("Cannot parse member expression");
+ }
+ bool isEvalOrArguments = false;
+ if (strictMode() && !m_syntaxAlreadyValidated) {
+ if (context.isResolve(expr))
+ isEvalOrArguments = *m_lastIdentifier == m_vm->propertyNames->eval || *m_lastIdentifier == m_vm->propertyNames->arguments;
+ }
+ failIfTrueIfStrict(isEvalOrArguments && modifiesExpr, "Cannot modify '", m_lastIdentifier->impl(), "' in strict mode");
+ switch (m_token.m_type) {
+ case PLUSPLUS:
+ m_nonTrivialExpressionCount++;
+ m_nonLHSCount++;
+ expr = context.makePostfixNode(location, expr, OpPlusPlus, subExprStart, lastTokenEndPosition(), tokenEndPosition());
+ m_assignmentCount++;
+ failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", m_lastIdentifier->impl(), "' in strict mode");
+ semanticFailIfTrue(requiresLExpr, "The ", operatorString(false, lastOperator), " operator requires a reference expression");
+ lastOperator = PLUSPLUS;
+ next();
+ break;
+ case MINUSMINUS:
+ m_nonTrivialExpressionCount++;
+ m_nonLHSCount++;
+ expr = context.makePostfixNode(location, expr, OpMinusMinus, subExprStart, lastTokenEndPosition(), tokenEndPosition());
+ m_assignmentCount++;
+ failIfTrueIfStrict(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
+ semanticFailIfTrue(requiresLExpr, "The ", operatorString(false, lastOperator), " operator requires a reference expression");
+ lastOperator = PLUSPLUS;
+ next();
+ break;
+ default:
+ break;
+ }
+
+ JSTextPosition end = lastTokenEndPosition();
+
+ if (!TreeBuilder::CreatesAST && (m_syntaxAlreadyValidated || !strictMode()))
+ return expr;
+
+ location = tokenLocation();
+ location.line = m_lexer->lastLineNumber();
+ while (tokenStackDepth) {
+ switch (context.unaryTokenStackLastType(tokenStackDepth)) {
+ case EXCLAMATION:
+ expr = context.createLogicalNot(location, expr);
+ break;
+ case TILDE:
+ expr = context.makeBitwiseNotNode(location, expr);
+ break;
+ case MINUS:
+ expr = context.makeNegateNode(location, expr);
+ break;
+ case PLUS:
+ expr = context.createUnaryPlus(location, expr);
+ break;
+ case PLUSPLUS:
+ case AUTOPLUSPLUS:
+ expr = context.makePrefixNode(location, expr, OpPlusPlus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
+ m_assignmentCount++;
+ break;
+ case MINUSMINUS:
+ case AUTOMINUSMINUS:
+ expr = context.makePrefixNode(location, expr, OpMinusMinus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
+ m_assignmentCount++;
+ break;
+ case TYPEOF:
+ expr = context.makeTypeOfNode(location, expr);
+ break;
+ case VOIDTOKEN:
+ expr = context.createVoid(location, expr);
+ break;
+ case DELETETOKEN:
+ failIfTrueIfStrict(context.isResolve(expr), "Cannot delete unqualified property '", m_lastIdentifier->impl(), "' in strict mode");
+ expr = context.makeDeleteNode(location, expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end);
+ break;
+ default:
+ // If we get here something has gone horribly horribly wrong
+ CRASH();
+ }
+ subExprStart = context.unaryTokenStackLastStart(tokenStackDepth);
+ context.unaryTokenStackRemoveLast(tokenStackDepth);
+ }
+ return expr;
+}
+
+
+template <typename LexerType> void Parser<LexerType>::printUnexpectedTokenText(WTF::PrintStream& out)
+{
+ switch (m_token.m_type) {
+ case EOFTOK:
+ out.print("Unexpected end of script");
+ return;
+ case UNTERMINATED_IDENTIFIER_ESCAPE_ERRORTOK:
+ case UNTERMINATED_IDENTIFIER_UNICODE_ESCAPE_ERRORTOK:
+ out.print("Incomplete unicode escape in identifier: '", getToken(), "'");
+ return;
+ case UNTERMINATED_MULTILINE_COMMENT_ERRORTOK:
+ out.print("Unterminated multiline comment");
+ return;
+ case UNTERMINATED_NUMERIC_LITERAL_ERRORTOK:
+ out.print("Unterminated numeric literal '", getToken(), "'");
+ return;
+ case UNTERMINATED_STRING_LITERAL_ERRORTOK:
+ out.print("Unterminated string literal '", getToken(), "'");
+ return;
+ case INVALID_IDENTIFIER_ESCAPE_ERRORTOK:
+ out.print("Invalid escape in identifier: '", getToken(), "'");
+ return;
+ case INVALID_IDENTIFIER_UNICODE_ESCAPE_ERRORTOK:
+ out.print("Invalid unicode escape in identifier: '", getToken(), "'");
+ return;
+ case INVALID_NUMERIC_LITERAL_ERRORTOK:
+ out.print("Invalid numeric literal: '", getToken(), "'");
+ return;
+ case INVALID_OCTAL_NUMBER_ERRORTOK:
+ out.print("Invalid use of octal: '", getToken(), "'");
+ return;
+ case INVALID_STRING_LITERAL_ERRORTOK:
+ out.print("Invalid string literal: '", getToken(), "'");
+ return;
+ case ERRORTOK:
+ out.print("Unrecognized token '", getToken(), "'");
+ return;
+ case STRING:
+ out.print("Unexpected string literal ", getToken());
+ return;
+ case NUMBER:
+ out.print("Unexpected number '", getToken(), "'");
+ return;
+
+ case RESERVED_IF_STRICT:
+ out.print("Unexpected use of reserved word '", getToken(), "' in strict mode");
+ return;
+
+ case RESERVED:
+ out.print("Unexpected use of reserved word '", getToken(), "'");
+ return;
+
+ case INVALID_PRIVATE_NAME_ERRORTOK:
+ out.print("Invalid private name '", getToken(), "'");
+ return;
+
+ case IDENT:
+ out.print("Unexpected identifier '", getToken(), "'");
+ return;
+
+ default:
+ break;
+ }
+
+ if (m_token.m_type & KeywordTokenFlag) {
+ out.print("Unexpected keyword '", getToken(), "'");
+ return;
+ }
+
+ out.print("Unexpected token '", getToken(), "'");
+}
+
+// Instantiate the two flavors of Parser we need instead of putting most of this file in Parser.h
+template class Parser<Lexer<LChar>>;
+template class Parser<Lexer<UChar>>;
+
} // namespace JSC
projects / apple / javascriptcore.git / blobdiff