diff options
author | Lorry Tar Creator <lorry-tar-importer@lorry> | 2016-04-10 09:28:39 +0000 |
---|---|---|
committer | Lorry Tar Creator <lorry-tar-importer@lorry> | 2016-04-10 09:28:39 +0000 |
commit | 32761a6cee1d0dee366b885b7b9c777e67885688 (patch) | |
tree | d6bec92bebfb216f4126356e55518842c2f476a1 /Source/JavaScriptCore/parser/Parser.cpp | |
parent | a4e969f4965059196ca948db781e52f7cfebf19e (diff) | |
download | WebKitGtk-tarball-32761a6cee1d0dee366b885b7b9c777e67885688.tar.gz |
webkitgtk-2.4.11webkitgtk-2.4.11
Diffstat (limited to 'Source/JavaScriptCore/parser/Parser.cpp')
-rw-r--r-- | Source/JavaScriptCore/parser/Parser.cpp | 2867 |
1 files changed, 552 insertions, 2315 deletions
diff --git a/Source/JavaScriptCore/parser/Parser.cpp b/Source/JavaScriptCore/parser/Parser.cpp index c66b74282..297666e72 100644 --- a/Source/JavaScriptCore/parser/Parser.cpp +++ b/Source/JavaScriptCore/parser/Parser.cpp @@ -28,12 +28,12 @@ #include "Debugger.h" #include "JSCJSValueInlines.h" #include "Lexer.h" -#include "JSCInlines.h" -#include "SetForScope.h" +#include "NodeInfo.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> @@ -49,7 +49,7 @@ #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 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) @@ -57,10 +57,9 @@ #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 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 restoreSavePointAndFail(savePoint, message) do { restoreSavePointWithError(savePoint, message); return 0; } while (0) #define failDueToUnexpectedToken() do {\ logError(true);\ return 0;\ @@ -192,37 +191,43 @@ void Parser<LexerType>::logError(bool shouldPrintToken, const A& value1, const B } template <typename LexerType> -Parser<LexerType>::Parser( - VM* vm, const SourceCode& source, JSParserBuiltinMode builtinMode, - JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding, - ConstructorKind defaultConstructorKind, ThisTDZMode thisTDZMode) +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(builtinMode == JSParserBuiltinMode::Builtin) - , m_superBinding(superBinding) - , m_defaultConstructorKind(defaultConstructorKind) - , m_thisTDZMode(thisTDZMode) { - m_lexer = std::make_unique<LexerType>(vm, builtinMode); - m_lexer->setCode(source, &m_parserArena); + m_lexer = adoptPtr(new LexerType(vm)); + 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()); - m_expressionErrorClassifier = nullptr; - ScopeRef scope = pushScope(); - scope->setSourceParseMode(parseMode); - - if (strictMode == JSParserStrictMode::Strict) + if (parserMode == JSParseFunctionCode) + scope->setIsFunction(); + if (strictness == JSParseStrict) scope->setStrictMode(); - + if (parameters) { + for (unsigned i = 0; i < parameters->size(); i++) { + auto parameter = parameters->at(i); + if (!parameter->isBindingNode()) + continue; + scope->declareParameter(&static_cast<BindingNode*>(parameter)->boundProperty()); + } + } + if (!name.isNull()) + scope->declareCallee(&name); next(); } @@ -232,64 +237,16 @@ Parser<LexerType>::~Parser() } template <typename LexerType> -String Parser<LexerType>::parseInner(const Identifier& calleeName, SourceParseMode parseMode) +String Parser<LexerType>::parseInner() { String parseError = String(); - - ASTBuilder context(const_cast<VM*>(m_vm), m_parserArena, const_cast<SourceCode*>(m_source)); - ScopeRef scope = currentScope(); - scope->setIsLexicalScope(); - SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Body); - - bool isArrowFunctionBodyExpression = false; - if (m_lexer->isReparsingFunction()) { - ParserFunctionInfo<ASTBuilder> functionInfo; - if (parseMode == SourceParseMode::GeneratorBodyMode) - functionInfo.parameters = createGeneratorParameters(context); - else - parseFunctionParameters(context, parseMode, functionInfo); - m_parameters = functionInfo.parameters; - - if (parseMode == SourceParseMode::ArrowFunctionMode && !hasError()) { - // The only way we could have an error wile reparsing is if we run out of stack space. - RELEASE_ASSERT(match(ARROWFUNCTION)); - next(); - isArrowFunctionBodyExpression = !match(OPENBRACE); - } - } - - if (!calleeName.isNull()) - scope->declareCallee(&calleeName); - - if (m_lexer->isReparsingFunction()) + + ASTBuilder context(const_cast<VM*>(m_vm), const_cast<SourceCode*>(m_source)); + if (m_lexer->isReparsing()) m_statementDepth--; - - SourceElements* sourceElements = nullptr; - // The only way we can error this early is if we reparse a function and we run out of stack space. - if (!hasError()) { - if (isArrowFunctionBodyExpression) - sourceElements = parseArrowFunctionSingleExpressionBodySourceElements(context); - else if (isModuleParseMode(parseMode)) - sourceElements = parseModuleSourceElements(context, parseMode); - else { - if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode) - sourceElements = parseGeneratorFunctionSourceElements(context, CheckForStrictMode); - else - sourceElements = parseSourceElements(context, CheckForStrictMode); - } - } - - bool validEnding; - if (isArrowFunctionBodyExpression) { - ASSERT(m_lexer->isReparsingFunction()); - // When we reparse and stack overflow, we're not guaranteed a valid ending. If we don't run out of stack space, - // then of course this will always be valid because we already parsed for syntax errors. But we must - // be cautious in case we run out of stack space. - validEnding = isEndOfArrowFunction(); - } else - validEnding = consume(EOFTOK); - - if (!sourceElements || !validEnding) { + ScopeRef scope = currentScope(); + SourceElements* sourceElements = parseSourceElements(context, CheckForStrictMode); + if (!sourceElements || !consume(EOFTOK)) { if (hasError()) parseError = m_errorMessage; else @@ -298,20 +255,7 @@ String Parser<LexerType>::parseInner(const Identifier& calleeName, SourceParseMo IdentifierSet capturedVariables; bool modifiedParameter = false; - bool modifiedArguments = false; - scope->getCapturedVars(capturedVariables, modifiedParameter, modifiedArguments); - - VariableEnvironment& varDeclarations = scope->declaredVariables(); - for (auto& entry : capturedVariables) - varDeclarations.markVariableAsCaptured(entry); - - IdentifierSet usedVariables; - scope->getUsedVariables(usedVariables); - if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode) { - if (usedVariables.contains(m_vm->propertyNames->arguments.impl())) - context.propagateArgumentsUse(); - } - + scope->getCapturedVariables(capturedVariables, modifiedParameter); CodeFeatures features = context.features(); if (scope->strictMode()) features |= StrictModeFeature; @@ -319,83 +263,26 @@ String Parser<LexerType>::parseInner(const Identifier& calleeName, SourceParseMo features |= ShadowsArgumentsFeature; if (modifiedParameter) features |= ModifiedParameterFeature; - if (modifiedArguments) - features |= ModifiedArgumentsFeature; -#ifndef NDEBUG - if (m_parsingBuiltin && isProgramParseMode(parseMode)) { - VariableEnvironment& lexicalVariables = scope->lexicalVariables(); - const IdentifierSet& closedVariableCandidates = scope->closedVariableCandidates(); - const BuiltinNames& builtinNames = m_vm->propertyNames->builtinNames(); - for (const RefPtr<UniquedStringImpl>& candidate : closedVariableCandidates) { - if (!lexicalVariables.contains(candidate) && !varDeclarations.contains(candidate) && !builtinNames.isPrivateName(*candidate.get())) { - dataLog("Bad global capture in builtin: '", candidate, "'\n"); - dataLog(m_source->view()); - CRASH(); - } - } - } -#endif // NDEBUG - didFinishParsing(sourceElements, context.funcDeclarations(), varDeclarations, features, context.numConstants()); + didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), features, + context.numConstants(), capturedVariables); return parseError; } template <typename LexerType> -void Parser<LexerType>::didFinishParsing(SourceElements* sourceElements, DeclarationStacks::FunctionStack& funcStack, - VariableEnvironment& varDeclarations, CodeFeatures features, int numConstants) +void Parser<LexerType>::didFinishParsing(SourceElements* sourceElements, ParserArenaData<DeclarationStacks::VarStack>* varStack, + ParserArenaData<DeclarationStacks::FunctionStack>* funcStack, CodeFeatures features, int numConstants, IdentifierSet& capturedVars) { m_sourceElements = sourceElements; - m_funcDeclarations.swap(funcStack); - m_varDeclarations.swap(varDeclarations); + m_varDeclarations = varStack; + m_funcDeclarations = funcStack; + m_capturedVariables.swap(capturedVars); m_features = features; m_numConstants = numConstants; } template <typename LexerType> -bool Parser<LexerType>::isArrowFunctionParameters() -{ - bool isArrowFunction = false; - - if (match(EOFTOK)) - return false; - - bool isOpenParen = match(OPENPAREN); - bool isIdent = match(IDENT); - - if (!isOpenParen && !isIdent) - return false; - - SavePoint saveArrowFunctionPoint = createSavePoint(); - - if (isIdent) { - next(); - isArrowFunction = match(ARROWFUNCTION); - } else { - RELEASE_ASSERT(isOpenParen); - next(); - if (match(CLOSEPAREN)) { - next(); - isArrowFunction = match(ARROWFUNCTION); - } else { - SyntaxChecker syntaxChecker(const_cast<VM*>(m_vm), m_lexer.get()); - // We make fake scope, otherwise parseFormalParameters will add variable to current scope that lead to errors - AutoPopScopeRef fakeScope(this, pushScope()); - fakeScope->setSourceParseMode(SourceParseMode::ArrowFunctionMode); - - unsigned parametersCount = 0; - isArrowFunction = parseFormalParameters(syntaxChecker, syntaxChecker.createFormalParameterList(), parametersCount) && consume(CLOSEPAREN) && match(ARROWFUNCTION); - - popScope(fakeScope, syntaxChecker.NeedsFreeVariableInfo); - } - } - - restoreSavePoint(saveArrowFunctionPoint); - - return isArrowFunction; -} - -template <typename LexerType> bool Parser<LexerType>::allowAutomaticSemicolon() { return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator(); @@ -411,8 +298,7 @@ template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceEl unsigned directiveLiteralLength = 0; auto savePoint = createSavePoint(); bool hasSetStrict = false; - - while (TreeStatement statement = parseStatementListItem(context, directive, &directiveLiteralLength)) { + 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. @@ -420,10 +306,10 @@ template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceEl setStrictMode(); hasSetStrict = true; if (!isValidStrictMode()) { - if (m_parserState.lastFunctionName) { - if (m_vm->propertyNames->arguments == *m_parserState.lastFunctionName) + 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_parserState.lastFunctionName) + if (m_vm->propertyNames->eval == *m_lastFunctionName) semanticFail("Cannot name a function 'eval' in strict mode"); } if (hasDeclaredVariable(m_vm->propertyNames->arguments)) @@ -447,160 +333,35 @@ template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceEl } template <typename LexerType> -template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseModuleSourceElements(TreeBuilder& context, SourceParseMode parseMode) +template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVarDeclaration(TreeBuilder& context) { - TreeSourceElements sourceElements = context.createSourceElements(); - SyntaxChecker syntaxChecker(const_cast<VM*>(m_vm), m_lexer.get()); - - while (true) { - TreeStatement statement = 0; - if (match(IMPORT)) - statement = parseImportDeclaration(context); - else if (match(EXPORT)) - statement = parseExportDeclaration(context); - else { - const Identifier* directive = 0; - unsigned directiveLiteralLength = 0; - if (parseMode == SourceParseMode::ModuleAnalyzeMode) { - if (!parseStatementListItem(syntaxChecker, directive, &directiveLiteralLength)) - break; - continue; - } - statement = parseStatementListItem(context, directive, &directiveLiteralLength); - } - - if (!statement) - break; - context.appendStatement(sourceElements, statement); - } - + 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(); - - for (const auto& uid : currentScope()->moduleScopeData().exportedBindings()) { - if (currentScope()->hasDeclaredVariable(uid)) { - currentScope()->declaredVariables().markVariableAsExported(uid); - continue; - } - - if (currentScope()->hasLexicallyDeclaredVariable(uid)) { - currentScope()->lexicalVariables().markVariableAsExported(uid); - continue; - } - - semanticFail("Exported binding '", uid.get(), "' needs to refer to a top-level declared variable"); - } - - return sourceElements; -} - -template <typename LexerType> -template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseGeneratorFunctionSourceElements(TreeBuilder& context, SourceElementsMode mode) -{ - auto sourceElements = context.createSourceElements(); - - unsigned functionKeywordStart = tokenStart(); - JSTokenLocation startLocation(tokenLocation()); - JSTextPosition start = tokenStartPosition(); - unsigned startColumn = tokenColumn(); - int functionNameStart = m_token.m_location.startOffset; - int parametersStart = m_token.m_location.startOffset; - - ParserFunctionInfo<TreeBuilder> info; - info.name = &m_vm->propertyNames->nullIdentifier; - info.parameters = createGeneratorParameters(context); - info.startOffset = parametersStart; - info.startLine = tokenLine(); - info.parameterCount = 4; // generator, state, value, resume mode - - { - AutoPopScopeRef generatorBodyScope(this, pushScope()); - generatorBodyScope->setSourceParseMode(SourceParseMode::GeneratorBodyMode); - SyntaxChecker generatorFunctionContext(const_cast<VM*>(m_vm), m_lexer.get()); - failIfFalse(parseSourceElements(generatorFunctionContext, mode), "Cannot parse the body of a generator"); - popScope(generatorBodyScope, TreeBuilder::NeedsFreeVariableInfo); - } - info.body = context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, tokenColumn(), functionKeywordStart, functionNameStart, parametersStart, strictMode(), ConstructorKind::None, m_superBinding, info.parameterCount, SourceParseMode::GeneratorBodyMode, false); - - info.endLine = tokenLine(); - info.endOffset = m_token.m_data.offset; - info.bodyStartColumn = startColumn; - - auto functionExpr = context.createFunctionExpr(startLocation, info); - auto statement = context.createExprStatement(startLocation, functionExpr, start, m_lastTokenEndPosition.line); - context.appendStatement(sourceElements, statement); - - return sourceElements; -} - -template <typename LexerType> -template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatementListItem(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength) -{ - // The grammar is documented here: - // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-statements - DepthManager statementDepth(&m_statementDepth); - m_statementDepth++; - TreeStatement result = 0; - bool shouldSetEndOffset = true; - switch (m_token.m_type) { - case CONSTTOKEN: - result = parseVariableDeclaration(context, DeclarationType::ConstDeclaration); - break; - case LET: { - bool shouldParseVariableDeclaration = true; - if (!strictMode()) { - SavePoint savePoint = createSavePoint(); - next(); - // Intentionally use `match(IDENT) || match(LET) || match(YIELD)` and don't use `matchSpecIdentifier()`. - // We would like to fall into parseVariableDeclaration path even if "yield" is not treated as an Identifier. - // For example, under a generator context, matchSpecIdentifier() for "yield" returns `false`. - // But we would like to enter parseVariableDeclaration and raise an error under the context of parseVariableDeclaration - // to raise consistent errors between "var", "const" and "let". - if (!(match(IDENT) || match(LET) || match(YIELD)) && !match(OPENBRACE) && !match(OPENBRACKET)) - shouldParseVariableDeclaration = false; - restoreSavePoint(savePoint); - } - if (shouldParseVariableDeclaration) - result = parseVariableDeclaration(context, DeclarationType::LetDeclaration); - else - result = parseExpressionOrLabelStatement(context); // Treat this as an IDENT. This is how ::parseStatement() handles IDENT. - - break; - } -#if ENABLE(ES6_CLASS_SYNTAX) - case CLASSTOKEN: - result = parseClassDeclaration(context); - break; -#endif - default: - m_statementDepth--; // parseStatement() increments the depth. - result = parseStatement(context, directive, directiveLiteralLength); - shouldSetEndOffset = false; - break; - } - - if (result && shouldSetEndOffset) - context.setEndOffset(result, m_lastTokenEndPosition.offset); - - return result; + failIfFalse(autoSemiColon(), "Expected ';' after var declaration"); + + return context.createVarStatement(location, varDecls, start, end); } template <typename LexerType> -template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVariableDeclaration(TreeBuilder& context, DeclarationType declarationType, ExportType exportType) +template <class TreeBuilder> TreeStatement Parser<LexerType>::parseConstDeclaration(TreeBuilder& context) { - ASSERT(match(VAR) || match(LET) || match(CONSTTOKEN)); + ASSERT(match(CONSTTOKEN)); JSTokenLocation location(tokenLocation()); int start = tokenLine(); int end = 0; - int scratch; - TreeDestructuringPattern scratch1 = 0; - TreeExpression scratch2 = 0; - JSTextPosition scratch3; - bool scratchBool; - TreeExpression variableDecls = parseVariableDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3, VarDeclarationContext, declarationType, exportType, scratchBool); + TreeConstDeclList constDecls = parseConstDeclarationList(context); propagateError(); - failIfFalse(autoSemiColon(), "Expected ';' after variable declaration"); + failIfFalse(autoSemiColon(), "Expected ';' after const declaration"); - return context.createDeclarationStatement(location, variableDecls, start, end); + return context.createConstStatement(location, constDecls, start, end); } template <typename LexerType> @@ -651,435 +412,261 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWhileStatemen } template <typename LexerType> -template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVariableDeclarationList(TreeBuilder& context, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext declarationListContext, DeclarationType declarationType, ExportType exportType, bool& forLoopConstDoesNotHaveInitializer) +template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarationList(TreeBuilder& context, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd) { - ASSERT(declarationType == DeclarationType::LetDeclaration || declarationType == DeclarationType::VarDeclaration || declarationType == DeclarationType::ConstDeclaration); - TreeExpression head = 0; - TreeExpression tail = 0; + TreeExpression varDecls = 0; const Identifier* lastIdent; - JSToken lastIdentToken; - AssignmentContext assignmentContext = assignmentContextFromDeclarationType(declarationType); do { lastIdent = 0; - lastPattern = TreeDestructuringPattern(0); + lastPattern = 0; JSTokenLocation location(tokenLocation()); next(); TreeExpression node = 0; declarations++; bool hasInitializer = false; - if (matchSpecIdentifier()) { - failIfTrue(match(LET) && (declarationType == DeclarationType::LetDeclaration || declarationType == DeclarationType::ConstDeclaration), - "Can't use 'let' as an identifier name for a LexicalDeclaration"); + if (match(IDENT)) { JSTextPosition varStart = tokenStartPosition(); - JSTokenLocation varStartLocation(tokenLocation()); identStart = varStart; const Identifier* name = m_token.m_data.ident; lastIdent = name; - lastIdentToken = m_token; next(); hasInitializer = match(EQUAL); - DeclarationResultMask declarationResult = declareVariable(name, declarationType); - if (declarationResult != DeclarationResult::Valid) { - failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare a variable named ", name->impl(), " in strict mode"); - if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) { - if (declarationType == DeclarationType::LetDeclaration) - internalFailWithMessage(false, "Cannot declare a let variable twice: '", name->impl(), "'"); - if (declarationType == DeclarationType::ConstDeclaration) - internalFailWithMessage(false, "Cannot declare a const variable twice: '", name->impl(), "'"); - ASSERT(declarationType == DeclarationType::VarDeclaration); - internalFailWithMessage(false, "Cannot declare a var variable that shadows a let/const/class variable: '", name->impl(), "'"); - } - } - if (exportType == ExportType::Exported) { - semanticFailIfFalse(exportName(*name), "Cannot export a duplicate name '", name->impl(), "'"); - currentScope()->moduleScopeData().exportBinding(*name); - } - + 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 '=' - propagateError(); 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(), assignmentContext); - } else { - if (declarationListContext == ForLoopContext && declarationType == DeclarationType::ConstDeclaration) - forLoopConstDoesNotHaveInitializer = true; - failIfTrue(declarationListContext != ForLoopContext && declarationType == DeclarationType::ConstDeclaration, "const declared variable '", name->impl(), "'", " must have an initializer"); - if (declarationType == DeclarationType::VarDeclaration) - node = context.createEmptyVarExpression(varStartLocation, *name); - else - node = context.createEmptyLetExpression(varStartLocation, *name); + node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEndPosition()); } } else { lastIdent = 0; - auto pattern = parseDestructuringPattern(context, destructuringKindFromDeclarationType(declarationType), exportType, nullptr, nullptr, assignmentContext); - failIfFalse(pattern, "Cannot parse this destructuring pattern"); + auto pattern = parseDeconstructionPattern(context, DeconstructToVariables); + failIfFalse(pattern, "Cannot parse this deconstruction pattern"); hasInitializer = match(EQUAL); - failIfTrue(declarationListContext == VarDeclarationContext && !hasInitializer, "Expected an initializer in destructuring variable declaration"); lastPattern = pattern; if (hasInitializer) { next(TreeBuilder::DontBuildStrings); // consume '=' - TreeExpression rhs = parseAssignmentExpression(context); - node = context.createDestructuringAssignment(location, pattern, rhs); - lastInitializer = rhs; + TreeExpression rhs = parseExpression(context); + node = context.createDeconstructingAssignment(location, pattern, rhs); } } - - if (node) { - if (!head) - head = node; - else if (!tail) { - head = context.createCommaExpr(location, head); - tail = context.appendToCommaExpr(location, head, head, node); - } else - tail = context.appendToCommaExpr(location, head, tail, node); + + if (hasInitializer) { + if (!varDecls) + varDecls = node; + else + varDecls = context.combineCommaNodes(location, varDecls, node); } } while (match(COMMA)); if (lastIdent) - lastPattern = context.createBindingLocation(lastIdentToken.m_location, *lastIdent, lastIdentToken.m_startPosition, lastIdentToken.m_endPosition, assignmentContext); - - return head; -} - -template <typename LexerType> -bool Parser<LexerType>::declareRestOrNormalParameter(const Identifier& name, const Identifier** duplicateIdentifier) -{ - DeclarationResultMask declarationResult = declareParameter(&name); - if ((declarationResult & DeclarationResult::InvalidStrictMode) && strictMode()) { - semanticFailIfTrue(isEvalOrArguments(&name), "Cannot destructure to a parameter name '", name.impl(), "' in strict mode"); - if (m_parserState.lastFunctionName && name == *m_parserState.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"); - } - if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) { - // It's not always an error to define a duplicate parameter. - // It's only an error when there are default parameter values or destructuring parameters. - // We note this value now so we can check it later. - if (duplicateIdentifier) - *duplicateIdentifier = &name; - } - - return true; + lastPattern = createBindingPattern(context, DeconstructToVariables, *lastIdent, 0); + return varDecls; } template <typename LexerType> -template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier& name, JSToken token, AssignmentContext bindingContext, const Identifier** duplicateIdentifier) +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() || name.impl()->isSymbol()); - - switch (kind) { - case DestructuringKind::DestructureToVariables: { - DeclarationResultMask declarationResult = declareVariable(&name); - failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare a variable named '", name.impl(), "' in strict mode"); - if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) - internalFailWithMessage(false, "Cannot declare a var variable that shadows a let/const/class variable: '", name.impl(), "'"); - break; - } - - case DestructuringKind::DestructureToLet: - case DestructuringKind::DestructureToConst: - case DestructuringKind::DestructureToCatchParameters: { - DeclarationResultMask declarationResult = declareVariable(&name, kind == DestructuringKind::DestructureToConst ? DeclarationType::ConstDeclaration : DeclarationType::LetDeclaration); - if (declarationResult != DeclarationResult::Valid) { - failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot destructure to a variable named '", name.impl(), "' in strict mode"); - failIfTrue(declarationResult & DeclarationResult::InvalidDuplicateDeclaration, "Cannot declare a lexical variable twice: '", name.impl(), "'"); + ASSERT(name.impl()->isIdentifier()); + 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, kind == DeconstructToParameters ? 0 : 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"); + } } - break; - } - - case DestructuringKind::DestructureToParameters: { - declareRestOrNormalParameter(name, duplicateIdentifier); - propagateError(); - break; - } - - case DestructuringKind::DestructureToExpressions: { - break; - } - } - - if (exportType == ExportType::Exported) { - semanticFailIfFalse(exportName(name), "Cannot export a duplicate name '", name.impl(), "'"); - currentScope()->moduleScopeData().exportBinding(name); } - return context.createBindingLocation(token.m_location, name, token.m_startPosition, token.m_endPosition, bindingContext); + return context.createBindingLocation(m_token.m_location, name, m_token.m_startPosition, m_token.m_endPosition); } template <typename LexerType> -template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern Parser<LexerType>::createAssignmentElement(TreeBuilder& context, TreeExpression& assignmentTarget, const JSTextPosition& startPosition, const JSTextPosition& endPosition) -{ - return context.createAssignmentElement(assignmentTarget, startPosition, endPosition); -} - -template <typename LexerType> -template <class TreeBuilder> TreeSourceElements Parser<LexerType>::parseArrowFunctionSingleExpressionBodySourceElements(TreeBuilder& context) -{ - ASSERT(!match(OPENBRACE)); - - JSTokenLocation location(tokenLocation()); - JSTextPosition start = tokenStartPosition(); - - failIfStackOverflow(); - TreeExpression expr = parseAssignmentExpression(context); - failIfFalse(expr, "Cannot parse the arrow function expression"); - - context.setEndOffset(expr, m_lastTokenEndPosition.offset); - - failIfFalse(isEndOfArrowFunction(), "Expected a ';', ']', '}', ')', ',', line terminator or EOF following a arrow function statement"); - - JSTextPosition end = tokenEndPosition(); - - if (!m_lexer->prevTerminator()) - setEndOfStatement(); - - TreeSourceElements sourceElements = context.createSourceElements(); - TreeStatement body = context.createReturnStatement(location, expr, start, end); - context.setEndOffset(body, m_lastTokenEndPosition.offset); - context.appendStatement(sourceElements, body); - - return sourceElements; -} - -template <typename LexerType> -template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::tryParseDestructuringPatternExpression(TreeBuilder& context, AssignmentContext bindingContext) -{ - return parseDestructuringPattern(context, DestructuringKind::DestructureToExpressions, ExportType::NotExported, nullptr, nullptr, bindingContext); -} - -template <typename LexerType> -template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseBindingOrAssignmentElement(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth) -{ - if (kind == DestructuringKind::DestructureToExpressions) - return parseAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth); - return parseDestructuringPattern(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth); -} - -template <typename LexerType> -template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseAssignmentElement(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth) -{ - TreeDestructuringPattern assignmentTarget = 0; - - if (match(OPENBRACE) || match(OPENBRACKET)) { - SavePoint savePoint = createSavePoint(); - assignmentTarget = parseDestructuringPattern(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth); - if (assignmentTarget && !match(DOT) && !match(OPENBRACKET) && !match(OPENPAREN) && !match(TEMPLATE)) - return assignmentTarget; - restoreSavePoint(savePoint); - } - - JSTextPosition startPosition = tokenStartPosition(); - auto element = parseMemberExpression(context); - - semanticFailIfFalse(element && context.isAssignmentLocation(element), "Invalid destructuring assignment target"); - - if (strictMode() && m_parserState.lastIdentifier && context.isResolve(element)) { - bool isEvalOrArguments = m_vm->propertyNames->eval == *m_parserState.lastIdentifier || m_vm->propertyNames->arguments == *m_parserState.lastIdentifier; - failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", m_parserState.lastIdentifier->impl(), "' in strict mode"); - } - - return createAssignmentElement(context, element, startPosition, lastTokenEndPosition()); -} - -static const char* destructuringKindToVariableKindName(DestructuringKind kind) +template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::tryParseDeconstructionPatternExpression(TreeBuilder& context) { - switch (kind) { - case DestructuringKind::DestructureToLet: - case DestructuringKind::DestructureToConst: - return "lexical variable name"; - case DestructuringKind::DestructureToVariables: - return "variable name"; - case DestructuringKind::DestructureToParameters: - return "parameter name"; - case DestructuringKind::DestructureToCatchParameters: - return "catch parameter name"; - case DestructuringKind::DestructureToExpressions: - return "expression name"; - } - RELEASE_ASSERT_NOT_REACHED(); - return "invalid"; + return parseDeconstructionPattern(context, DeconstructToExpressions); } template <typename LexerType> -template <class TreeBuilder> TreeDestructuringPattern Parser<LexerType>::parseDestructuringPattern(TreeBuilder& context, DestructuringKind kind, ExportType exportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth) +template <class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::parseDeconstructionPattern(TreeBuilder& context, DeconstructionKind kind, int depth) { failIfStackOverflow(); - int nonLHSCount = m_parserState.nonLHSCount; - TreeDestructuringPattern pattern; + int nonLHSCount = m_nonLHSCount; + TreeDeconstructionPattern pattern; switch (m_token.m_type) { case OPENBRACKET: { - JSTextPosition divotStart = tokenStartPosition(); auto arrayPattern = context.createArrayPattern(m_token.m_location); next(); - - if (hasDestructuringPattern) - *hasDestructuringPattern = true; - - bool restElementWasFound = false; - + 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(); - - if (match(CLOSEBRACKET)) - break; - - if (UNLIKELY(match(DOTDOTDOT))) { - JSTokenLocation location = m_token.m_location; - next(); - auto innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1); - if (kind == DestructuringKind::DestructureToExpressions && !innerPattern) - return 0; - failIfFalse(innerPattern, "Cannot parse this destructuring pattern"); - - failIfTrue(kind != DestructuringKind::DestructureToExpressions && !context.isBindingNode(innerPattern), "Expected identifier for a rest element destructuring pattern"); - - context.appendArrayPatternRestEntry(arrayPattern, location, innerPattern); - restElementWasFound = true; - break; - } - JSTokenLocation location = m_token.m_location; - auto innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1); - if (kind == DestructuringKind::DestructureToExpressions && !innerPattern) + auto innerPattern = parseDeconstructionPattern(context, kind, depth + 1); + if (kind == DeconstructToExpressions && !innerPattern) return 0; - failIfFalse(innerPattern, "Cannot parse this destructuring pattern"); - TreeExpression defaultValue = parseDefaultValueForDestructuringPattern(context); - context.appendArrayPatternEntry(arrayPattern, location, innerPattern, defaultValue); + failIfFalse(innerPattern, "Cannot parse this deconstruction pattern"); + context.appendArrayPatternEntry(arrayPattern, location, innerPattern); } while (consume(COMMA)); + + if (kind == DeconstructToExpressions && !match(CLOSEBRACKET)) + return 0; - consumeOrFail(CLOSEBRACKET, restElementWasFound ? "Expected a closing ']' following a rest element destructuring pattern" : "Expected either a closing ']' or a ',' following an element destructuring pattern"); - context.finishArrayPattern(arrayPattern, divotStart, divotStart, lastTokenEndPosition()); + consumeOrFail(CLOSEBRACKET, "Expected either a closing ']' or a ',' following an element deconstruction pattern"); pattern = arrayPattern; break; } case OPENBRACE: { - auto objectPattern = context.createObjectPattern(m_token.m_location); next(); + + if (kind == DeconstructToExpressions && match(CLOSEBRACE)) + return 0; - if (hasDestructuringPattern) - *hasDestructuringPattern = true; - + 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 { - bool wasString = false; - - if (match(CLOSEBRACE)) - break; - - const Identifier* propertyName = nullptr; - TreeExpression propertyExpression = 0; - TreeDestructuringPattern innerPattern = 0; + Identifier propertyName; + TreeDeconstructionPattern innerPattern = 0; JSTokenLocation location = m_token.m_location; - if (matchSpecIdentifier()) { - failIfTrue(match(LET) && (kind == DestructuringKind::DestructureToLet || kind == DestructuringKind::DestructureToConst), "Can't use 'let' as an identifier name for a LexicalDeclaration"); - propertyName = m_token.m_data.ident; - JSToken identifierToken = m_token; + if (match(IDENT)) { + propertyName = *m_token.m_data.ident; next(); if (consume(COLON)) - innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1); - else { - if (kind == DestructuringKind::DestructureToExpressions) { - bool isEvalOrArguments = m_vm->propertyNames->eval == *propertyName || m_vm->propertyNames->arguments == *propertyName; - if (isEvalOrArguments && strictMode()) - reclassifyExpressionError(ErrorIndicatesPattern, ErrorIndicatesNothing); - failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", propertyName->impl(), "' in strict mode"); - } - innerPattern = createBindingPattern(context, kind, exportType, *propertyName, identifierToken, bindingContext, duplicateIdentifier); - } + 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 DOUBLE: - case INTEGER: - propertyName = &m_parserArena.identifierArena().makeNumericIdentifier(const_cast<VM*>(m_vm), m_token.m_data.doubleValue); + case NUMBER: + propertyName = Identifier::from(m_vm, m_token.m_data.doubleValue); break; case STRING: - propertyName = m_token.m_data.ident; + propertyName = *m_token.m_data.ident; wasString = true; break; - case OPENBRACKET: - next(); - propertyExpression = parseAssignmentExpression(context); - failIfFalse(propertyExpression, "Cannot parse computed property name"); - matchOrFail(CLOSEBRACKET, "Expected ']' to end end a computed property name"); - break; default: if (m_token.m_type != RESERVED && m_token.m_type != RESERVED_IF_STRICT && !(m_token.m_type & KeywordTokenFlag)) { - if (kind == DestructuringKind::DestructureToExpressions) + if (kind == DeconstructToExpressions) return 0; failWithMessage("Expected a property name"); } - propertyName = m_token.m_data.ident; + propertyName = *m_token.m_data.ident; break; } next(); if (!consume(COLON)) { - if (kind == DestructuringKind::DestructureToExpressions) + if (kind == DeconstructToExpressions) return 0; - semanticFailIfTrue(tokenType == RESERVED, "Cannot use abbreviated destructuring syntax for reserved name '", propertyName->impl(), "'"); - semanticFailIfTrue(tokenType == RESERVED_IF_STRICT, "Cannot use abbreviated destructuring syntax for reserved name '", propertyName->impl(), "' in strict mode"); - semanticFailIfTrue(tokenType & KeywordTokenFlag, "Cannot use abbreviated destructuring syntax for keyword '", propertyName->impl(), "'"); + 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 a named destructuring property"); + failWithMessage("Expected a ':' prior to named property deconstruction"); } - innerPattern = parseBindingOrAssignmentElement(context, kind, exportType, duplicateIdentifier, hasDestructuringPattern, bindingContext, depth + 1); + innerPattern = parseDeconstructionPattern(context, kind, depth + 1); } - if (kind == DestructuringKind::DestructureToExpressions && !innerPattern) + if (kind == DeconstructToExpressions && !innerPattern) return 0; - failIfFalse(innerPattern, "Cannot parse this destructuring pattern"); - TreeExpression defaultValue = parseDefaultValueForDestructuringPattern(context); - if (propertyExpression) - context.appendObjectPatternEntry(objectPattern, location, propertyExpression, innerPattern, defaultValue); - else { - ASSERT(propertyName); - context.appendObjectPatternEntry(objectPattern, location, wasString, *propertyName, innerPattern, defaultValue); - } + failIfFalse(innerPattern, "Cannot parse this deconstruction pattern"); + context.appendObjectPatternEntry(objectPattern, location, wasString, propertyName, innerPattern); } while (consume(COMMA)); - - if (kind == DestructuringKind::DestructureToExpressions && !match(CLOSEBRACE)) + if (kind == DeconstructToExpressions && !match(CLOSEBRACE)) return 0; - consumeOrFail(CLOSEBRACE, "Expected either a closing '}' or an ',' after a property destructuring pattern"); + consumeOrFail(CLOSEBRACE, "Expected either a closing '}' or an ',' after a property deconstruction pattern"); pattern = objectPattern; break; } default: { - if (!matchSpecIdentifier()) { - if (kind == DestructuringKind::DestructureToExpressions) + if (!match(IDENT)) { + if (kind == DeconstructToExpressions) return 0; - semanticFailureDueToKeyword(destructuringKindToVariableKindName(kind)); + semanticFailureDueToKeyword("variable name"); failWithMessage("Expected a parameter pattern or a ')' in parameter list"); } - failIfTrue(match(LET) && (kind == DestructuringKind::DestructureToLet || kind == DestructuringKind::DestructureToConst), "Can't use 'let' as an identifier name for a LexicalDeclaration"); - pattern = createBindingPattern(context, kind, exportType, *m_token.m_data.ident, m_token, bindingContext, duplicateIdentifier); + pattern = createBindingPattern(context, kind, *m_token.m_data.ident, depth); next(); break; } } - m_parserState.nonLHSCount = nonLHSCount; + m_nonLHSCount = nonLHSCount; return pattern; } template <typename LexerType> -template <class TreeBuilder> TreeExpression Parser<LexerType>::parseDefaultValueForDestructuringPattern(TreeBuilder& context) +template <class TreeBuilder> TreeConstDeclList Parser<LexerType>::parseConstDeclarationList(TreeBuilder& context) { - if (!match(EQUAL)) - return 0; - - next(TreeBuilder::DontBuildStrings); // consume '=' - return parseAssignmentExpression(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> @@ -1090,61 +677,23 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement( int startLine = tokenLine(); next(); handleProductionOrFail(OPENPAREN, "(", "start", "for-loop header"); - int nonLHSCount = m_parserState.nonLHSCount; + int nonLHSCount = m_nonLHSCount; int declarations = 0; JSTextPosition declsStart; JSTextPosition declsEnd; TreeExpression decls = 0; - TreeDestructuringPattern pattern = 0; - bool isVarDeclaraton = match(VAR); - bool isLetDeclaration = match(LET); - bool isConstDeclaration = match(CONSTTOKEN); - bool forLoopConstDoesNotHaveInitializer = false; - - VariableEnvironment dummySet; - VariableEnvironment* lexicalVariables = nullptr; - AutoCleanupLexicalScope lexicalScope; - - auto gatherLexicalVariablesIfNecessary = [&] { - if (isLetDeclaration || isConstDeclaration) { - ScopeRef scope = lexicalScope.scope(); - lexicalVariables = &scope->finalizeLexicalEnvironment(); - } else - lexicalVariables = &dummySet; - }; - - auto popLexicalScopeIfNecessary = [&] { - if (isLetDeclaration || isConstDeclaration) - popScope(lexicalScope, TreeBuilder::NeedsFreeVariableInfo); - }; - - if (isVarDeclaraton || isLetDeclaration || isConstDeclaration) { + TreeDeconstructionPattern pattern = 0; + if (match(VAR)) { /* - for (var/let/const IDENT in/of expression) statement - for (var/let/const varDeclarationList; expressionOpt; expressionOpt) + for (var IDENT in expression) statement + for (var varDeclarationList; expressionOpt; expressionOpt) */ - if (isLetDeclaration || isConstDeclaration) { - ScopeRef newScope = pushScope(); - newScope->setIsLexicalScope(); - newScope->preventVarDeclarations(); - lexicalScope.setIsValid(newScope, this); - } - - TreeDestructuringPattern forInTarget = 0; + TreeDeconstructionPattern forInTarget = 0; TreeExpression forInInitializer = 0; m_allowsIn = false; JSTextPosition initStart; JSTextPosition initEnd; - DeclarationType declarationType; - if (isVarDeclaraton) - declarationType = DeclarationType::VarDeclaration; - else if (isLetDeclaration) - declarationType = DeclarationType::LetDeclaration; - else if (isConstDeclaration) - declarationType = DeclarationType::ConstDeclaration; - else - RELEASE_ASSERT_NOT_REACHED(); - decls = parseVariableDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd, ForLoopContext, declarationType, ExportType::NotExported, forLoopConstDoesNotHaveInitializer); + decls = parseVarDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd); m_allowsIn = true; propagateError(); @@ -1152,21 +701,18 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement( 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"); - + failIfFalse(declarations == 1, "must declare variables after 'var'"); + failIfTrue(forInInitializer, "Cannot use initialiser syntax in a for-in loop"); + // 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(); @@ -1180,25 +726,20 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement( TreeStatement statement = parseStatement(context, unused); endLoop(); failIfFalse(statement, "Expected statement as body of for-", isOfEnumeration ? "of" : "in", " statement"); - gatherLexicalVariablesIfNecessary(); - TreeStatement result; if (isOfEnumeration) - result = context.createForOfLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine, *lexicalVariables); - else - result = context.createForInLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine, *lexicalVariables); - popLexicalScopeIfNecessary(); - return result; + 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 = tryParseDestructuringPatternExpression(context, AssignmentContext::DeclarationStatement); + pattern = tryParseDeconstructionPatternExpression(context); declsEnd = lastTokenEndPosition(); if (pattern && (match(INTOKEN) || (match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of))) goto enumerationLoop; - pattern = TreeDestructuringPattern(0); + pattern = 0; restoreSavePoint(savePoint); } m_allowsIn = false; @@ -1214,7 +755,6 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement( // Standard for loop next(); TreeExpression condition = 0; - failIfTrue(forLoopConstDoesNotHaveInitializer && isConstDeclaration, "const variables in for loops must have initializers"); if (!match(SEMICOLON)) { condition = parseExpression(context); @@ -1234,15 +774,12 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement( TreeStatement statement = parseStatement(context, unused); endLoop(); failIfFalse(statement, "Expected a statement as the body of a for loop"); - gatherLexicalVariablesIfNecessary(); - TreeStatement result = context.createForLoop(location, decls, condition, increment, statement, startLine, endLine, *lexicalVariables); - popLexicalScopeIfNecessary(); - return result; + return context.createForLoop(location, decls, condition, increment, statement, startLine, endLine); } - // For-in and For-of loop + // For-in loop enumerationLoop: - failIfFalse(nonLHSCount == m_parserState.nonLHSCount, "Expected a reference on the left hand side of an enumeration statement"); + 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"); @@ -1260,24 +797,15 @@ enumerationLoop: TreeStatement statement = parseStatement(context, unused); endLoop(); failIfFalse(statement, "Expected a statement as the body of a for-", isOfEnumeration ? "of" : "in", "loop"); - gatherLexicalVariablesIfNecessary(); - TreeStatement result; if (pattern) { ASSERT(!decls); if (isOfEnumeration) - result = context.createForOfLoop(location, pattern, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine, *lexicalVariables); - else - result = context.createForInLoop(location, pattern, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine, *lexicalVariables); - - popLexicalScopeIfNecessary(); - return result; + 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) - result = context.createForOfLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine, *lexicalVariables); - else - result = context.createForInLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine, *lexicalVariables); - popLexicalScopeIfNecessary(); - return result; + 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> @@ -1291,9 +819,9 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBreakStatemen if (autoSemiColon()) { semanticFailIfFalse(breakIsValid(), "'break' is only valid inside a switch or loop statement"); - return context.createBreakStatement(location, &m_vm->propertyNames->nullIdentifier, start, end); + return context.createBreakStatement(location, start, end); } - failIfFalse(matchSpecIdentifier(), "Expected an identifier as the target for a break statement"); + 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(); @@ -1313,13 +841,13 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseContinueState if (autoSemiColon()) { semanticFailIfFalse(continueIsValid(), "'continue' is only valid inside a loop statement"); - return context.createContinueStatement(location, &m_vm->propertyNames->nullIdentifier, start, end); + return context.createContinueStatement(location, start, end); } - failIfFalse(matchSpecIdentifier(), "Expected an identifier as the target for a continue statement"); + 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->isLoop, "Cannot continue to the label '", ident->impl(), "' as it is not targeting a loop"); + 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"); @@ -1409,9 +937,6 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStateme handleProductionOrFail(CLOSEPAREN, ")", "end", "subject of a 'switch'"); handleProductionOrFail(OPENBRACE, "{", "start", "body of a 'switch'"); - AutoPopScopeRef lexicalScope(this, pushScope()); - lexicalScope->setIsLexicalScope(); - lexicalScope->preventVarDeclarations(); startSwitch(); TreeClauseList firstClauses = parseSwitchClauses(context); propagateError(); @@ -1424,9 +949,8 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStateme endSwitch(); handleProductionOrFail(CLOSEBRACE, "}", "end", "body of a 'switch'"); - TreeStatement result = context.createSwitchStatement(location, expr, firstClauses, defaultClause, secondClauses, startLine, endLine, lexicalScope->finalizeLexicalEnvironment()); - popScope(lexicalScope, TreeBuilder::NeedsFreeVariableInfo); - return result; + return context.createSwitchStatement(location, expr, firstClauses, defaultClause, secondClauses, startLine, endLine); + } template <typename LexerType> @@ -1434,7 +958,6 @@ template <class TreeBuilder> TreeClauseList Parser<LexerType>::parseSwitchClause { if (!match(CASE)) return 0; - unsigned startOffset = tokenStart(); next(); TreeExpression condition = parseExpression(context); failIfFalse(condition, "Cannot parse switch clause"); @@ -1442,12 +965,10 @@ template <class TreeBuilder> TreeClauseList Parser<LexerType>::parseSwitchClause TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode); failIfFalse(statements, "Cannot parse the body of a switch clause"); TreeClause clause = context.createClause(condition, statements); - context.setStartOffset(clause, startOffset); TreeClauseList clauseList = context.createClauseList(clause); TreeClauseList tail = clauseList; while (match(CASE)) { - startOffset = tokenStart(); next(); TreeExpression condition = parseExpression(context); failIfFalse(condition, "Cannot parse switch case expression"); @@ -1455,7 +976,6 @@ template <class TreeBuilder> TreeClauseList Parser<LexerType>::parseSwitchClause TreeSourceElements statements = parseSourceElements(context, DontCheckForStrictMode); failIfFalse(statements, "Cannot parse the body of a switch clause"); clause = context.createClause(condition, statements); - context.setStartOffset(clause, startOffset); tail = context.createClauseList(tail, clause); } return clauseList; @@ -1466,14 +986,11 @@ template <class TreeBuilder> TreeClause Parser<LexerType>::parseSwitchDefaultCla { if (!match(DEFAULT)) return 0; - unsigned startOffset = tokenStart(); 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"); - TreeClause result = context.createClause(0, statements); - context.setStartOffset(result, startOffset); - return result; + return context.createClause(0, statements); } template <typename LexerType> @@ -1482,7 +999,7 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement( ASSERT(match(TRY)); JSTokenLocation location(tokenLocation()); TreeStatement tryBlock = 0; - TreeDestructuringPattern catchPattern = 0; + const Identifier* ident = &m_vm->propertyNames->nullIdentifier; TreeStatement catchBlock = 0; TreeStatement finallyBlock = 0; int firstLine = tokenLine(); @@ -1492,31 +1009,26 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement( tryBlock = parseBlockStatement(context); failIfFalse(tryBlock, "Cannot parse the body of try block"); int lastLine = m_lastTokenEndPosition.line; - VariableEnvironment catchEnvironment; + if (match(CATCH)) { + currentScope()->setNeedsFullActivation(); next(); handleProductionOrFail(OPENPAREN, "(", "start", "'catch' target"); - AutoPopScopeRef catchScope(this, pushScope()); - catchScope->setIsLexicalScope(); - catchScope->preventVarDeclarations(); - const Identifier* ident = nullptr; - if (matchSpecIdentifier()) { - ident = m_token.m_data.ident; - catchPattern = context.createBindingLocation(m_token.m_location, *ident, m_token.m_startPosition, m_token.m_endPosition, AssignmentContext::DeclarationStatement); - next(); - failIfTrueIfStrict(catchScope->declareLexicalVariable(ident, false) & DeclarationResult::InvalidStrictMode, "Cannot declare a catch variable named '", ident->impl(), "' in strict mode"); - } else { - catchPattern = parseDestructuringPattern(context, DestructuringKind::DestructureToCatchParameters, ExportType::NotExported); - failIfFalse(catchPattern, "Cannot parse this destructuring pattern"); + 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"); - catchEnvironment = catchScope->finalizeLexicalEnvironment(); - RELEASE_ASSERT(!ident || (catchEnvironment.size() == 1 && catchEnvironment.contains(ident->impl()))); - popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo); + failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo), "Parse error"); } if (match(FINALLY)) { @@ -1526,7 +1038,7 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement( 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, catchPattern, catchBlock, finallyBlock, firstLine, lastLine, catchEnvironment); + return context.createTryStatement(location, tryBlock, ident, catchBlock, finallyBlock, firstLine, lastLine); } template <typename LexerType> @@ -1547,44 +1059,18 @@ template <typename LexerType> template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context) { ASSERT(match(OPENBRACE)); - - // We should treat the first block statement of the function (the body of the function) as the lexical - // scope of the function itself, and not the lexical scope of a 'block' statement within the function. - AutoCleanupLexicalScope lexicalScope; - bool shouldPushLexicalScope = m_statementDepth > 0; - if (shouldPushLexicalScope) { - ScopeRef newScope = pushScope(); - newScope->setIsLexicalScope(); - newScope->preventVarDeclarations(); - lexicalScope.setIsValid(newScope, this); - } JSTokenLocation location(tokenLocation()); - int startOffset = m_token.m_data.offset; int start = tokenLine(); - VariableEnvironment emptyEnvironment; next(); if (match(CLOSEBRACE)) { - int endOffset = m_token.m_data.offset; next(); - TreeStatement result = context.createBlockStatement(location, 0, start, m_lastTokenEndPosition.line, shouldPushLexicalScope ? currentScope()->finalizeLexicalEnvironment() : emptyEnvironment); - context.setStartOffset(result, startOffset); - context.setEndOffset(result, endOffset); - if (shouldPushLexicalScope) - popScope(lexicalScope, TreeBuilder::NeedsFreeVariableInfo); - return result; + 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"); - int endOffset = m_token.m_data.offset; next(); - TreeStatement result = context.createBlockStatement(location, subtree, start, m_lastTokenEndPosition.line, shouldPushLexicalScope ? currentScope()->finalizeLexicalEnvironment() : emptyEnvironment); - context.setStartOffset(result, startOffset); - context.setEndOffset(result, endOffset); - if (shouldPushLexicalScope) - popScope(lexicalScope, TreeBuilder::NeedsFreeVariableInfo); - - return result; + return context.createBlockStatement(location, subtree, start, m_lastTokenEndPosition.line); } template <typename LexerType> @@ -1595,63 +1081,45 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatement(Tre directive = 0; int nonTrivialExpressionCount = 0; failIfStackOverflow(); - TreeStatement result = 0; - bool shouldSetEndOffset = true; - switch (m_token.m_type) { case OPENBRACE: - result = parseBlockStatement(context); - shouldSetEndOffset = false; - break; + return parseBlockStatement(context); case VAR: - result = parseVariableDeclaration(context, DeclarationType::VarDeclaration); - break; + 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"); - result = parseFunctionDeclaration(context); - break; + failIfFalseIfStrict(m_statementDepth == 1, "Nested functions cannot be declared in strict mode"); + return parseFunctionDeclaration(context); case SEMICOLON: { JSTokenLocation location(tokenLocation()); next(); - result = context.createEmptyStatement(location); - break; + return context.createEmptyStatement(location); } case IF: - result = parseIfStatement(context); - break; + return parseIfStatement(context); case DO: - result = parseDoWhileStatement(context); - break; + return parseDoWhileStatement(context); case WHILE: - result = parseWhileStatement(context); - break; + return parseWhileStatement(context); case FOR: - result = parseForStatement(context); - break; + return parseForStatement(context); case CONTINUE: - result = parseContinueStatement(context); - break; + return parseContinueStatement(context); case BREAK: - result = parseBreakStatement(context); - break; + return parseBreakStatement(context); case RETURN: - result = parseReturnStatement(context); - break; + return parseReturnStatement(context); case WITH: - result = parseWithStatement(context); - break; + return parseWithStatement(context); case SWITCH: - result = parseSwitchStatement(context); - break; + return parseSwitchStatement(context); case THROW: - result = parseThrowStatement(context); - break; + return parseThrowStatement(context); case TRY: - result = parseTryStatement(context); - break; + return parseTryStatement(context); case DEBUGGER: - result = parseDebuggerStatement(context); - break; + return parseDebuggerStatement(context); case EOFTOK: case CASE: case CLOSEBRACE: @@ -1659,681 +1127,196 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatement(Tre // These tokens imply the end of a set of source elements return 0; case IDENT: - case YIELD: - result = parseExpressionOrLabelStatement(context); - break; + 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_parserState.nonTrivialExpressionCount; + nonTrivialExpressionCount = m_nonTrivialExpressionCount; FALLTHROUGH; default: TreeStatement exprStatement = parseExpressionStatement(context); - if (directive && nonTrivialExpressionCount != m_parserState.nonTrivialExpressionCount) + if (directive && nonTrivialExpressionCount != m_nonTrivialExpressionCount) directive = 0; - result = exprStatement; - break; + return exprStatement; } - - if (result && shouldSetEndOffset) - context.setEndOffset(result, m_lastTokenEndPosition.offset); - return result; } template <typename LexerType> -template <class TreeBuilder> bool Parser<LexerType>::parseFormalParameters(TreeBuilder& context, TreeFormalParameterList list, unsigned& parameterCount) +template <class TreeBuilder> TreeFormalParameterList Parser<LexerType>::parseFormalParameters(TreeBuilder& context) { -#define failIfDuplicateIfViolation() \ - if (duplicateParameter) {\ - semanticFailIfTrue(defaultValue, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in function with default parameter values");\ - semanticFailIfTrue(hasDestructuringPattern, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in function with destructuring parameters");\ - semanticFailIfTrue(isRestParameter, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in function with a rest parameter");\ - } - - bool hasDestructuringPattern = false; - bool isRestParameter = false; - const Identifier* duplicateParameter = nullptr; - do { - TreeDestructuringPattern parameter = 0; - TreeExpression defaultValue = 0; - - if (match(DOTDOTDOT)) { - next(); - failIfFalse(matchSpecIdentifier(), "Rest parameter '...' should be followed by a variable identifier"); - declareRestOrNormalParameter(*m_token.m_data.ident, &duplicateParameter); - propagateError(); - JSTextPosition identifierStart = tokenStartPosition(); - JSTextPosition identifierEnd = tokenEndPosition(); - parameter = context.createRestParameter(*m_token.m_data.ident, parameterCount, identifierStart, identifierEnd); - next(); - failIfTrue(match(COMMA), "Rest parameter should be the last parameter in a function declaration"); // Let's have a good error message for this common case. - isRestParameter = true; - } else - parameter = parseDestructuringPattern(context, DestructuringKind::DestructureToParameters, ExportType::NotExported, &duplicateParameter, &hasDestructuringPattern); + 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"); - if (!isRestParameter) - defaultValue = parseDefaultValueForDestructuringPattern(context); - propagateError(); - failIfDuplicateIfViolation(); - context.appendParameter(list, parameter, defaultValue); - if (!isRestParameter) - parameterCount++; - } while (!isRestParameter && consume(COMMA)); - - return true; -#undef failIfDuplicateIfViolation + tail = context.createFormalParameterList(tail, parameter); + } + return list; } template <typename LexerType> -template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody( - TreeBuilder& context, const JSTokenLocation& startLocation, int startColumn, int functionKeywordStart, int functionNameStart, int parametersStart, - ConstructorKind constructorKind, SuperBinding superBinding, FunctionBodyType bodyType, unsigned parameterCount, SourceParseMode parseMode) +template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(TreeBuilder& context) { - bool isArrowFunctionBodyExpression = bodyType == ArrowFunctionBodyExpression; - if (!isArrowFunctionBodyExpression) { - next(); - if (match(CLOSEBRACE)) { - unsigned endColumn = tokenColumn(); - return context.createFunctionMetadata(startLocation, tokenLocation(), startColumn, endColumn, functionKeywordStart, functionNameStart, parametersStart, strictMode(), constructorKind, superBinding, parameterCount, parseMode, isArrowFunctionBodyExpression); - } - } + 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; - SyntaxChecker syntaxChecker(const_cast<VM*>(m_vm), m_lexer.get()); - if (bodyType == ArrowFunctionBodyExpression) - failIfFalse(parseArrowFunctionSingleExpressionBodySourceElements(syntaxChecker), "Cannot parse body of this arrow function"); - else - failIfFalse(parseSourceElements(syntaxChecker, CheckForStrictMode), bodyType == StandardFunctionBodyBlock ? "Cannot parse body of this function" : "Cannot parse body of this arrow function"); + 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.createFunctionMetadata(startLocation, tokenLocation(), startColumn, endColumn, functionKeywordStart, functionNameStart, parametersStart, strictMode(), constructorKind, superBinding, parameterCount, parseMode, isArrowFunctionBodyExpression); + return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, strictMode()); } -static const char* stringForFunctionMode(SourceParseMode mode) +static const char* stringForFunctionMode(FunctionParseMode mode) { switch (mode) { - case SourceParseMode::GetterMode: + case GetterMode: return "getter"; - case SourceParseMode::SetterMode: + case SetterMode: return "setter"; - case SourceParseMode::NormalFunctionMode: + case FunctionMode: return "function"; - case SourceParseMode::MethodMode: - return "method"; - case SourceParseMode::GeneratorBodyMode: - return "generator"; - case SourceParseMode::GeneratorWrapperFunctionMode: - return "generator function"; - case SourceParseMode::ArrowFunctionMode: - return "arrow function"; - case SourceParseMode::ProgramMode: - case SourceParseMode::ModuleAnalyzeMode: - case SourceParseMode::ModuleEvaluateMode: - RELEASE_ASSERT_NOT_REACHED(); - return ""; } RELEASE_ASSERT_NOT_REACHED(); return nullptr; } -template <typename LexerType> template <class TreeBuilder> int Parser<LexerType>::parseFunctionParameters(TreeBuilder& context, SourceParseMode mode, ParserFunctionInfo<TreeBuilder>& functionInfo) +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) { - RELEASE_ASSERT(mode != SourceParseMode::ProgramMode && mode != SourceParseMode::ModuleAnalyzeMode && mode != SourceParseMode::ModuleEvaluateMode); - int parametersStart = m_token.m_location.startOffset; - TreeFormalParameterList parameterList = context.createFormalParameterList(); - functionInfo.parameters = parameterList; - functionInfo.startOffset = parametersStart; - SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Parameters); - - if (mode == SourceParseMode::ArrowFunctionMode) { - if (!match(IDENT) && !match(OPENPAREN)) { - semanticFailureDueToKeyword(stringForFunctionMode(mode), " name"); - failWithMessage("Expected an arrow function input parameter"); - } else { - if (match(OPENPAREN)) { - next(); - - if (match(CLOSEPAREN)) - functionInfo.parameterCount = 0; - else - failIfFalse(parseFormalParameters(context, parameterList, functionInfo.parameterCount), "Cannot parse parameters for this ", stringForFunctionMode(mode)); - - consumeOrFail(CLOSEPAREN, "Expected a ')' or a ',' after a parameter declaration"); - } else { - functionInfo.parameterCount = 1; - auto parameter = parseDestructuringPattern(context, DestructuringKind::DestructureToParameters, ExportType::NotExported); - failIfFalse(parameter, "Cannot parse parameter pattern"); - context.appendParameter(parameterList, parameter, 0); - } - } - - return parametersStart; + 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 (mode == SourceParseMode::GetterMode) { - consumeOrFail(CLOSEPAREN, "getter functions must have no parameters"); - functionInfo.parameterCount = 0; - } else if (mode == SourceParseMode::SetterMode) { - failIfTrue(match(CLOSEPAREN), "setter functions must have one parameter"); - const Identifier* duplicateParameter = nullptr; - auto parameter = parseDestructuringPattern(context, DestructuringKind::DestructureToParameters, ExportType::NotExported, &duplicateParameter); - failIfFalse(parameter, "setter functions must have one parameter"); - auto defaultValue = parseDefaultValueForDestructuringPattern(context); - propagateError(); - semanticFailIfTrue(duplicateParameter && defaultValue, "Duplicate parameter '", duplicateParameter->impl(), "' not allowed in function with default parameter values"); - context.appendParameter(parameterList, parameter, defaultValue); - functionInfo.parameterCount = 1; - failIfTrue(match(COMMA), "setter functions must have one parameter"); - consumeOrFail(CLOSEPAREN, "Expected a ')' after a parameter declaration"); - } else { - if (match(CLOSEPAREN)) - functionInfo.parameterCount = 0; - else - failIfFalse(parseFormalParameters(context, parameterList, functionInfo.parameterCount), "Cannot parse parameters for this ", stringForFunctionMode(mode)); - consumeOrFail(CLOSEPAREN, "Expected a ')' or a ',' after a parameter declaration"); + if (!match(CLOSEPAREN)) { + parameters = parseFormalParameters(context); + failIfFalse(parameters, "Cannot parse parameters for this ", stringForFunctionMode(mode)); } - - return parametersStart; -} - -template <typename LexerType> -template <class TreeBuilder> typename TreeBuilder::FormalParameterList Parser<LexerType>::createGeneratorParameters(TreeBuilder& context) -{ - auto parameters = context.createFormalParameterList(); - - JSTokenLocation location(tokenLocation()); - JSTextPosition position = tokenStartPosition(); - - // @generator - declareParameter(&m_vm->propertyNames->generatorPrivateName); - auto generator = context.createBindingLocation(location, m_vm->propertyNames->generatorPrivateName, position, position, AssignmentContext::DeclarationStatement); - context.appendParameter(parameters, generator, 0); - - // @generatorState - declareParameter(&m_vm->propertyNames->generatorStatePrivateName); - auto generatorState = context.createBindingLocation(location, m_vm->propertyNames->generatorStatePrivateName, position, position, AssignmentContext::DeclarationStatement); - context.appendParameter(parameters, generatorState, 0); - - // @generatorValue - declareParameter(&m_vm->propertyNames->generatorValuePrivateName); - auto generatorValue = context.createBindingLocation(location, m_vm->propertyNames->generatorValuePrivateName, position, position, AssignmentContext::DeclarationStatement); - context.appendParameter(parameters, generatorValue, 0); - - // @generatorResumeMode - declareParameter(&m_vm->propertyNames->generatorResumeModePrivateName); - auto generatorResumeMode = context.createBindingLocation(location, m_vm->propertyNames->generatorResumeModePrivateName, position, position, AssignmentContext::DeclarationStatement); - context.appendParameter(parameters, generatorResumeMode, 0); - - return parameters; -} - -template <typename LexerType> -template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, FunctionRequirements requirements, SourceParseMode mode, bool nameIsInContainingScope, ConstructorKind constructorKind, SuperBinding expectedSuperBinding, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>& functionInfo, FunctionDefinitionType functionDefinitionType) -{ - RELEASE_ASSERT(isFunctionParseMode(mode)); - - bool upperScopeIsGenerator = currentScope()->isGenerator(); - AutoPopScopeRef functionScope(this, pushScope()); - functionScope->setSourceParseMode(mode); - SetForScope<FunctionParsePhase> functionParsePhasePoisoner(m_parserState.functionParsePhase, FunctionParsePhase::Body); - int functionNameStart = m_token.m_location.startOffset; - const Identifier* lastFunctionName = m_parserState.lastFunctionName; - m_parserState.lastFunctionName = nullptr; - int parametersStart; - JSTokenLocation startLocation; - int startColumn; - FunctionBodyType functionBodyType; - - if (mode == SourceParseMode::ArrowFunctionMode) { - startLocation = tokenLocation(); - functionInfo.startLine = tokenLine(); - startColumn = tokenColumn(); - - parametersStart = parseFunctionParameters(context, mode, functionInfo); - propagateError(); - - matchOrFail(ARROWFUNCTION, "Expected a '=>' after arrow function parameter declaration"); - - if (m_lexer->prevTerminator()) - failDueToUnexpectedToken(); - - ASSERT(constructorKind == ConstructorKind::None); - - // Check if arrow body start with {. If it true it mean that arrow function is Fat arrow function - // and we need use common approach to parse function body - next(); - functionBodyType = match(OPENBRACE) ? ArrowFunctionBodyBlock : ArrowFunctionBodyExpression; - } else { - // http://ecma-international.org/ecma-262/6.0/#sec-function-definitions - // FunctionExpression : - // function BindingIdentifieropt ( FormalParameters ) { FunctionBody } - // - // FunctionDeclaration[Yield, Default] : - // function BindingIdentifier[?Yield] ( FormalParameters ) { FunctionBody } - // [+Default] function ( FormalParameters ) { FunctionBody } - // - // GeneratorDeclaration[Yield, Default] : - // function * BindingIdentifier[?Yield] ( FormalParameters[Yield] ) { GeneratorBody } - // [+Default] function * ( FormalParameters[Yield] ) { GeneratorBody } - // - // GeneratorExpression : - // function * BindingIdentifier[Yield]opt ( FormalParameters[Yield] ) { GeneratorBody } - // - // The name of FunctionExpression can accept "yield" even in the context of generator. - if (functionDefinitionType == FunctionDefinitionType::Expression && mode == SourceParseMode::NormalFunctionMode) - upperScopeIsGenerator = false; - - if (matchSpecIdentifier(upperScopeIsGenerator)) { - functionInfo.name = m_token.m_data.ident; - m_parserState.lastFunctionName = functionInfo.name; - next(); - if (!nameIsInContainingScope) - failIfTrueIfStrict(functionScope->declareCallee(functionInfo.name) & DeclarationResult::InvalidStrictMode, "'", functionInfo.name->impl(), "' is not a valid ", stringForFunctionMode(mode), " name in strict mode"); - } else if (requirements == FunctionNeedsName) { - if (match(OPENPAREN) && mode == SourceParseMode::NormalFunctionMode) - semanticFail("Function statements must have a name"); - semanticFailureDueToKeyword(stringForFunctionMode(mode), " name"); - failDueToUnexpectedToken(); - return false; - } - - startLocation = tokenLocation(); - functionInfo.startLine = tokenLine(); - startColumn = tokenColumn(); - - parametersStart = parseFunctionParameters(context, mode, functionInfo); - propagateError(); - - matchOrFail(OPENBRACE, "Expected an opening '{' at the start of a ", stringForFunctionMode(mode), " body"); - - // BytecodeGenerator emits code to throw TypeError when a class constructor is "call"ed. - // Set ConstructorKind to None for non-constructor methods of classes. + consumeOrFail(CLOSEPAREN, "Expected a ')' or a ',' after a parameter declaration"); + matchOrFail(OPENBRACE, "Expected an opening '{' at the start of a ", stringForFunctionMode(mode), " body"); - if (m_defaultConstructorKind != ConstructorKind::None) { - constructorKind = m_defaultConstructorKind; - expectedSuperBinding = m_defaultConstructorKind == ConstructorKind::Derived ? SuperBinding::Needed : SuperBinding::NotNeeded; - } - - functionBodyType = StandardFunctionBodyBlock; - } - - functionScope->setConstructorKind(constructorKind); - functionScope->setExpectedSuperBinding(expectedSuperBinding); - - functionInfo.bodyStartColumn = startColumn; + 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(functionInfo.startOffset) : 0) { + 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->lastTockenLine; - endLocation.startOffset = cachedInfo->lastTockenStartOffset; - endLocation.lineStartOffset = cachedInfo->lastTockenLineStartOffset; + endLocation.line = cachedInfo->closeBraceLine; + endLocation.startOffset = cachedInfo->closeBraceOffset; + endLocation.lineStartOffset = cachedInfo->closeBraceLineStartOffset; - bool endColumnIsOnStartLine = (endLocation.line == functionInfo.startLine); + bool endColumnIsOnStartLine = (endLocation.line == bodyStartLine); ASSERT(endLocation.startOffset >= endLocation.lineStartOffset); unsigned bodyEndColumn = endColumnIsOnStartLine ? endLocation.startOffset - m_token.m_data.lineStartOffset : endLocation.startOffset - endLocation.lineStartOffset; - unsigned currentLineStartOffset = m_token.m_location.lineStartOffset; - - functionInfo.body = context.createFunctionMetadata( - startLocation, endLocation, functionInfo.bodyStartColumn, bodyEndColumn, - functionKeywordStart, functionNameStart, parametersStart, - cachedInfo->strictMode, constructorKind, expectedSuperBinding, cachedInfo->parameterCount, mode, functionBodyType == ArrowFunctionBodyExpression); + + body = context.createFunctionBody(startLocation, endLocation, bodyStartColumn, bodyEndColumn, cachedInfo->strictMode); functionScope->restoreFromSourceProviderCache(cachedInfo); - popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo); - - m_token = cachedInfo->endFunctionToken(); + failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo), "Parser error"); - if (endColumnIsOnStartLine) - m_token.m_location.lineStartOffset = currentLineStartOffset; + 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); - functionInfo.endOffset = cachedInfo->endFunctionOffset; - - if (mode == SourceParseMode::ArrowFunctionMode) - functionBodyType = cachedInfo->isBodyArrowExpression ? ArrowFunctionBodyExpression : ArrowFunctionBodyBlock; - else - functionBodyType = StandardFunctionBodyBlock; - switch (functionBodyType) { - case ArrowFunctionBodyExpression: - next(); - context.setEndOffset(functionInfo.body, m_lexer->currentOffset()); - break; - case ArrowFunctionBodyBlock: - case StandardFunctionBodyBlock: - context.setEndOffset(functionInfo.body, m_lexer->currentOffset()); - next(); - break; - } - functionInfo.endLine = m_lastTokenEndPosition.line; + next(); return true; } - - m_parserState.lastFunctionName = lastFunctionName; - ParserState oldState = internalSaveParserState(); - - auto performParsingFunctionBody = [&] { - return parseFunctionBody(context, startLocation, startColumn, functionKeywordStart, functionNameStart, parametersStart, constructorKind, expectedSuperBinding, functionBodyType, functionInfo.parameterCount, mode); - }; - - if (mode == SourceParseMode::GeneratorWrapperFunctionMode) { - AutoPopScopeRef generatorBodyScope(this, pushScope()); - generatorBodyScope->setSourceParseMode(SourceParseMode::GeneratorBodyMode); - functionInfo.body = performParsingFunctionBody(); - - // When a generator has a "use strict" directive, a generator function wrapping it should be strict mode. - if (generatorBodyScope->strictMode()) - functionScope->setStrictMode(); - - semanticFailIfTrue(generatorBodyScope->hasDirectSuper(), "Cannot call super() outside of a class constructor"); - if (generatorBodyScope->needsSuperBinding()) - semanticFailIfTrue(expectedSuperBinding == SuperBinding::NotNeeded, "super can only be used in a method of a derived class"); - - popScope(generatorBodyScope, TreeBuilder::NeedsFreeVariableInfo); - } else - functionInfo.body = performParsingFunctionBody(); - - restoreParserState(oldState); - failIfFalse(functionInfo.body, "Cannot parse the body of this ", stringForFunctionMode(mode)); - context.setEndOffset(functionInfo.body, m_lexer->currentOffset()); - if (functionScope->strictMode() && functionInfo.name) { - RELEASE_ASSERT(mode == SourceParseMode::NormalFunctionMode || mode == SourceParseMode::MethodMode || mode == SourceParseMode::ArrowFunctionMode || mode == SourceParseMode::GeneratorBodyMode || mode == SourceParseMode::GeneratorWrapperFunctionMode); - semanticFailIfTrue(m_vm->propertyNames->arguments == *functionInfo.name, "'", functionInfo.name->impl(), "' is not a valid function name in strict mode"); - semanticFailIfTrue(m_vm->propertyNames->eval == *functionInfo.name, "'", functionInfo.name->impl(), "' is not a valid function name in strict mode"); - } - // It unncecessary to check of using super during reparsing one more time. Also it can lead to syntax error - // in case of arrow function becuase during reparsing we don't know that parse arrow function - // inside of the constructor or method - if (!m_lexer->isReparsingFunction()) { - if (functionScope->hasDirectSuper()) { - ConstructorKind functionConstructorKind = functionBodyType == StandardFunctionBodyBlock - ? constructorKind - : closestParentNonArrowFunctionNonLexicalScope()->constructorKind(); - semanticFailIfTrue(functionConstructorKind == ConstructorKind::None, "Cannot call super() outside of a class constructor"); - semanticFailIfTrue(functionConstructorKind != ConstructorKind::Derived, "Cannot call super() in a base class constructor"); - } - if (functionScope->needsSuperBinding()) { - SuperBinding functionSuperBinding = functionBodyType == StandardFunctionBodyBlock - ? expectedSuperBinding - : closestParentNonArrowFunctionNonLexicalScope()->expectedSuperBinding(); - semanticFailIfTrue(functionSuperBinding == SuperBinding::NotNeeded, "super can only be used in a method of a derived class"); - } - } - - JSTokenLocation location = JSTokenLocation(m_token.m_location); - functionInfo.endOffset = m_token.m_data.offset; - - if (functionBodyType == ArrowFunctionBodyExpression) { - location = locationBeforeLastToken(); - functionInfo.endOffset = location.endOffset; - } + 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. - // For arrow function is 8 = x=>x + 4 symbols; - // For ordinary function is 16 = function(){} + 4 symbols - const int minimumFunctionLengthToCache = functionBodyType == StandardFunctionBodyBlock ? 16 : 8; + static const int minimumFunctionLengthToCache = 16; std::unique_ptr<SourceProviderCacheItem> newInfo; - int functionLength = functionInfo.endOffset - functionInfo.startOffset; + int functionLength = closeBraceOffset - openBraceOffset; if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) { SourceProviderCacheItemCreationParameters parameters; - parameters.endFunctionOffset = functionInfo.endOffset; parameters.functionNameStart = functionNameStart; - parameters.lastTockenLine = location.line; - parameters.lastTockenStartOffset = location.startOffset; - parameters.lastTockenEndOffset = location.endOffset; - parameters.lastTockenLineStartOffset = location.lineStartOffset; - parameters.parameterCount = functionInfo.parameterCount; - if (functionBodyType == ArrowFunctionBodyExpression) { - parameters.isBodyArrowExpression = true; - parameters.tokenType = m_token.m_type; - } + parameters.closeBraceLine = closeBraceLine; + parameters.closeBraceOffset = closeBraceOffset; + parameters.closeBraceLineStartOffset = closeBraceLineStartOffset; functionScope->fillParametersForSourceProviderCache(parameters); newInfo = SourceProviderCacheItem::create(parameters); + } + context.setFunctionNameStart(body, functionNameStart); - popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo); - - if (functionBodyType == ArrowFunctionBodyExpression) - failIfFalse(isEndOfArrowFunction(), "Expected the closing ';' ',' ']' ')' '}', line terminator or EOF after arrow function"); - else { - matchOrFail(CLOSEBRACE, "Expected a closing '}' after a ", stringForFunctionMode(mode), " body"); - next(); - } + failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo), "Parser error"); + matchOrFail(CLOSEBRACE, "Expected a closing '}' after a ", stringForFunctionMode(mode), " body"); if (newInfo) - m_functionCache->add(functionInfo.startOffset, WTFMove(newInfo)); + m_functionCache->add(openBraceOffset, std::move(newInfo)); - functionInfo.endLine = m_lastTokenEndPosition.line; + next(); return true; } template <typename LexerType> -template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context, ExportType exportType) +template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context) { ASSERT(match(FUNCTION)); JSTokenLocation location(tokenLocation()); - unsigned functionKeywordStart = tokenStart(); - next(); - ParserFunctionInfo<TreeBuilder> functionInfo; - SourceParseMode parseMode = SourceParseMode::NormalFunctionMode; -#if ENABLE(ES6_GENERATORS) - if (consume(TIMES)) - parseMode = SourceParseMode::GeneratorWrapperFunctionMode; -#endif - failIfFalse((parseFunctionInfo(context, FunctionNeedsName, parseMode, true, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, functionInfo, FunctionDefinitionType::Declaration)), "Cannot parse this function"); - failIfFalse(functionInfo.name, "Function statements must have a name"); - - DeclarationResultMask declarationResult = declareVariable(functionInfo.name); - failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare a function named '", functionInfo.name->impl(), "' in strict mode"); - if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) - internalFailWithMessage(false, "Cannot declare a function that shadows a let/const/class variable '", functionInfo.name->impl(), "' in strict mode"); - if (exportType == ExportType::Exported) { - semanticFailIfFalse(exportName(*functionInfo.name), "Cannot export a duplicate function name: '", functionInfo.name->impl(), "'"); - currentScope()->moduleScopeData().exportBinding(*functionInfo.name); - } - return context.createFuncDeclStatement(location, functionInfo); -} - -template <typename LexerType> -template <class TreeBuilder> TreeStatement Parser<LexerType>::parseClassDeclaration(TreeBuilder& context, ExportType exportType) -{ - ASSERT(match(CLASSTOKEN)); - JSTokenLocation location(tokenLocation()); - JSTextPosition classStart = tokenStartPosition(); - unsigned classStartLine = tokenLine(); - - ParserClassInfo<TreeBuilder> info; - TreeClassExpression classExpr = parseClass(context, FunctionNeedsName, info); - failIfFalse(classExpr, "Failed to parse class"); - - DeclarationResultMask declarationResult = declareVariable(info.className, DeclarationType::LetDeclaration); - if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) - internalFailWithMessage(false, "Cannot declare a class twice: '", info.className->impl(), "'"); - if (exportType == ExportType::Exported) { - semanticFailIfFalse(exportName(*info.className), "Cannot export a duplicate class name: '", info.className->impl(), "'"); - currentScope()->moduleScopeData().exportBinding(*info.className); - } - - JSTextPosition classEnd = lastTokenEndPosition(); - unsigned classEndLine = tokenLine(); - - return context.createClassDeclStatement(location, classExpr, classStart, classEnd, classStartLine, classEndLine); -} - -template <typename LexerType> -template <class TreeBuilder> TreeClassExpression Parser<LexerType>::parseClass(TreeBuilder& context, FunctionRequirements requirements, ParserClassInfo<TreeBuilder>& info) -{ - ASSERT(match(CLASSTOKEN)); - JSTokenLocation location(tokenLocation()); next(); - - AutoPopScopeRef classScope(this, pushScope()); - classScope->setIsLexicalScope(); - classScope->preventVarDeclarations(); - classScope->setStrictMode(); - - const Identifier* className = nullptr; - if (match(IDENT)) { - className = m_token.m_data.ident; - info.className = className; - next(); - failIfTrue(classScope->declareLexicalVariable(className, true) & DeclarationResult::InvalidStrictMode, "'", className->impl(), "' is not a valid class name"); - } else if (requirements == FunctionNeedsName) { - if (match(OPENBRACE)) - semanticFail("Class statements must have a name"); - semanticFailureDueToKeyword("class name"); - failDueToUnexpectedToken(); - } else - className = &m_vm->propertyNames->nullIdentifier; - ASSERT(className); - - TreeExpression parentClass = 0; - if (consume(EXTENDS)) { - parentClass = parseMemberExpression(context); - failIfFalse(parentClass, "Cannot parse the parent class name"); - } - const ConstructorKind constructorKind = parentClass ? ConstructorKind::Derived : ConstructorKind::Base; - - consumeOrFail(OPENBRACE, "Expected opening '{' at the start of a class body"); - - TreeExpression constructor = 0; - TreePropertyList staticMethods = 0; - TreePropertyList instanceMethods = 0; - TreePropertyList instanceMethodsTail = 0; - TreePropertyList staticMethodsTail = 0; - while (!match(CLOSEBRACE)) { - if (match(SEMICOLON)) { - next(); - continue; - } - - JSTokenLocation methodLocation(tokenLocation()); - unsigned methodStart = tokenStart(); - - // For backwards compatibility, "static" is a non-reserved keyword in non-strict mode. - bool isStaticMethod = false; - if (match(RESERVED_IF_STRICT) && *m_token.m_data.ident == m_vm->propertyNames->staticKeyword) { - SavePoint savePoint = createSavePoint(); - next(); - if (match(OPENPAREN)) { - // Reparse "static()" as a method named "static". - restoreSavePoint(savePoint); - } else - isStaticMethod = true; - } - - // FIXME: Figure out a way to share more code with parseProperty. - const CommonIdentifiers& propertyNames = *m_vm->propertyNames; - const Identifier* ident = &propertyNames.nullIdentifier; - TreeExpression computedPropertyName = 0; - bool isGetter = false; - bool isSetter = false; - bool isGenerator = false; -#if ENABLE(ES6_GENERATORS) - if (consume(TIMES)) - isGenerator = true; -#endif - switch (m_token.m_type) { - namedKeyword: - case STRING: - ident = m_token.m_data.ident; - ASSERT(ident); - next(); - break; - case IDENT: - ident = m_token.m_data.ident; - ASSERT(ident); - next(); - if (!isGenerator && (matchIdentifierOrKeyword() || match(STRING) || match(DOUBLE) || match(INTEGER) || match(OPENBRACKET))) { - isGetter = *ident == propertyNames.get; - isSetter = *ident == propertyNames.set; - } - break; - case DOUBLE: - case INTEGER: - ident = &m_parserArena.identifierArena().makeNumericIdentifier(const_cast<VM*>(m_vm), m_token.m_data.doubleValue); - ASSERT(ident); - next(); - break; - case OPENBRACKET: - next(); - computedPropertyName = parseAssignmentExpression(context); - failIfFalse(computedPropertyName, "Cannot parse computed property name"); - handleProductionOrFail(CLOSEBRACKET, "]", "end", "computed property name"); - break; - default: - if (m_token.m_type & KeywordTokenFlag) - goto namedKeyword; - failDueToUnexpectedToken(); - } - - TreeProperty property; - const bool alwaysStrictInsideClass = true; - if (isGetter || isSetter) { - property = parseGetterSetter(context, alwaysStrictInsideClass, isGetter ? PropertyNode::Getter : PropertyNode::Setter, methodStart, - ConstructorKind::None, SuperBinding::Needed); - failIfFalse(property, "Cannot parse this method"); - } else { - ParserFunctionInfo<TreeBuilder> methodInfo; - bool isConstructor = !isStaticMethod && *ident == propertyNames.constructor; - SourceParseMode parseMode = SourceParseMode::MethodMode; - if (isGenerator) { - isConstructor = false; - parseMode = SourceParseMode::GeneratorWrapperFunctionMode; - semanticFailIfTrue(*ident == m_vm->propertyNames->prototype, "Cannot declare a generator named 'prototype'"); - semanticFailIfTrue(*ident == m_vm->propertyNames->constructor, "Cannot declare a generator named 'constructor'"); - } - failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, parseMode, false, isConstructor ? constructorKind : ConstructorKind::None, SuperBinding::Needed, methodStart, methodInfo, FunctionDefinitionType::Method)), "Cannot parse this method"); - methodInfo.name = isConstructor ? className : ident; - - TreeExpression method = context.createFunctionExpr(methodLocation, methodInfo); - if (isConstructor) { - semanticFailIfTrue(constructor, "Cannot declare multiple constructors in a single class"); - constructor = method; - continue; - } - - // FIXME: Syntax error when super() is called - semanticFailIfTrue(isStaticMethod && methodInfo.name && *methodInfo.name == propertyNames.prototype, - "Cannot declare a static method named 'prototype'"); - if (computedPropertyName) { - property = context.createProperty(computedPropertyName, method, static_cast<PropertyNode::Type>(PropertyNode::Constant | PropertyNode::Computed), - PropertyNode::Unknown, alwaysStrictInsideClass, SuperBinding::Needed); - } else - property = context.createProperty(methodInfo.name, method, PropertyNode::Constant, PropertyNode::Unknown, alwaysStrictInsideClass, SuperBinding::Needed); - } - - TreePropertyList& tail = isStaticMethod ? staticMethodsTail : instanceMethodsTail; - if (tail) - tail = context.createPropertyList(methodLocation, property, tail); - else { - tail = context.createPropertyList(methodLocation, property); - if (isStaticMethod) - staticMethods = tail; - else - instanceMethods = tail; - } - } - - consumeOrFail(CLOSEBRACE, "Expected a closing '}' after a class body"); - - auto classExpression = context.createClassExpr(location, *className, classScope->finalizeLexicalEnvironment(), constructor, parentClass, instanceMethods, staticMethods); - popScope(classScope, TreeBuilder::NeedsFreeVariableInfo); - return classExpression; + 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 { @@ -2383,7 +1366,7 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrL failIfTrue(getLabel(ident), "Cannot find scope for the label '", ident->impl(), "'"); labels.append(LabelInfo(ident, start, end)); } - } while (matchSpecIdentifier()); + } while (match(IDENT)); bool isLoop = false; switch (m_token.m_type) { case FOR: @@ -2396,7 +1379,6 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrL break; } const Identifier* unused = 0; - ScopeRef labelScope = currentScope(); if (!m_syntaxAlreadyValidated) { for (size_t i = 0; i < labels.size(); i++) pushLabel(labels[i].m_ident, isLoop); @@ -2404,7 +1386,7 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrL TreeStatement statement = parseStatement(context, unused); if (!m_syntaxAlreadyValidated) { for (size_t i = 0; i < labels.size(); i++) - popLabel(labelScope); + popLabel(); } failIfFalse(statement, "Cannot parse statement"); for (size_t i = 0; i < labels.size(); i++) { @@ -2417,19 +1399,6 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrL template <typename LexerType> template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionStatement(TreeBuilder& context) { - switch (m_token.m_type) { - // Consult: http://www.ecma-international.org/ecma-262/6.0/index.html#sec-expression-statement - // The ES6 spec mandates that we should fail from FUNCTION token here. We handle this case - // in parseStatement() which is the only caller of parseExpressionStatement(). - // We actually allow FUNCTION in situations where it should not be allowed unless we're in strict mode. - case CLASSTOKEN: - failWithMessage("'class' declaration is not directly within a block statement"); - break; - default: - // FIXME: when implementing 'let' we should fail when we see the token sequence "let [". - // https://bugs.webkit.org/show_bug.cgi?id=142944 - break; - } JSTextPosition start = tokenStartPosition(); JSTokenLocation location(tokenLocation()); TreeExpression expression = parseExpression(context); @@ -2502,9 +1471,7 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(T posStack.removeLast(); JSTokenLocation elseLocation = tokenLocationStack.last(); tokenLocationStack.removeLast(); - TreeStatement ifStatement = context.createIfStatement(elseLocation, condition, trueBlock, 0, pos.first, pos.second); - context.setEndOffset(ifStatement, context.endOffset(trueBlock)); - statementStack.append(ifStatement); + statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, 0, pos.first, pos.second)); } while (!exprStack.isEmpty()) { @@ -2518,480 +1485,57 @@ template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(T posStack.removeLast(); JSTokenLocation elseLocation = tokenLocationStack.last(); tokenLocationStack.removeLast(); - TreeStatement ifStatement = context.createIfStatement(elseLocation, condition, trueBlock, falseBlock, pos.first, pos.second); - context.setEndOffset(ifStatement, context.endOffset(falseBlock)); - statementStack.append(ifStatement); + 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> typename TreeBuilder::ModuleName Parser<LexerType>::parseModuleName(TreeBuilder& context) -{ - // ModuleName (ModuleSpecifier in the spec) represents the module name imported by the script. - // http://www.ecma-international.org/ecma-262/6.0/#sec-imports - // http://www.ecma-international.org/ecma-262/6.0/#sec-exports - JSTokenLocation specifierLocation(tokenLocation()); - failIfFalse(match(STRING), "Imported modules names must be string literals"); - const Identifier* moduleName = m_token.m_data.ident; - next(); - return context.createModuleName(specifierLocation, *moduleName); -} - -template <typename LexerType> -template <class TreeBuilder> typename TreeBuilder::ImportSpecifier Parser<LexerType>::parseImportClauseItem(TreeBuilder& context, ImportSpecifierType specifierType) -{ - // Produced node is the item of the ImportClause. - // That is the ImportSpecifier, ImportedDefaultBinding or NameSpaceImport. - // http://www.ecma-international.org/ecma-262/6.0/#sec-imports - JSTokenLocation specifierLocation(tokenLocation()); - JSToken localNameToken; - const Identifier* importedName = nullptr; - const Identifier* localName = nullptr; - - switch (specifierType) { - case ImportSpecifierType::NamespaceImport: { - // NameSpaceImport : - // * as ImportedBinding - // e.g. - // * as namespace - ASSERT(match(TIMES)); - importedName = &m_vm->propertyNames->timesIdentifier; - next(); - - failIfFalse(matchContextualKeyword(m_vm->propertyNames->as), "Expected 'as' before imported binding name"); - next(); - - matchOrFail(IDENT, "Expected a variable name for the import declaration"); - localNameToken = m_token; - localName = m_token.m_data.ident; - next(); - break; - } - - case ImportSpecifierType::NamedImport: { - // ImportSpecifier : - // ImportedBinding - // IdentifierName as ImportedBinding - // e.g. - // A - // A as B - ASSERT(matchIdentifierOrKeyword()); - localNameToken = m_token; - localName = m_token.m_data.ident; - importedName = localName; - next(); - - if (matchContextualKeyword(m_vm->propertyNames->as)) { - next(); - matchOrFail(IDENT, "Expected a variable name for the import declaration"); - localNameToken = m_token; - localName = m_token.m_data.ident; - next(); - } - break; - } - - case ImportSpecifierType::DefaultImport: { - // ImportedDefaultBinding : - // ImportedBinding - ASSERT(match(IDENT)); - localNameToken = m_token; - localName = m_token.m_data.ident; - importedName = &m_vm->propertyNames->defaultKeyword; - next(); - break; - } - } - - semanticFailIfTrue(localNameToken.m_type & KeywordTokenFlag, "Cannot use keyword as imported binding name"); - DeclarationResultMask declarationResult = declareVariable(localName, DeclarationType::ConstDeclaration, (specifierType == ImportSpecifierType::NamespaceImport) ? DeclarationImportType::ImportedNamespace : DeclarationImportType::Imported); - if (declarationResult != DeclarationResult::Valid) { - failIfTrueIfStrict(declarationResult & DeclarationResult::InvalidStrictMode, "Cannot declare an imported binding named ", localName->impl(), " in strict mode"); - if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) - internalFailWithMessage(false, "Cannot declare an imported binding name twice: '", localName->impl(), "'"); - } - - return context.createImportSpecifier(specifierLocation, *importedName, *localName); -} - -template <typename LexerType> -template <class TreeBuilder> TreeStatement Parser<LexerType>::parseImportDeclaration(TreeBuilder& context) -{ - // http://www.ecma-international.org/ecma-262/6.0/#sec-imports - ASSERT(match(IMPORT)); - JSTokenLocation importLocation(tokenLocation()); - next(); - - auto specifierList = context.createImportSpecifierList(); - - if (match(STRING)) { - // import ModuleSpecifier ; - auto moduleName = parseModuleName(context); - failIfFalse(moduleName, "Cannot parse the module name"); - failIfFalse(autoSemiColon(), "Expected a ';' following a targeted import declaration"); - return context.createImportDeclaration(importLocation, specifierList, moduleName); - } - - bool isFinishedParsingImport = false; - if (match(IDENT)) { - // ImportedDefaultBinding : - // ImportedBinding - auto specifier = parseImportClauseItem(context, ImportSpecifierType::DefaultImport); - failIfFalse(specifier, "Cannot parse the default import"); - context.appendImportSpecifier(specifierList, specifier); - if (match(COMMA)) - next(); - else - isFinishedParsingImport = true; - } - - if (!isFinishedParsingImport) { - if (match(TIMES)) { - // import NameSpaceImport FromClause ; - auto specifier = parseImportClauseItem(context, ImportSpecifierType::NamespaceImport); - failIfFalse(specifier, "Cannot parse the namespace import"); - context.appendImportSpecifier(specifierList, specifier); - } else if (match(OPENBRACE)) { - // NamedImports : - // { } - // { ImportsList } - // { ImportsList , } - next(); - - while (!match(CLOSEBRACE)) { - failIfFalse(matchIdentifierOrKeyword(), "Expected an imported name for the import declaration"); - auto specifier = parseImportClauseItem(context, ImportSpecifierType::NamedImport); - failIfFalse(specifier, "Cannot parse the named import"); - context.appendImportSpecifier(specifierList, specifier); - if (!consume(COMMA)) - break; - } - handleProductionOrFail(CLOSEBRACE, "}", "end", "import list"); - } else - failWithMessage("Expected namespace import or import list"); - } - - // FromClause : - // from ModuleSpecifier - - failIfFalse(matchContextualKeyword(m_vm->propertyNames->from), "Expected 'from' before imported module name"); - next(); - - auto moduleName = parseModuleName(context); - failIfFalse(moduleName, "Cannot parse the module name"); - failIfFalse(autoSemiColon(), "Expected a ';' following a targeted import declaration"); - - return context.createImportDeclaration(importLocation, specifierList, moduleName); -} - -template <typename LexerType> -template <class TreeBuilder> typename TreeBuilder::ExportSpecifier Parser<LexerType>::parseExportSpecifier(TreeBuilder& context, Vector<const Identifier*>& maybeLocalNames, bool& hasKeywordForLocalBindings) -{ - // ExportSpecifier : - // IdentifierName - // IdentifierName as IdentifierName - // http://www.ecma-international.org/ecma-262/6.0/#sec-exports - ASSERT(matchIdentifierOrKeyword()); - JSTokenLocation specifierLocation(tokenLocation()); - if (m_token.m_type & KeywordTokenFlag) - hasKeywordForLocalBindings = true; - const Identifier* localName = m_token.m_data.ident; - const Identifier* exportedName = localName; - next(); - - if (matchContextualKeyword(m_vm->propertyNames->as)) { - next(); - failIfFalse(matchIdentifierOrKeyword(), "Expected an exported name for the export declaration"); - exportedName = m_token.m_data.ident; - next(); - } - - semanticFailIfFalse(exportName(*exportedName), "Cannot export a duplicate name '", exportedName->impl(), "'"); - maybeLocalNames.append(localName); - return context.createExportSpecifier(specifierLocation, *localName, *exportedName); -} - -template <typename LexerType> -template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExportDeclaration(TreeBuilder& context) -{ - // http://www.ecma-international.org/ecma-262/6.0/#sec-exports - ASSERT(match(EXPORT)); - JSTokenLocation exportLocation(tokenLocation()); - next(); - - switch (m_token.m_type) { - case TIMES: { - // export * FromClause ; - next(); - - failIfFalse(matchContextualKeyword(m_vm->propertyNames->from), "Expected 'from' before exported module name"); - next(); - auto moduleName = parseModuleName(context); - failIfFalse(moduleName, "Cannot parse the 'from' clause"); - failIfFalse(autoSemiColon(), "Expected a ';' following a targeted export declaration"); - - return context.createExportAllDeclaration(exportLocation, moduleName); - } - - case DEFAULT: { - // export default HoistableDeclaration[Default] - // export default ClassDeclaration[Default] - // export default [lookahead not-in {function, class}] AssignmentExpression[In] ; - - next(); - - TreeStatement result = 0; - bool isFunctionOrClassDeclaration = false; - const Identifier* localName = nullptr; - SavePoint savePoint = createSavePoint(); - - bool startsWithFunction = match(FUNCTION); - if (startsWithFunction -#if ENABLE(ES6_CLASS_SYNTAX) - || match(CLASSTOKEN) -#endif - ) { - isFunctionOrClassDeclaration = true; - next(); - -#if ENABLE(ES6_GENERATORS) - // ES6 Generators - if (startsWithFunction && match(TIMES)) - next(); -#endif - if (match(IDENT)) - localName = m_token.m_data.ident; - restoreSavePoint(savePoint); - } - - if (localName) { - if (match(FUNCTION)) - result = parseFunctionDeclaration(context); -#if ENABLE(ES6_CLASS_SYNTAX) - else { - ASSERT(match(CLASSTOKEN)); - result = parseClassDeclaration(context); - } -#endif - } else { - // export default expr; - // - // It should be treated as the same to the following. - // - // const *default* = expr; - // export { *default* as default } - // - // In the above example, *default* is the invisible variable to the users. - // We use the private symbol to represent the name of this variable. - JSTokenLocation location(tokenLocation()); - JSTextPosition start = tokenStartPosition(); - TreeExpression expression = parseAssignmentExpression(context); - failIfFalse(expression, "Cannot parse expression"); - - DeclarationResultMask declarationResult = declareVariable(&m_vm->propertyNames->starDefaultPrivateName, DeclarationType::ConstDeclaration); - if (declarationResult & DeclarationResult::InvalidDuplicateDeclaration) - internalFailWithMessage(false, "Only one 'default' export is allowed"); - - TreeExpression assignment = context.createAssignResolve(location, m_vm->propertyNames->starDefaultPrivateName, expression, start, start, tokenEndPosition(), AssignmentContext::ConstDeclarationStatement); - result = context.createExprStatement(location, assignment, start, tokenEndPosition()); - if (!isFunctionOrClassDeclaration) - failIfFalse(autoSemiColon(), "Expected a ';' following a targeted export declaration"); - localName = &m_vm->propertyNames->starDefaultPrivateName; - } - failIfFalse(result, "Cannot parse the declaration"); - - semanticFailIfFalse(exportName(m_vm->propertyNames->defaultKeyword), "Only one 'default' export is allowed"); - currentScope()->moduleScopeData().exportBinding(*localName); - return context.createExportDefaultDeclaration(exportLocation, result, *localName); - } - - case OPENBRACE: { - // export ExportClause FromClause ; - // export ExportClause ; - // - // ExportClause : - // { } - // { ExportsList } - // { ExportsList , } - // - // ExportsList : - // ExportSpecifier - // ExportsList , ExportSpecifier - - next(); - - auto specifierList = context.createExportSpecifierList(); - Vector<const Identifier*> maybeLocalNames; - - bool hasKeywordForLocalBindings = false; - while (!match(CLOSEBRACE)) { - failIfFalse(matchIdentifierOrKeyword(), "Expected a variable name for the export declaration"); - auto specifier = parseExportSpecifier(context, maybeLocalNames, hasKeywordForLocalBindings); - failIfFalse(specifier, "Cannot parse the named export"); - context.appendExportSpecifier(specifierList, specifier); - if (!consume(COMMA)) - break; - } - handleProductionOrFail(CLOSEBRACE, "}", "end", "export list"); - - typename TreeBuilder::ModuleName moduleName = 0; - if (matchContextualKeyword(m_vm->propertyNames->from)) { - next(); - moduleName = parseModuleName(context); - failIfFalse(moduleName, "Cannot parse the 'from' clause"); - } - failIfFalse(autoSemiColon(), "Expected a ';' following a targeted export declaration"); - - if (!moduleName) { - semanticFailIfTrue(hasKeywordForLocalBindings, "Cannot use keyword as exported variable name"); - // Since this export declaration does not have module specifier part, it exports the local bindings. - // While the export declaration with module specifier does not have any effect on the current module's scope, - // the export named declaration without module specifier references the the local binding names. - // For example, - // export { A, B, C as D } from "mod" - // does not have effect on the current module's scope. But, - // export { A, B, C as D } - // will reference the current module's bindings. - for (const Identifier* localName : maybeLocalNames) - currentScope()->moduleScopeData().exportBinding(*localName); - } - - return context.createExportNamedDeclaration(exportLocation, specifierList, moduleName); - } - - default: { - // export VariableStatement - // export Declaration - TreeStatement result = 0; - switch (m_token.m_type) { - case VAR: - result = parseVariableDeclaration(context, DeclarationType::VarDeclaration, ExportType::Exported); - break; - - case CONSTTOKEN: - result = parseVariableDeclaration(context, DeclarationType::ConstDeclaration, ExportType::Exported); - break; - - case LET: - result = parseVariableDeclaration(context, DeclarationType::LetDeclaration, ExportType::Exported); - break; - - case FUNCTION: - result = parseFunctionDeclaration(context, ExportType::Exported); - break; - -#if ENABLE(ES6_CLASS_SYNTAX) - case CLASSTOKEN: - result = parseClassDeclaration(context, ExportType::Exported); - break; -#endif - - default: - failWithMessage("Expected either a declaration or a variable statement"); - break; - } - failIfFalse(result, "Cannot parse the declaration"); - return context.createExportLocalDeclaration(exportLocation, result); - } - } - - RELEASE_ASSERT_NOT_REACHED(); - return 0; -} - -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"); - context.setEndOffset(node, m_lastTokenEndPosition.offset); if (!match(COMMA)) return node; next(); - m_parserState.nonTrivialExpressionCount++; - m_parserState.nonLHSCount++; + m_nonTrivialExpressionCount++; + m_nonLHSCount++; TreeExpression right = parseAssignmentExpression(context); failIfFalse(right, "Cannot parse expression in a comma expression"); - context.setEndOffset(right, m_lastTokenEndPosition.offset); - typename TreeBuilder::Comma head = context.createCommaExpr(location, node); - typename TreeBuilder::Comma tail = context.appendToCommaExpr(location, head, head, right); + 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.setEndOffset(right, m_lastTokenEndPosition.offset); - tail = context.appendToCommaExpr(location, head, tail, right); + context.appendToComma(commaNode, right); } - context.setEndOffset(head, m_lastTokenEndPosition.offset); - return head; -} - -template <typename LexerType> -template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpressionOrPropagateErrorClass(TreeBuilder& context) -{ - ExpressionErrorClassifier classifier(this); - auto assignment = parseAssignmentExpression(context, classifier); - if (!assignment) - classifier.propagateExpressionErrorClass(); - return assignment; + return commaNode; } template <typename LexerType> template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpression(TreeBuilder& context) { - ExpressionErrorClassifier classifier(this); - return parseAssignmentExpression(context, classifier); -} - -template <typename LexerType> -template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmentExpression(TreeBuilder& context, ExpressionErrorClassifier& classifier) -{ - ASSERT(!hasError()); - failIfStackOverflow(); JSTextPosition start = tokenStartPosition(); JSTokenLocation location(tokenLocation()); - int initialAssignmentCount = m_parserState.assignmentCount; - int initialNonLHSCount = m_parserState.nonLHSCount; - bool maybeAssignmentPattern = match(OPENBRACE) || match(OPENBRACKET); - SavePoint savePoint = createSavePoint(); - -#if ENABLE(ES6_GENERATORS) - if (match(YIELD) && !isYIELDMaskedAsIDENT(currentScope()->isGenerator())) - return parseYieldExpression(context); -#endif - -#if ENABLE(ES6_ARROWFUNCTION_SYNTAX) - if (isArrowFunctionParameters()) - return parseArrowFunctionExpression(context); -#endif - - TreeExpression lhs = parseConditionalExpression(context); - - if (!lhs && (!maybeAssignmentPattern || !classifier.indicatesPossiblePattern())) - propagateError(); - - if (maybeAssignmentPattern && (!lhs || (context.isObjectOrArrayLiteral(lhs) && match(EQUAL)))) { - String expressionError = m_errorMessage; - SavePoint expressionErrorLocation = createSavePointForError(); + 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); - auto pattern = tryParseDestructuringPatternExpression(context, AssignmentContext::AssignmentExpression); - if (classifier.indicatesPossiblePattern() && (!pattern || !match(EQUAL))) - restoreSavePointAndFail(expressionErrorLocation, expressionError); - failIfFalse(pattern, "Cannot parse assignment pattern"); - consumeOrFail(EQUAL, "Expected '=' following assignment pattern"); - auto rhs = parseAssignmentExpression(context); - if (!rhs) - propagateError(); - return context.createDestructuringAssignment(location, pattern, rhs); } - + TreeExpression lhs = parseConditionalExpression(context); failIfFalse(lhs, "Cannot parse expression"); - if (initialNonLHSCount != m_parserState.nonLHSCount) { + 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"); @@ -3018,21 +1562,21 @@ template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmen default: goto end; } - m_parserState.nonTrivialExpressionCount++; + m_nonTrivialExpressionCount++; hadAssignment = true; - context.assignmentStackAppend(assignmentStack, lhs, start, tokenStartPosition(), m_parserState.assignmentCount, op); + context.assignmentStackAppend(assignmentStack, lhs, start, tokenStartPosition(), m_assignmentCount, op); start = tokenStartPosition(); - m_parserState.assignmentCount++; + m_assignmentCount++; next(TreeBuilder::DontBuildStrings); - if (strictMode() && m_parserState.lastIdentifier && context.isResolve(lhs)) { - failIfTrueIfStrict(m_vm->propertyNames->eval == *m_parserState.lastIdentifier, "Cannot modify 'eval' in strict mode"); - failIfTrueIfStrict(m_vm->propertyNames->arguments == *m_parserState.lastIdentifier, "Cannot modify 'arguments' in strict mode"); - declareWrite(m_parserState.lastIdentifier); - m_parserState.lastIdentifier = 0; + 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_parserState.nonLHSCount) { + 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; @@ -3040,51 +1584,18 @@ template <typename TreeBuilder> TreeExpression Parser<LexerType>::parseAssignmen } end: if (hadAssignment) - m_parserState.nonLHSCount++; + m_nonLHSCount++; if (!TreeBuilder::CreatesAST) return lhs; while (assignmentStack) - lhs = context.createAssignment(location, assignmentStack, lhs, initialAssignmentCount, m_parserState.assignmentCount, lastTokenEndPosition()); + lhs = context.createAssignment(location, assignmentStack, lhs, initialAssignmentCount, m_assignmentCount, lastTokenEndPosition()); return lhs; } template <typename LexerType> -template <class TreeBuilder> TreeExpression Parser<LexerType>::parseYieldExpression(TreeBuilder& context) -{ - // YieldExpression[In] : - // yield - // yield [no LineTerminator here] AssignmentExpression[?In, Yield] - // yield [no LineTerminator here] * AssignmentExpression[?In, Yield] - - // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions - failIfFalse(currentScope()->isGenerator(), "Cannot use yield expression out of generator"); - - // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors - failIfTrue(m_parserState.functionParsePhase == FunctionParsePhase::Parameters, "Cannot use yield expression within parameters"); - - JSTokenLocation location(tokenLocation()); - JSTextPosition divotStart = tokenStartPosition(); - ASSERT(match(YIELD)); - SavePoint savePoint = createSavePoint(); - next(); - if (m_lexer->prevTerminator()) - return context.createYield(location); - - bool delegate = consume(TIMES); - JSTextPosition argumentStart = tokenStartPosition(); - TreeExpression argument = parseAssignmentExpression(context); - if (!argument) { - restoreSavePoint(savePoint); - next(); - return context.createYield(location); - } - return context.createYield(location, argument, delegate, divotStart, argumentStart, lastTokenEndPosition()); -} - -template <typename LexerType> template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalExpression(TreeBuilder& context) { JSTokenLocation location(tokenLocation()); @@ -3092,17 +1603,15 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalE failIfFalse(cond, "Cannot parse expression"); if (!match(QUESTION)) return cond; - m_parserState.nonTrivialExpressionCount++; - m_parserState.nonLHSCount++; + m_nonTrivialExpressionCount++; + m_nonLHSCount++; next(TreeBuilder::DontBuildStrings); TreeExpression lhs = parseAssignmentExpression(context); failIfFalse(lhs, "Cannot parse left hand side of ternary operator"); - context.setEndOffset(lhs, m_lastTokenEndPosition.offset); consumeOrFailWithFlags(COLON, TreeBuilder::DontBuildStrings, "Expected ':' in ternary operator"); TreeExpression rhs = parseAssignmentExpression(context); failIfFalse(rhs, "Cannot parse right hand side of ternary operator"); - context.setEndOffset(rhs, m_lastTokenEndPosition.offset); return context.createConditionalExpr(location, cond, lhs, rhs); } @@ -3122,22 +1631,23 @@ int Parser<LexerType>::isBinaryOperator(JSTokenType token) 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_parserState.assignmentCount; + int initialAssignments = m_assignmentCount; TreeExpression current = parseUnaryExpression(context); failIfFalse(current, "Cannot parse expression"); - context.appendBinaryExpressionInfo(operandStackDepth, current, exprStart, lastTokenEndPosition(), lastTokenEndPosition(), initialAssignments != m_parserState.assignmentCount); + context.appendBinaryExpressionInfo(operandStackDepth, current, exprStart, lastTokenEndPosition(), lastTokenEndPosition(), initialAssignments != m_assignmentCount); int precedence = isBinaryOperator(m_token.m_type); if (!precedence) break; - m_parserState.nonTrivialExpressionCount++; - m_parserState.nonLHSCount++; + m_nonTrivialExpressionCount++; + m_nonLHSCount++; int operatorToken = m_token.m_type; next(TreeBuilder::DontBuildStrings); @@ -3168,11 +1678,6 @@ template <typename LexerType> template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeBuilder& context, bool complete) { bool wasIdent = false; - bool isGenerator = false; -#if ENABLE(ES6_GENERATORS) - if (consume(TIMES)) - isGenerator = true; -#endif switch (m_token.m_type) { namedProperty: case IDENT: @@ -3180,40 +1685,25 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB FALLTHROUGH; case STRING: { const Identifier* ident = m_token.m_data.ident; - unsigned getterOrSetterStartOffset = tokenStart(); - if (complete || (wasIdent && !isGenerator && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set))) + if (complete || (wasIdent && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set))) nextExpectIdentifier(LexerFlagsIgnoreReservedWords); else nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords); - - if (!isGenerator && match(COLON)) { + + if (match(COLON)) { next(); - TreeExpression node = parseAssignmentExpressionOrPropagateErrorClass(context); + TreeExpression node = parseAssignmentExpression(context); failIfFalse(node, "Cannot parse expression for property declaration"); - context.setEndOffset(node, m_lexer->currentOffset()); - return context.createProperty(ident, node, PropertyNode::Constant, PropertyNode::Unknown, complete); + return context.createProperty(ident, node, PropertyNode::Constant, complete); } - - if (match(OPENPAREN)) { - auto method = parsePropertyMethod(context, ident, isGenerator); - propagateError(); - return context.createProperty(ident, method, PropertyNode::Constant, PropertyNode::KnownDirect, complete); - } - failIfTrue(isGenerator, "Expected a parenthesis for argument list"); - failIfFalse(wasIdent, "Expected an identifier as property name"); - - if (match(COMMA) || match(CLOSEBRACE)) { - JSTextPosition start = tokenStartPosition(); - JSTokenLocation location(tokenLocation()); - currentScope()->useVariable(ident, m_vm->propertyNames->eval == *ident); - TreeExpression node = context.createResolve(location, *ident, start, lastTokenEndPosition()); - return context.createProperty(ident, node, static_cast<PropertyNode::Type>(PropertyNode::Constant | PropertyNode::Shorthand), PropertyNode::KnownDirect, complete); - } - - if (match(EQUAL)) // CoverInitializedName is exclusive to BindingPattern and AssignmentPattern - classifyExpressionError(ErrorIndicatesPattern); - + 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; @@ -3221,45 +1711,45 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB type = PropertyNode::Setter; else failWithMessage("Expected a ':' following the property name '", ident->impl(), "'"); - return parseGetterSetter(context, complete, type, getterOrSetterStartOffset); + 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 DOUBLE: - case INTEGER: { + case NUMBER: { double propertyName = m_token.m_data.doubleValue; next(); - - if (match(OPENPAREN)) { - const Identifier& ident = m_parserArena.identifierArena().makeNumericIdentifier(const_cast<VM*>(m_vm), propertyName); - auto method = parsePropertyMethod(context, &ident, isGenerator); - propagateError(); - return context.createProperty(&ident, method, PropertyNode::Constant, PropertyNode::Unknown, complete); - } - failIfTrue(isGenerator, "Expected a parenthesis for argument list"); - consumeOrFail(COLON, "Expected ':' after property name"); TreeExpression node = parseAssignmentExpression(context); failIfFalse(node, "Cannot parse expression for property declaration"); - context.setEndOffset(node, m_lexer->currentOffset()); - return context.createProperty(const_cast<VM*>(m_vm), m_parserArena, propertyName, node, PropertyNode::Constant, PropertyNode::Unknown, complete); + return context.createProperty(const_cast<VM*>(m_vm), propertyName, node, PropertyNode::Constant, complete); } case OPENBRACKET: { next(); - auto propertyName = parseAssignmentExpression(context); + auto propertyName = parseExpression(context); failIfFalse(propertyName, "Cannot parse computed property name"); + handleProductionOrFail(CLOSEBRACKET, "]", "end", "computed property name"); - - if (match(OPENPAREN)) { - auto method = parsePropertyMethod(context, &m_vm->propertyNames->nullIdentifier, isGenerator); - propagateError(); - return context.createProperty(propertyName, method, static_cast<PropertyNode::Type>(PropertyNode::Constant | PropertyNode::Computed), PropertyNode::KnownDirect, complete); - } - failIfTrue(isGenerator, "Expected a parenthesis for argument list"); - consumeOrFail(COLON, "Expected ':' after property name"); TreeExpression node = parseAssignmentExpression(context); failIfFalse(node, "Cannot parse expression for property declaration"); - context.setEndOffset(node, m_lexer->currentOffset()); - return context.createProperty(propertyName, node, static_cast<PropertyNode::Type>(PropertyNode::Constant | PropertyNode::Computed), PropertyNode::Unknown, complete); + return context.createProperty(const_cast<VM*>(m_vm), propertyName, node, PropertyNode::Constant, complete); } default: failIfFalse(m_token.m_type & KeywordTokenFlag, "Expected a property name"); @@ -3268,85 +1758,14 @@ template <class TreeBuilder> TreeProperty Parser<LexerType>::parseProperty(TreeB } template <typename LexerType> -template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator) -{ - JSTokenLocation methodLocation(tokenLocation()); - unsigned methodStart = tokenStart(); - ParserFunctionInfo<TreeBuilder> methodInfo; - SourceParseMode parseMode = isGenerator ? SourceParseMode::GeneratorWrapperFunctionMode : SourceParseMode::MethodMode; - failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, parseMode, false, ConstructorKind::None, SuperBinding::NotNeeded, methodStart, methodInfo, FunctionDefinitionType::Method)), "Cannot parse this method"); - methodInfo.name = methodName; - return context.createFunctionExpr(methodLocation, methodInfo); -} - -template <typename LexerType> -template <class TreeBuilder> TreeProperty Parser<LexerType>::parseGetterSetter(TreeBuilder& context, bool strict, PropertyNode::Type type, unsigned getterOrSetterStartOffset, - ConstructorKind constructorKind, SuperBinding superBinding) -{ - const Identifier* stringPropertyName = 0; - double numericPropertyName = 0; - TreeExpression computedPropertyName = 0; - - JSTokenLocation location(tokenLocation()); - - if (matchSpecIdentifier() || match(STRING) || m_token.m_type & KeywordTokenFlag) { - stringPropertyName = m_token.m_data.ident; - semanticFailIfTrue(superBinding == SuperBinding::Needed && *stringPropertyName == m_vm->propertyNames->prototype, - "Cannot declare a static method named 'prototype'"); - semanticFailIfTrue(superBinding == SuperBinding::Needed && *stringPropertyName == m_vm->propertyNames->constructor, - "Cannot declare a getter or setter named 'constructor'"); - next(); - } else if (match(DOUBLE) || match(INTEGER)) { - numericPropertyName = m_token.m_data.doubleValue; - next(); - } else if (match(OPENBRACKET)) { - next(); - computedPropertyName = parseAssignmentExpression(context); - failIfFalse(computedPropertyName, "Cannot parse computed property name"); - handleProductionOrFail(CLOSEBRACKET, "]", "end", "computed property name"); - } else - failDueToUnexpectedToken(); - - ParserFunctionInfo<TreeBuilder> info; - if (type & PropertyNode::Getter) { - failIfFalse(match(OPENPAREN), "Expected a parameter list for getter definition"); - failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SourceParseMode::GetterMode, false, constructorKind, superBinding, getterOrSetterStartOffset, info, FunctionDefinitionType::Method)), "Cannot parse getter definition"); - } else { - failIfFalse(match(OPENPAREN), "Expected a parameter list for setter definition"); - failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SourceParseMode::SetterMode, false, constructorKind, superBinding, getterOrSetterStartOffset, info, FunctionDefinitionType::Method)), "Cannot parse setter definition"); - } - - if (stringPropertyName) - return context.createGetterOrSetterProperty(location, type, strict, stringPropertyName, info, superBinding); - - if (computedPropertyName) - return context.createGetterOrSetterProperty(location, static_cast<PropertyNode::Type>(type | PropertyNode::Computed), strict, computedPropertyName, info, superBinding); - - return context.createGetterOrSetterProperty(const_cast<VM*>(m_vm), m_parserArena, location, type, strict, numericPropertyName, info, superBinding); -} - -template <typename LexerType> -template <class TreeBuilder> bool Parser<LexerType>::shouldCheckPropertyForUnderscoreProtoDuplicate(TreeBuilder& context, const TreeProperty& property) -{ - if (m_syntaxAlreadyValidated) - return false; - - if (!context.getName(property)) - return false; - - // A Constant property that is not a Computed or Shorthand Constant property. - return context.getType(property) == PropertyNode::Constant; -} - -template <typename LexerType> template <class TreeBuilder> TreeExpression Parser<LexerType>::parseObjectLiteral(TreeBuilder& context) { - SavePoint savePoint = createSavePoint(); + auto savePoint = createSavePoint(); consumeOrFailWithFlags(OPENBRACE, TreeBuilder::DontBuildStrings, "Expected opening '{' at the start of an object literal"); + JSTokenLocation location(tokenLocation()); - int oldNonLHSCount = m_parserState.nonLHSCount; - - JSTokenLocation location(tokenLocation()); + int oldNonLHSCount = m_nonLHSCount; + if (match(CLOSEBRACE)) { next(); return context.createObjectLiteral(location); @@ -3354,42 +1773,31 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseObjectLitera TreeProperty property = parseProperty(context, false); failIfFalse(property, "Cannot parse object literal property"); - - if (!m_syntaxAlreadyValidated && context.getType(property) & (PropertyNode::Getter | PropertyNode::Setter)) { + if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) { restoreSavePoint(savePoint); return parseStrictObjectLiteral(context); } - - bool seenUnderscoreProto = false; - if (shouldCheckPropertyForUnderscoreProtoDuplicate(context, property)) - seenUnderscoreProto = *context.getName(property) == m_vm->propertyNames->underscoreProto; - 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::Getter | PropertyNode::Setter)) { + if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) { restoreSavePoint(savePoint); return parseStrictObjectLiteral(context); } - if (shouldCheckPropertyForUnderscoreProtoDuplicate(context, property)) { - if (*context.getName(property) == m_vm->propertyNames->underscoreProto) { - semanticFailIfTrue(seenUnderscoreProto, "Attempted to redefine __proto__ property"); - seenUnderscoreProto = true; - } - } tail = context.createPropertyList(propertyLocation, property, tail); } location = tokenLocation(); handleProductionOrFail(CLOSEBRACE, "}", "end", "object literal"); - m_parserState.nonLHSCount = oldNonLHSCount; + m_nonLHSCount = oldNonLHSCount; return context.createObjectLiteral(location, propertyList); } @@ -3399,7 +1807,7 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseStrictObject { consumeOrFail(OPENBRACE, "Expected opening '{' at the start of an object literal"); - int oldNonLHSCount = m_parserState.nonLHSCount; + int oldNonLHSCount = m_nonLHSCount; JSTokenLocation location(tokenLocation()); if (match(CLOSEBRACE)) { @@ -3409,24 +1817,30 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseStrictObject TreeProperty property = parseProperty(context, true); failIfFalse(property, "Cannot parse object literal property"); - - bool seenUnderscoreProto = false; - if (shouldCheckPropertyForUnderscoreProtoDuplicate(context, property)) - seenUnderscoreProto = *context.getName(property) == m_vm->propertyNames->underscoreProto; - + + 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 (shouldCheckPropertyForUnderscoreProtoDuplicate(context, property)) { - if (*context.getName(property) == m_vm->propertyNames->underscoreProto) { - semanticFailIfTrue(seenUnderscoreProto, "Attempted to redefine __proto__ property"); - seenUnderscoreProto = true; + 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); @@ -3435,7 +1849,7 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseStrictObject location = tokenLocation(); handleProductionOrFail(CLOSEBRACE, "}", "end", "object literal"); - m_parserState.nonLHSCount = oldNonLHSCount; + m_nonLHSCount = oldNonLHSCount; return context.createObjectLiteral(location, propertyList); } @@ -3445,7 +1859,7 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrayLiteral { consumeOrFailWithFlags(OPENBRACKET, TreeBuilder::DontBuildStrings, "Expected an opening '[' at the beginning of an array literal"); - int oldNonLHSCount = m_parserState.nonLHSCount; + int oldNonLHSCount = m_nonLHSCount; int elisions = 0; while (match(COMMA)) { @@ -3464,11 +1878,11 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrayLiteral auto start = m_token.m_startPosition; auto divot = m_token.m_endPosition; next(); - auto spreadExpr = parseAssignmentExpressionOrPropagateErrorClass(context); + auto spreadExpr = parseAssignmentExpression(context); failIfFalse(spreadExpr, "Cannot parse subject of a spread operation"); elem = context.createSpreadExpression(spreadLocation, spreadExpr, start, divot, m_lastTokenEndPosition); } else - elem = parseAssignmentExpressionOrPropagateErrorClass(context); + elem = parseAssignmentExpression(context); failIfFalse(elem, "Cannot parse array literal element"); typename TreeBuilder::ElementList elementList = context.createElementList(elisions, elem); typename TreeBuilder::ElementList tail = elementList; @@ -3492,13 +1906,13 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrayLiteral auto start = m_token.m_startPosition; auto divot = m_token.m_endPosition; next(); - TreeExpression elem = parseAssignmentExpressionOrPropagateErrorClass(context); + 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 = parseAssignmentExpressionOrPropagateErrorClass(context); + TreeExpression elem = parseAssignmentExpression(context); failIfFalse(elem, "Cannot parse array literal element"); tail = context.createElementList(tail, elisions, elem); } @@ -3509,100 +1923,16 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrayLiteral semanticFail("The '...' operator should come before a target expression"); } - m_parserState.nonLHSCount = oldNonLHSCount; + m_nonLHSCount = oldNonLHSCount; return context.createArray(location, elementList); } template <typename LexerType> -template <class TreeBuilder> TreeExpression Parser<LexerType>::parseFunctionExpression(TreeBuilder& context) -{ - ASSERT(match(FUNCTION)); - JSTokenLocation location(tokenLocation()); - unsigned functionKeywordStart = tokenStart(); - next(); - ParserFunctionInfo<TreeBuilder> functionInfo; - functionInfo.name = &m_vm->propertyNames->nullIdentifier; - SourceParseMode parseMode = SourceParseMode::NormalFunctionMode; -#if ENABLE(ES6_GENERATORS) - if (consume(TIMES)) - parseMode = SourceParseMode::GeneratorWrapperFunctionMode; -#endif - failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, parseMode, false, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, functionInfo, FunctionDefinitionType::Expression)), "Cannot parse function expression"); - return context.createFunctionExpr(location, functionInfo); -} - -template <typename LexerType> -template <class TreeBuilder> typename TreeBuilder::TemplateString Parser<LexerType>::parseTemplateString(TreeBuilder& context, bool isTemplateHead, typename LexerType::RawStringsBuildMode rawStringsBuildMode, bool& elementIsTail) -{ - if (!isTemplateHead) { - matchOrFail(CLOSEBRACE, "Expected a closing '}' following an expression in template literal"); - // Re-scan the token to recognize it as Template Element. - m_token.m_type = m_lexer->scanTrailingTemplateString(&m_token, rawStringsBuildMode); - } - matchOrFail(TEMPLATE, "Expected an template element"); - const Identifier* cooked = m_token.m_data.cooked; - const Identifier* raw = m_token.m_data.raw; - elementIsTail = m_token.m_data.isTail; - JSTokenLocation location(tokenLocation()); - next(); - return context.createTemplateString(location, *cooked, *raw); -} - -template <typename LexerType> -template <class TreeBuilder> typename TreeBuilder::TemplateLiteral Parser<LexerType>::parseTemplateLiteral(TreeBuilder& context, typename LexerType::RawStringsBuildMode rawStringsBuildMode) -{ - JSTokenLocation location(tokenLocation()); - bool elementIsTail = false; - - auto headTemplateString = parseTemplateString(context, true, rawStringsBuildMode, elementIsTail); - failIfFalse(headTemplateString, "Cannot parse head template element"); - - typename TreeBuilder::TemplateStringList templateStringList = context.createTemplateStringList(headTemplateString); - typename TreeBuilder::TemplateStringList templateStringTail = templateStringList; - - if (elementIsTail) - return context.createTemplateLiteral(location, templateStringList); - - failIfTrue(match(CLOSEBRACE), "Template literal expression cannot be empty"); - TreeExpression expression = parseExpression(context); - failIfFalse(expression, "Cannot parse expression in template literal"); - - typename TreeBuilder::TemplateExpressionList templateExpressionList = context.createTemplateExpressionList(expression); - typename TreeBuilder::TemplateExpressionList templateExpressionTail = templateExpressionList; - - auto templateString = parseTemplateString(context, false, rawStringsBuildMode, elementIsTail); - failIfFalse(templateString, "Cannot parse template element"); - templateStringTail = context.createTemplateStringList(templateStringTail, templateString); - - while (!elementIsTail) { - failIfTrue(match(CLOSEBRACE), "Template literal expression cannot be empty"); - TreeExpression expression = parseExpression(context); - failIfFalse(expression, "Cannot parse expression in template literal"); - - templateExpressionTail = context.createTemplateExpressionList(templateExpressionTail, expression); - - auto templateString = parseTemplateString(context, false, rawStringsBuildMode, elementIsTail); - failIfFalse(templateString, "Cannot parse template element"); - templateStringTail = context.createTemplateStringList(templateStringTail, templateString); - } - - return context.createTemplateLiteral(location, templateStringList, templateExpressionList); -} - -template <typename LexerType> template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpression(TreeBuilder& context) { failIfStackOverflow(); switch (m_token.m_type) { - case FUNCTION: - return parseFunctionExpression(context); -#if ENABLE(ES6_CLASS_SYNTAX) - case CLASSTOKEN: { - ParserClassInfo<TreeBuilder> info; - return parseClass(context, FunctionNoRequirements, info); - } -#endif case OPENBRACE: if (strictMode()) return parseStrictObjectLiteral(context); @@ -3611,26 +1941,25 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpre return parseArrayLiteral(context); case OPENPAREN: { next(); - int oldNonLHSCount = m_parserState.nonLHSCount; + int oldNonLHSCount = m_nonLHSCount; TreeExpression result = parseExpression(context); - m_parserState.nonLHSCount = oldNonLHSCount; + m_nonLHSCount = oldNonLHSCount; handleProductionOrFail(CLOSEPAREN, ")", "end", "compound expression"); return result; } case THISTOKEN: { JSTokenLocation location(tokenLocation()); next(); - return context.createThisExpr(location, m_thisTDZMode); + return context.thisExpr(location); } case IDENT: { - identifierExpression: JSTextPosition start = tokenStartPosition(); const Identifier* ident = m_token.m_data.ident; JSTokenLocation location(tokenLocation()); next(); currentScope()->useVariable(ident, m_vm->propertyNames->eval == *ident); - m_parserState.lastIdentifier = ident; - return context.createResolve(location, *ident, start, lastTokenEndPosition()); + m_lastIdentifier = ident; + return context.createResolve(location, ident, start); } case STRING: { const Identifier* ident = m_token.m_data.ident; @@ -3638,17 +1967,11 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpre next(); return context.createString(location, ident); } - case DOUBLE: { - double d = m_token.m_data.doubleValue; - JSTokenLocation location(tokenLocation()); - next(); - return context.createDoubleExpr(location, d); - } - case INTEGER: { + case NUMBER: { double d = m_token.m_data.doubleValue; JSTokenLocation location(tokenLocation()); next(); - return context.createIntegerExpr(location, d); + return context.createNumberExpr(location, d); } case NULLTOKEN: { JSTokenLocation location(tokenLocation()); @@ -3685,25 +2008,13 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parsePrimaryExpre } return re; } -#if ENABLE(ES6_TEMPLATE_LITERAL_SYNTAX) - case TEMPLATE: - return parseTemplateLiteral(context, LexerType::RawStringsBuildMode::DontBuildRawStrings); -#endif - case YIELD: - if (!strictMode() && !currentScope()->isGenerator()) - goto identifierExpression; - failDueToUnexpectedToken(); - case LET: - if (!strictMode()) - goto identifierExpression; - FALLTHROUGH; default: failDueToUnexpectedToken(); } } template <typename LexerType> -template <class TreeBuilder> TreeArguments Parser<LexerType>::parseArguments(TreeBuilder& context) +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()); @@ -3711,146 +2022,105 @@ template <class TreeBuilder> TreeArguments Parser<LexerType>::parseArguments(Tre next(TreeBuilder::DontBuildStrings); return context.createArguments(); } - auto argumentsStart = m_token.m_startPosition; - auto argumentsDivot = m_token.m_endPosition; - - ArgumentType argType = ArgumentType::Normal; - TreeExpression firstArg = parseArgument(context, argType); + 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"); - semanticFailIfTrue(match(DOTDOTDOT), "The '...' operator should come before the target expression"); - - bool hasSpread = false; - if (argType == ArgumentType::Spread) - hasSpread = true; + TreeArgumentsList argList = context.createArgumentsList(location, firstArg); TreeArgumentsList tail = argList; - while (match(COMMA)) { JSTokenLocation argumentLocation(tokenLocation()); next(TreeBuilder::DontBuildStrings); - - TreeExpression arg = parseArgument(context, argType); - propagateError(); - semanticFailIfTrue(match(DOTDOTDOT), "The '...' operator should come before the target expression"); - - if (argType == ArgumentType::Spread) - hasSpread = true; - + 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"); - if (hasSpread) { - TreeExpression spreadArray = context.createSpreadExpression(location, context.createArray(location, context.createElementList(argList)), argumentsStart, argumentsDivot, m_lastTokenEndPosition); - return context.createArguments(context.createArgumentsList(location, spreadArray)); - } - return context.createArguments(argList); } template <typename LexerType> -template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArgument(TreeBuilder& context, ArgumentType& type) -{ - if (UNLIKELY(match(DOTDOTDOT))) { - JSTokenLocation spreadLocation(tokenLocation()); - auto start = m_token.m_startPosition; - auto divot = m_token.m_endPosition; - next(); - TreeExpression spreadExpr = parseAssignmentExpression(context); - propagateError(); - auto end = m_lastTokenEndPosition; - type = ArgumentType::Spread; - return context.createSpreadExpression(spreadLocation, spreadExpr, start, divot, end); - } - - type = ArgumentType::Normal; - return parseAssignmentExpression(context); -} - -template <typename LexerType> template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpression(TreeBuilder& context) { TreeExpression base = 0; JSTextPosition expressionStart = tokenStartPosition(); int newCount = 0; - JSTokenLocation startLocation = tokenLocation(); JSTokenLocation location; while (match(NEW)) { next(); newCount++; } - -#if ENABLE(ES6_CLASS_SYNTAX) - bool baseIsSuper = match(SUPER); - semanticFailIfTrue(baseIsSuper && newCount, "Cannot use new with super"); -#else - bool baseIsSuper = false; -#endif - - bool baseIsNewTarget = false; - if (newCount && match(DOT)) { - next(); - if (match(IDENT)) { - const Identifier* ident = m_token.m_data.ident; - if (m_vm->propertyNames->target == *ident) { - semanticFailIfFalse(currentScope()->isFunction(), "new.target is only valid inside functions"); - baseIsNewTarget = true; - base = context.createNewTargetExpr(location); - newCount--; - next(); - } else - failWithMessage("\"new.\" can only followed with target"); - } else - failDueToUnexpectedToken(); - } - - if (baseIsSuper) { - semanticFailIfFalse(currentScope()->isFunction(), "super is only valid inside functions"); - base = context.createSuperExpr(location); + + 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(); - currentFunctionScope()->setNeedsSuperBinding(); - } else if (!baseIsNewTarget) + 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_parserState.nonTrivialExpressionCount++; + m_nonTrivialExpressionCount++; JSTextPosition expressionEnd = lastTokenEndPosition(); next(); - int nonLHSCount = m_parserState.nonLHSCount; - int initialAssignments = m_parserState.assignmentCount; + 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_parserState.assignmentCount, expressionStart, expressionEnd, tokenEndPosition()); + base = context.createBracketAccess(location, base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEndPosition()); handleProductionOrFail(CLOSEBRACKET, "]", "end", "subscript expression"); - m_parserState.nonLHSCount = nonLHSCount; + m_nonLHSCount = nonLHSCount; break; } case OPENPAREN: { - m_parserState.nonTrivialExpressionCount++; - int nonLHSCount = m_parserState.nonLHSCount; + m_nonTrivialExpressionCount++; + int nonLHSCount = m_nonLHSCount; if (newCount) { newCount--; JSTextPosition expressionEnd = lastTokenEndPosition(); - TreeArguments arguments = parseArguments(context); + TreeArguments arguments = parseArguments(context, DontAllowSpread); failIfFalse(arguments, "Cannot parse call arguments"); base = context.createNewExpr(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition()); } else { JSTextPosition expressionEnd = lastTokenEndPosition(); - TreeArguments arguments = parseArguments(context); + TreeArguments arguments = parseArguments(context, AllowSpread); failIfFalse(arguments, "Cannot parse call arguments"); - if (baseIsSuper) - currentFunctionScope()->setHasDirectSuper(); - base = context.makeFunctionCallNode(startLocation, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition()); + base = context.makeFunctionCallNode(location, base, arguments, expressionStart, expressionEnd, lastTokenEndPosition()); } - m_parserState.nonLHSCount = nonLHSCount; + m_nonLHSCount = nonLHSCount; break; } case DOT: { - m_parserState.nonTrivialExpressionCount++; + m_nonTrivialExpressionCount++; JSTextPosition expressionEnd = lastTokenEndPosition(); nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords); matchOrFail(IDENT, "Expected a property name after '.'"); @@ -3858,44 +2128,16 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres next(); break; } -#if ENABLE(ES6_TEMPLATE_LITERAL_SYNTAX) - case TEMPLATE: { - semanticFailIfTrue(baseIsSuper, "Cannot use super as tag for tagged templates"); - JSTextPosition expressionEnd = lastTokenEndPosition(); - int nonLHSCount = m_parserState.nonLHSCount; - typename TreeBuilder::TemplateLiteral templateLiteral = parseTemplateLiteral(context, LexerType::RawStringsBuildMode::BuildRawStrings); - failIfFalse(templateLiteral, "Cannot parse template literal"); - base = context.createTaggedTemplate(location, base, templateLiteral, expressionStart, expressionEnd, lastTokenEndPosition()); - m_parserState.nonLHSCount = nonLHSCount; - break; - } -#endif default: goto endMemberExpression; } - baseIsSuper = false; } endMemberExpression: - semanticFailIfTrue(baseIsSuper, "Cannot reference super"); while (newCount--) base = context.createNewExpr(location, base, expressionStart, lastTokenEndPosition()); return base; } -template <typename LexerType> -template <class TreeBuilder> TreeExpression Parser<LexerType>::parseArrowFunctionExpression(TreeBuilder& context) -{ - JSTokenLocation location; - - unsigned functionKeywordStart = tokenStart(); - location = tokenLocation(); - ParserFunctionInfo<TreeBuilder> info; - info.name = &m_vm->propertyNames->nullIdentifier; - failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SourceParseMode::ArrowFunctionMode, true, ConstructorKind::None, SuperBinding::NotNeeded, functionKeywordStart, info, FunctionDefinitionType::Expression)), "Cannot parse arrow function expression"); - - return context.createArrowFunctionExpr(location, info); -} - static const char* operatorString(bool prefix, unsigned tok) { switch (tok) { @@ -3956,10 +2198,10 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpress } } lastOperator = m_token.m_type; - m_parserState.nonLHSCount++; + m_nonLHSCount++; context.appendUnaryToken(tokenStackDepth, m_token.m_type, tokenStartPosition()); next(); - m_parserState.nonTrivialExpressionCount++; + m_nonTrivialExpressionCount++; } JSTextPosition subExprStart = tokenStartPosition(); ASSERT(subExprStart.offset >= subExprStart.lineStartOffset); @@ -3973,26 +2215,26 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpress bool isEvalOrArguments = false; if (strictMode() && !m_syntaxAlreadyValidated) { if (context.isResolve(expr)) - isEvalOrArguments = *m_parserState.lastIdentifier == m_vm->propertyNames->eval || *m_parserState.lastIdentifier == m_vm->propertyNames->arguments; + isEvalOrArguments = *m_lastIdentifier == m_vm->propertyNames->eval || *m_lastIdentifier == m_vm->propertyNames->arguments; } - failIfTrueIfStrict(isEvalOrArguments && modifiesExpr, "Cannot modify '", m_parserState.lastIdentifier->impl(), "' in strict mode"); + failIfTrueIfStrict(isEvalOrArguments && modifiesExpr, "Cannot modify '", m_lastIdentifier->impl(), "' in strict mode"); switch (m_token.m_type) { case PLUSPLUS: - m_parserState.nonTrivialExpressionCount++; - m_parserState.nonLHSCount++; + m_nonTrivialExpressionCount++; + m_nonLHSCount++; expr = context.makePostfixNode(location, expr, OpPlusPlus, subExprStart, lastTokenEndPosition(), tokenEndPosition()); - m_parserState.assignmentCount++; - failIfTrueIfStrict(isEvalOrArguments, "Cannot modify '", m_parserState.lastIdentifier->impl(), "' in strict mode"); + 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_parserState.nonTrivialExpressionCount++; - m_parserState.nonLHSCount++; + m_nonTrivialExpressionCount++; + m_nonLHSCount++; expr = context.makePostfixNode(location, expr, OpMinusMinus, subExprStart, lastTokenEndPosition(), tokenEndPosition()); - m_parserState.assignmentCount++; - failIfTrueIfStrict(isEvalOrArguments, "'", m_parserState.lastIdentifier->impl(), "' cannot be modified in strict mode"); + 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(); @@ -4025,12 +2267,12 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpress case PLUSPLUS: case AUTOPLUSPLUS: expr = context.makePrefixNode(location, expr, OpPlusPlus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end); - m_parserState.assignmentCount++; + m_assignmentCount++; break; case MINUSMINUS: case AUTOMINUSMINUS: expr = context.makePrefixNode(location, expr, OpMinusMinus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end); - m_parserState.assignmentCount++; + m_assignmentCount++; break; case TYPEOF: expr = context.makeTypeOfNode(location, expr); @@ -4039,7 +2281,7 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseUnaryExpress expr = context.createVoid(location, expr); break; case DELETETOKEN: - failIfTrueIfStrict(context.isResolve(expr), "Cannot delete unqualified property '", m_parserState.lastIdentifier->impl(), "' in strict mode"); + 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: @@ -4081,7 +2323,7 @@ template <typename LexerType> void Parser<LexerType>::printUnexpectedTokenText(W case INVALID_NUMERIC_LITERAL_ERRORTOK: out.print("Invalid numeric literal: '", getToken(), "'"); return; - case UNTERMINATED_OCTAL_NUMBER_ERRORTOK: + case INVALID_OCTAL_NUMBER_ERRORTOK: out.print("Invalid use of octal: '", getToken(), "'"); return; case INVALID_STRING_LITERAL_ERRORTOK: @@ -4093,8 +2335,7 @@ template <typename LexerType> void Parser<LexerType>::printUnexpectedTokenText(W case STRING: out.print("Unexpected string literal ", getToken()); return; - case INTEGER: - case DOUBLE: + case NUMBER: out.print("Unexpected number '", getToken(), "'"); return; @@ -4105,10 +2346,6 @@ template <typename LexerType> void Parser<LexerType>::printUnexpectedTokenText(W 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(), "'"); |