/*

* Copyright (C) 1999-2001 Harri Porten (porten@kde.org)

* Copyright (C) 2001 Peter Kelly (pmk@post.com)

* Copyright (C) 2003-2019 Apple Inc. All rights reserved.

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Library General Public

* License as published by the Free Software Foundation; either

* version 2 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Library General Public License for more details.

*

* You should have received a copy of the GNU Library General Public License

* along with this library; see the file COPYING.LIB. If not, write to

* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

* Boston, MA 02110-1301, USA.

*

*/

#pragma once

#include "ExecutableInfo.h"

#include "IterationStatus.h"

#include "Lexer.h"

#include "ModuleScopeData.h"

#include "Nodes.h"

#include "ParseHash.h"

#include "ParserArena.h"

#include "ParserError.h"

#include "ParserFunctionInfo.h"

#include "ParserTokens.h"

#include "SourceProvider.h"

#include "SourceProviderCache.h"

#include "SourceProviderCacheItem.h"

#include "VariableEnvironment.h"

#include <wtf/FixedVector.h>

#include <wtf/Forward.h>

#include <wtf/Noncopyable.h>

#include <wtf/RefPtr.h>

namespace JSC {

class FunctionMetadataNode;

class FunctionParameters;

class Identifier;

class VM;

class SourceCode;

class SyntaxChecker;

struct DebuggerParseData;

// Macros to make the more common TreeBuilder types a little less verbose

#define TreeStatement typename TreeBuilder::Statement

#define TreeExpression typename TreeBuilder::Expression

#define TreeFormalParameterList typename TreeBuilder::FormalParameterList

#define TreeSourceElements typename TreeBuilder::SourceElements

#define TreeClause typename TreeBuilder::Clause

#define TreeClauseList typename TreeBuilder::ClauseList

#define TreeArguments typename TreeBuilder::Arguments

#define TreeArgumentsList typename TreeBuilder::ArgumentsList

#define TreeFunctionBody typename TreeBuilder::FunctionBody

#define TreeClassExpression typename TreeBuilder::ClassExpression

#define TreeProperty typename TreeBuilder::Property

#define TreePropertyList typename TreeBuilder::PropertyList

#define TreeDestructuringPattern typename TreeBuilder::DestructuringPattern

COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);

enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };

enum FunctionBodyType { ArrowFunctionBodyExpression, ArrowFunctionBodyBlock, StandardFunctionBodyBlock };

enum class FunctionNameRequirements { None, Named, Unnamed };

enum class DestructuringKind {

DestructureToVariables,

DestructureToLet,

DestructureToConst,

DestructureToCatchParameters,

DestructureToParameters,

DestructureToExpressions

};

enum class DeclarationType {

VarDeclaration,

LetDeclaration,

ConstDeclaration

};

enum class DeclarationImportType {

Imported,

ImportedNamespace,

NotImported

};

enum DeclarationResult {

Valid = 0,

InvalidStrictMode = 1 << 0,

InvalidDuplicateDeclaration = 1 << 1,

InvalidPrivateStaticNonStatic = 1 << 2

};

typedef uint8_t DeclarationResultMask;

enum class DeclarationDefaultContext {

Standard,

ExportDefault,

};

enum class InferName {

Allowed,

Disallowed,

};

template <typename T> inline bool isEvalNode() { return false; }

template <> inline bool isEvalNode<EvalNode>() { return true; }

struct ScopeLabelInfo {

UniquedStringImpl* uid;

bool isLoop;

};

ALWAYS_INLINE static bool isArguments(const VM& vm, const Identifier* ident)

{

return vm.propertyNames->arguments == *ident;

}

ALWAYS_INLINE static bool isEval(const VM& vm, const Identifier* ident)

{

return vm.propertyNames->eval == *ident;

}

ALWAYS_INLINE static bool isEvalOrArgumentsIdentifier(const VM& vm, const Identifier* ident)

{

return isEval(vm, ident) || isArguments(vm, ident);

}

ALWAYS_INLINE static bool isIdentifierOrKeyword(const JSToken& token)

{

return token.m_type == IDENT || token.m_type & KeywordTokenFlag;

}

// "let", "yield", and "await" may be keywords or identifiers depending on context.

ALWAYS_INLINE static bool isContextualKeyword(const JSToken& token)

{

return token.m_type >= FirstContextualKeywordToken && token.m_type <= LastContextualKeywordToken;

}

JS_EXPORT_PRIVATE extern std::atomic<unsigned> globalParseCount;

struct Scope {

WTF_MAKE_NONCOPYABLE(Scope);

public:

Scope(const VM& vm, LexicalScopeFeatures lexicalScopeFeatures, bool isFunction, bool isGenerator, bool isArrowFunction, bool isAsyncFunction)

: m_vm(vm)

, m_shadowsArguments(false)

, m_usesEval(false)

, m_needsFullActivation(false)

, m_hasDirectSuper(false)

, m_needsSuperBinding(false)

, m_allowsVarDeclarations(true)

, m_allowsLexicalDeclarations(true)

, m_lexicalScopeFeatures(lexicalScopeFeatures)

, m_isFunction(isFunction)

, m_isGenerator(isGenerator)

, m_isGeneratorBoundary(false)

, m_isArrowFunction(isArrowFunction)

, m_isArrowFunctionBoundary(false)

, m_isAsyncFunction(isAsyncFunction)

, m_isAsyncFunctionBoundary(false)

, m_isLexicalScope(false)

, m_isGlobalCodeScope(false)

, m_isSimpleCatchParameterScope(false)

, m_isCatchBlockScope(false)

, m_isFunctionBoundary(false)

, m_isValidStrictMode(true)

, m_hasArguments(false)

, m_isEvalContext(false)

, m_hasNonSimpleParameterList(false)

, m_isClassScope(false)

, m_evalContextType(EvalContextType::None)

, m_constructorKind(static_cast<unsigned>(ConstructorKind::None))

, m_expectedSuperBinding(static_cast<unsigned>(SuperBinding::NotNeeded))

, m_loopDepth(0)

, m_switchDepth(0)

, m_innerArrowFunctionFeatures(0)

{

m_usedVariables.append(UniquedStringImplPtrSet());

}

Scope(Scope&&) = default;

void startSwitch() { m_switchDepth++; }

void endSwitch() { m_switchDepth--; }

void startLoop() { m_loopDepth++; }

void endLoop() { ASSERT(m_loopDepth); m_loopDepth--; }

bool inLoop() { return !!m_loopDepth; }

bool breakIsValid() { return m_loopDepth || m_switchDepth; }

bool continueIsValid() { return m_loopDepth; }

void pushLabel(const Identifier* label, bool isLoop)

{

if (!m_labels)

m_labels = makeUnique<LabelStack>();

m_labels->append(ScopeLabelInfo { label->impl(), isLoop });

}

void popLabel()

{

ASSERT(m_labels);

ASSERT(m_labels->size());

m_labels->removeLast();

}

ScopeLabelInfo* getLabel(const Identifier* label)

{

if (!m_labels)

return nullptr;

for (int i = m_labels->size(); i > 0; i--) {

if (m_labels->at(i - 1).uid == label->impl())

return &m_labels->at(i - 1);

}

return nullptr;

}

void setSourceParseMode(SourceParseMode mode)

{

switch (mode) {

case SourceParseMode::AsyncGeneratorBodyMode:

setIsAsyncGeneratorFunctionBody();

break;

case SourceParseMode::AsyncArrowFunctionBodyMode:

setIsAsyncArrowFunctionBody();

break;

case SourceParseMode::AsyncFunctionBodyMode:

setIsAsyncFunctionBody();

break;

case SourceParseMode::GeneratorBodyMode:

setIsGenerator();

break;

case SourceParseMode::GeneratorWrapperFunctionMode:

case SourceParseMode::GeneratorWrapperMethodMode:

setIsGeneratorFunction();

break;

case SourceParseMode::AsyncGeneratorWrapperMethodMode:

case SourceParseMode::AsyncGeneratorWrapperFunctionMode:

setIsAsyncGeneratorFunction();

break;

case SourceParseMode::NormalFunctionMode:

case SourceParseMode::GetterMode:

case SourceParseMode::SetterMode:

case SourceParseMode::MethodMode:

case SourceParseMode::ClassFieldInitializerMode:

setIsFunction();

break;

case SourceParseMode::ArrowFunctionMode:

setIsArrowFunction();

break;

case SourceParseMode::AsyncFunctionMode:

case SourceParseMode::AsyncMethodMode:

setIsAsyncFunction();

break;

case SourceParseMode::AsyncArrowFunctionMode:

setIsAsyncArrowFunction();

break;

case SourceParseMode::ProgramMode:

case SourceParseMode::ModuleAnalyzeMode:

case SourceParseMode::ModuleEvaluateMode:

break;

}

}

bool isFunction() const { return m_isFunction; }

bool isFunctionBoundary() const { return m_isFunctionBoundary; }

bool isGenerator() const { return m_isGenerator; }

bool isGeneratorBoundary() const { return m_isGeneratorBoundary; }

bool isAsyncFunction() const { return m_isAsyncFunction; }

bool isAsyncFunctionBoundary() const { return m_isAsyncFunctionBoundary; }

bool isPrivateNameScope() const { return m_isClassScope; }

bool isClassScope() const { return m_isClassScope; }

bool hasArguments() const { return m_hasArguments; }

void setIsGlobalCodeScope() { m_isGlobalCodeScope = true; }

bool isGlobalCodeScope() const { return m_isGlobalCodeScope; }

void setIsSimpleCatchParameterScope() { m_isSimpleCatchParameterScope = true; }

bool isSimpleCatchParameterScope() { return m_isSimpleCatchParameterScope; }

void setIsCatchBlockScope() { m_isCatchBlockScope = true; }

bool isCatchBlockScope() { return m_isCatchBlockScope; }

void setIsLexicalScope()

{

m_isLexicalScope = true;

m_allowsLexicalDeclarations = true;

}

void setIsPrivateNameScope()

{

// FIXME: Currently, isPrivateNameScope is an alias for isClassScope --- This is potentially misleading,

// particularly when parsing direct eval code which occurs within a class.

setIsClassScope();

}

void setIsClassScope()

{

m_isClassScope = true;

}

bool isLexicalScope() { return m_isLexicalScope; }

bool usesEval() { return m_usesEval; }

const HashSet<UniquedStringImpl*>& closedVariableCandidates() const { return m_closedVariableCandidates; }

VariableEnvironment& declaredVariables() { return m_declaredVariables; }

VariableEnvironment& lexicalVariables() { return m_lexicalVariables; }

void finalizeLexicalEnvironment()

{

if (m_usesEval || m_needsFullActivation)

m_lexicalVariables.markAllVariablesAsCaptured();

else

computeLexicallyCapturedVariablesAndPurgeCandidates();

}

VariableEnvironment takeLexicalEnvironment() { return WTFMove(m_lexicalVariables); }

VariableEnvironment takeDeclaredVariables() { return WTFMove(m_declaredVariables); }

void computeLexicallyCapturedVariablesAndPurgeCandidates()

{

// Because variables may be defined at any time in the range of a lexical scope, we must

// track lexical variables that might be captured. Then, when we're preparing to pop the top

// lexical scope off the stack, we should find which variables are truly captured, and which

// variable still may be captured in a parent scope.

if (m_lexicalVariables.size() && m_closedVariableCandidates.size()) {

for (UniquedStringImpl* impl : m_closedVariableCandidates)

m_lexicalVariables.markVariableAsCapturedIfDefined(impl);

}

// We can now purge values from the captured candidates because they're captured in this scope.

{

for (const auto& entry : m_lexicalVariables) {

if (entry.value.isCaptured())

m_closedVariableCandidates.remove(entry.key.get());

}

}

}

DeclarationResultMask declareCallee(const Identifier* ident)

{

auto addResult = m_declaredVariables.add(ident->impl());

// We want to track if callee is captured, but we don't want to act like it's a 'var'

// because that would cause the BytecodeGenerator to emit bad code.

addResult.iterator->value.clearIsVar();

DeclarationResultMask result = DeclarationResult::Valid;

if (isEvalOrArgumentsIdentifier(m_vm, ident))

result |= DeclarationResult::InvalidStrictMode;

return result;

}

DeclarationResultMask declareVariable(const Identifier* ident)

{

ASSERT(m_allowsVarDeclarations);

DeclarationResultMask result = DeclarationResult::Valid;

bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);

m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;

auto addResult = m_declaredVariables.add(ident->impl());

addResult.iterator->value.setIsVar();

if (!isValidStrictMode)

result |= DeclarationResult::InvalidStrictMode;

return result;

}

DeclarationResultMask declareFunction(const Identifier* ident, bool declareAsVar, bool isSloppyModeHoistingCandidate)

{

ASSERT(m_allowsVarDeclarations || m_allowsLexicalDeclarations);

DeclarationResultMask result = DeclarationResult::Valid;

bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);

if (!isValidStrictMode)

result |= DeclarationResult::InvalidStrictMode;

m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;

auto addResult = declareAsVar ? m_declaredVariables.add(ident->impl()) : m_lexicalVariables.add(ident->impl());

if (isSloppyModeHoistingCandidate)

addResult.iterator->value.setIsSloppyModeHoistingCandidate();

if (declareAsVar) {

addResult.iterator->value.setIsVar();

if (m_lexicalVariables.contains(ident->impl()))

result |= DeclarationResult::InvalidDuplicateDeclaration;

} else {

addResult.iterator->value.setIsLet();

ASSERT_WITH_MESSAGE(!m_declaredVariables.size(), "We should only declare a function as a lexically scoped variable in scopes where var declarations aren't allowed. I.e, in strict mode and not at the top-level scope of a function or program.");

if (!addResult.isNewEntry) {

if (!isSloppyModeHoistingCandidate || !addResult.iterator->value.isFunction())

result |= DeclarationResult::InvalidDuplicateDeclaration;

}

}

addResult.iterator->value.setIsFunction();

return result;

}

void addVariableBeingHoisted(const Identifier* ident)

{

ASSERT(!m_allowsVarDeclarations);

m_variablesBeingHoisted.add(ident->impl());

}

void addSloppyModeHoistableFunctionCandidate(const Identifier* ident)

{

ASSERT(m_allowsVarDeclarations);

m_sloppyModeHoistableFunctionCandidates.add(ident->impl());

}

void appendFunction(FunctionMetadataNode* node)

{

ASSERT(node);

m_functionDeclarations.append(node);

}

DeclarationStacks::FunctionStack takeFunctionDeclarations() { return WTFMove(m_functionDeclarations); }

DeclarationResultMask declareLexicalVariable(const Identifier* ident, bool isConstant, DeclarationImportType importType = DeclarationImportType::NotImported)

{

ASSERT(m_allowsLexicalDeclarations);

DeclarationResultMask result = DeclarationResult::Valid;

bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);

m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;

auto addResult = m_lexicalVariables.add(ident->impl());

if (isConstant)

addResult.iterator->value.setIsConst();

else

addResult.iterator->value.setIsLet();

if (importType == DeclarationImportType::Imported)

addResult.iterator->value.setIsImported();

else if (importType == DeclarationImportType::ImportedNamespace) {

addResult.iterator->value.setIsImported();

addResult.iterator->value.setIsImportedNamespace();

}

if (!addResult.isNewEntry || m_variablesBeingHoisted.contains(ident->impl()))

result |= DeclarationResult::InvalidDuplicateDeclaration;

if (!isValidStrictMode)

result |= DeclarationResult::InvalidStrictMode;

return result;

}

ALWAYS_INLINE bool hasDeclaredVariable(const Identifier& ident)

{

return hasDeclaredVariable(ident.impl());

}

bool hasDeclaredVariable(const RefPtr<UniquedStringImpl>& ident)

{

auto iter = m_declaredVariables.find(ident.get());

if (iter == m_declaredVariables.end())

return false;

VariableEnvironmentEntry entry = iter->value;

return entry.isVar(); // The callee isn't a "var".

}

ALWAYS_INLINE bool hasLexicallyDeclaredVariable(const Identifier& ident)

{

return hasLexicallyDeclaredVariable(ident.impl());

}

bool hasLexicallyDeclaredVariable(const RefPtr<UniquedStringImpl>& ident) const

{

return m_lexicalVariables.contains(ident.get());

}

bool hasPrivateName(const Identifier& ident)

{

return m_lexicalVariables.hasPrivateName(ident);

}

DeclarationResultMask declarePrivateMethod(const Identifier& ident, ClassElementTag tag)

{

ASSERT(m_allowsLexicalDeclarations);

DeclarationResultMask result = DeclarationResult::Valid;

bool addResult = tag == ClassElementTag::Static ? m_lexicalVariables.declareStaticPrivateMethod(ident) : m_lexicalVariables.declarePrivateMethod(ident);

if (!addResult) {

result |= DeclarationResult::InvalidDuplicateDeclaration;

return result;

}

return result;

}

enum class PrivateAccessorType { Setter, Getter };

DeclarationResultMask declarePrivateAccessor(const Identifier& ident, ClassElementTag tag, PrivateAccessorType accessorType)

{

DeclarationResultMask result = DeclarationResult::Valid;

VariableEnvironment::PrivateDeclarationResult addResult;

if (accessorType == PrivateAccessorType::Setter)

addResult = tag == ClassElementTag::Static ? m_lexicalVariables.declareStaticPrivateSetter(ident) : m_lexicalVariables.declarePrivateSetter(ident);

else

addResult = tag == ClassElementTag::Static ? m_lexicalVariables.declareStaticPrivateGetter(ident) : m_lexicalVariables.declarePrivateGetter(ident);

if (addResult == VariableEnvironment::PrivateDeclarationResult::DuplicatedName)

result |= DeclarationResult::InvalidDuplicateDeclaration;

if (addResult == VariableEnvironment::PrivateDeclarationResult::InvalidStaticNonStatic)

result |= DeclarationResult::InvalidPrivateStaticNonStatic;

return result;

}

DeclarationResultMask declarePrivateSetter(const Identifier& ident, ClassElementTag tag)

{

ASSERT(m_allowsLexicalDeclarations);

return declarePrivateAccessor(ident, tag, PrivateAccessorType::Setter);

}

DeclarationResultMask declarePrivateGetter(const Identifier& ident, ClassElementTag tag)

{

ASSERT(m_allowsLexicalDeclarations);

return declarePrivateAccessor(ident, tag, PrivateAccessorType::Getter);

}

DeclarationResultMask declarePrivateField(const Identifier& ident)

{

ASSERT(m_allowsLexicalDeclarations);

DeclarationResultMask result = DeclarationResult::Valid;

auto addResult = m_lexicalVariables.declarePrivateField(ident);

if (!addResult.isNewEntry)

result |= DeclarationResult::InvalidDuplicateDeclaration;

return result;

}

ALWAYS_INLINE bool hasDeclaredParameter(const Identifier& ident)

{

return hasDeclaredParameter(ident.impl());

}

bool hasDeclaredParameter(const RefPtr<UniquedStringImpl>& ident)

{

return m_declaredParameters.contains(ident.get()) || hasDeclaredVariable(ident);

}

void preventAllVariableDeclarations()

{

m_allowsVarDeclarations = false;

m_allowsLexicalDeclarations = false;

}

void preventVarDeclarations() { m_allowsVarDeclarations = false; }

bool allowsVarDeclarations() const { return m_allowsVarDeclarations; }

bool allowsLexicalDeclarations() const { return m_allowsLexicalDeclarations; }

DeclarationResultMask declareParameter(const Identifier* ident)

{

ASSERT(m_allowsVarDeclarations);

DeclarationResultMask result = DeclarationResult::Valid;

bool isArgumentsIdent = isArguments(m_vm, ident);

auto addResult = m_declaredVariables.add(ident->impl());

bool isValidStrictMode = (addResult.isNewEntry || !addResult.iterator->value.isParameter())

&& m_vm.propertyNames->eval != *ident && !isArgumentsIdent;

addResult.iterator->value.clearIsVar();

addResult.iterator->value.setIsParameter();

m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;

m_declaredParameters.add(ident->impl());

if (!isValidStrictMode)

result |= DeclarationResult::InvalidStrictMode;

if (isArgumentsIdent)

m_shadowsArguments = true;

if (!addResult.isNewEntry)

result |= DeclarationResult::InvalidDuplicateDeclaration;

return result;

}

bool usedVariablesContains(UniquedStringImpl* impl) const

{

for (const UniquedStringImplPtrSet& set : m_usedVariables) {

if (set.contains(impl))

return true;

}

return false;

}

template <typename Func>

void forEachUsedVariable(const Func& func)

{

for (const UniquedStringImplPtrSet& set : m_usedVariables) {

for (UniquedStringImpl* impl : set) {

if (func(impl) == IterationStatus::Done)

return;

}

}

}

void useVariable(const Identifier* ident, bool isEval)

{

useVariable(ident->impl(), isEval);

}

void useVariable(UniquedStringImpl* impl, bool isEval)

{

m_usesEval |= isEval;

m_usedVariables.last().add(impl);

}

void usePrivateName(const Identifier& ident)

{

ASSERT(m_allowsLexicalDeclarations);

useVariable(&ident, false);

}

void pushUsedVariableSet() { m_usedVariables.append(UniquedStringImplPtrSet()); }

size_t currentUsedVariablesSize() { return m_usedVariables.size(); }

void revertToPreviousUsedVariables(size_t size) { m_usedVariables.resize(size); }

void setNeedsFullActivation() { m_needsFullActivation = true; }

bool needsFullActivation() const { return m_needsFullActivation; }

bool isArrowFunctionBoundary() { return m_isArrowFunctionBoundary; }

bool isArrowFunction() { return m_isArrowFunction; }

bool hasDirectSuper() const { return m_hasDirectSuper; }

void setHasDirectSuper() { m_hasDirectSuper = true; }

bool needsSuperBinding() const { return m_needsSuperBinding; }

void setNeedsSuperBinding() { m_needsSuperBinding = true; }

void setEvalContextType(EvalContextType evalContextType) { m_evalContextType = evalContextType; }

EvalContextType evalContextType() { return m_evalContextType; }

InnerArrowFunctionCodeFeatures innerArrowFunctionFeatures() { return m_innerArrowFunctionFeatures; }

void setExpectedSuperBinding(SuperBinding superBinding) { m_expectedSuperBinding = static_cast<unsigned>(superBinding); }

SuperBinding expectedSuperBinding() const { return static_cast<SuperBinding>(m_expectedSuperBinding); }

void setConstructorKind(ConstructorKind constructorKind) { m_constructorKind = static_cast<unsigned>(constructorKind); }

ConstructorKind constructorKind() const { return static_cast<ConstructorKind>(m_constructorKind); }

void setInnerArrowFunctionUsesSuperCall() { m_innerArrowFunctionFeatures |= SuperCallInnerArrowFunctionFeature; }

void setInnerArrowFunctionUsesSuperProperty() { m_innerArrowFunctionFeatures |= SuperPropertyInnerArrowFunctionFeature; }

void setInnerArrowFunctionUsesEval() { m_innerArrowFunctionFeatures |= EvalInnerArrowFunctionFeature; }

void setInnerArrowFunctionUsesThis() { m_innerArrowFunctionFeatures |= ThisInnerArrowFunctionFeature; }

void setInnerArrowFunctionUsesNewTarget() { m_innerArrowFunctionFeatures |= NewTargetInnerArrowFunctionFeature; }

void setInnerArrowFunctionUsesArguments() { m_innerArrowFunctionFeatures |= ArgumentsInnerArrowFunctionFeature; }

bool isEvalContext() const { return m_isEvalContext; }

void setIsEvalContext(bool isEvalContext) { m_isEvalContext = isEvalContext; }

void setInnerArrowFunctionUsesEvalAndUseArgumentsIfNeeded()

{

ASSERT(m_isArrowFunction);

if (m_usesEval)

setInnerArrowFunctionUsesEval();

if (usedVariablesContains(m_vm.propertyNames->arguments.impl()))

setInnerArrowFunctionUsesArguments();

}

void addClosedVariableCandidateUnconditionally(UniquedStringImpl* impl)

{

m_closedVariableCandidates.add(impl);

}

void markLastUsedVariablesSetAsCaptured()

{

for (UniquedStringImpl* impl : m_usedVariables.last())

m_closedVariableCandidates.add(impl);

}

void collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)

{

if (nestedScope->m_usesEval)

m_usesEval = true;

{

UniquedStringImplPtrSet& destinationSet = m_usedVariables.last();

for (const UniquedStringImplPtrSet& usedVariablesSet : nestedScope->m_usedVariables) {

for (UniquedStringImpl* impl : usedVariablesSet) {

if (nestedScope->m_declaredVariables.contains(impl) || nestedScope->m_lexicalVariables.contains(impl))

continue;

// "arguments" reference should be resolved at function boudary.

if (nestedScope->isFunctionBoundary() && nestedScope->hasArguments() && impl == m_vm.propertyNames->arguments.impl() && !nestedScope->isArrowFunctionBoundary())

continue;

destinationSet.add(impl);

// We don't want a declared variable that is used in an inner scope to be thought of as captured if

// that inner scope is both a lexical scope and not a function. Only inner functions and "catch"

// statements can cause variables to be captured.

if (shouldTrackClosedVariables && (nestedScope->m_isFunctionBoundary || !nestedScope->m_isLexicalScope))

m_closedVariableCandidates.add(impl);

}

}

}

// Propagate closed variable candidates downwards within the same function.

// Cross function captures will be realized via m_usedVariables propagation.

if (shouldTrackClosedVariables && !nestedScope->m_isFunctionBoundary && nestedScope->m_closedVariableCandidates.size()) {

auto end = nestedScope->m_closedVariableCandidates.end();

auto begin = nestedScope->m_closedVariableCandidates.begin();

m_closedVariableCandidates.add(begin, end);

}

}

void mergeInnerArrowFunctionFeatures(InnerArrowFunctionCodeFeatures arrowFunctionCodeFeatures)

{

m_innerArrowFunctionFeatures = m_innerArrowFunctionFeatures | arrowFunctionCodeFeatures;

}

void getSloppyModeHoistedFunctions(UniquedStringImplPtrSet& sloppyModeHoistedFunctions)

{

for (UniquedStringImpl* function : m_sloppyModeHoistableFunctionCandidates) {

// ES6 Annex B.3.3. The only time we can't hoist a function is if a syntax error would

// be caused by declaring a var with that function's name or if we have a parameter with

// that function's name. Note that we would only cause a syntax error if we had a let/const/class

// variable with the same name.

if (!m_lexicalVariables.contains(function)) {

auto iter = m_declaredVariables.find(function);

bool isParameter = iter != m_declaredVariables.end() && iter->value.isParameter();

if (!isParameter) {

auto addResult = m_declaredVariables.add(function);

addResult.iterator->value.setIsVar();

addResult.iterator->value.setIsSloppyModeHoistingCandidate();

sloppyModeHoistedFunctions.add(function);

}

}

}

}

void getCapturedVars(IdentifierSet& capturedVariables)

{

if (m_needsFullActivation || m_usesEval) {

for (auto& entry : m_declaredVariables)

capturedVariables.add(entry.key);

return;

}

for (UniquedStringImpl* impl : m_closedVariableCandidates) {

// We refer to m_declaredVariables here directly instead of a hasDeclaredVariable because we want to mark the callee as captured.

if (!m_declaredVariables.contains(impl))

continue;

capturedVariables.add(impl);

}

}

LexicalScopeFeatures lexicalScopeFeatures() const { return m_lexicalScopeFeatures; }

void setStrictMode() { m_lexicalScopeFeatures |= StrictModeLexicalFeature; }

bool strictMode() const { return m_lexicalScopeFeatures & StrictModeLexicalFeature; }

bool isValidStrictMode() const { return m_isValidStrictMode; }

bool shadowsArguments() const { return m_shadowsArguments; }

void setHasNonSimpleParameterList()

{

m_isValidStrictMode = false;

m_hasNonSimpleParameterList = true;

}

bool hasNonSimpleParameterList() const { return m_hasNonSimpleParameterList; }

void copyCapturedVariablesToVector(const UniquedStringImplPtrSet& usedVariables, Vector<UniquedStringImpl*, 8>& vector)

{

for (UniquedStringImpl* impl : usedVariables) {

if (m_declaredVariables.contains(impl) || m_lexicalVariables.contains(impl))

continue;

vector.append(impl);

}

}

void fillParametersForSourceProviderCache(SourceProviderCacheItemCreationParameters& parameters, const UniquedStringImplPtrSet& capturesFromParameterExpressions)

{

ASSERT(m_isFunction);

parameters.usesEval = m_usesEval;

parameters.lexicalScopeFeatures = m_lexicalScopeFeatures;

parameters.needsFullActivation = m_needsFullActivation;

parameters.innerArrowFunctionFeatures = m_innerArrowFunctionFeatures;

parameters.needsSuperBinding = m_needsSuperBinding;

for (const UniquedStringImplPtrSet& set : m_usedVariables)

copyCapturedVariablesToVector(set, parameters.usedVariables);

// FIXME: https://bugs.webkit.org/show_bug.cgi?id=156962

// We add these unconditionally because we currently don't keep a separate

// declaration scope for a function's parameters and its var/let/const declarations.

// This is somewhat unfortunate and we should refactor to do this at some point

// because parameters logically form a parent scope to var/let/const variables.

// But because we don't do this, we must grab capture candidates from a parameter

// list before we parse the body of a function because the body's declarations

// might make us believe something isn't actually a capture candidate when it really

// is.

for (UniquedStringImpl* impl : capturesFromParameterExpressions)

parameters.usedVariables.append(impl);

}

void restoreFromSourceProviderCache(const SourceProviderCacheItem* info)

{

ASSERT(m_isFunction);

m_usesEval = info->usesEval;

m_lexicalScopeFeatures = info->lexicalScopeFeatures();

m_innerArrowFunctionFeatures = info->innerArrowFunctionFeatures;

m_needsFullActivation = info->needsFullActivation;

m_needsSuperBinding = info->needsSuperBinding;

UniquedStringImplPtrSet& destSet = m_usedVariables.last();

for (unsigned i = 0; i < info->usedVariablesCount; ++i)

destSet.add(info->usedVariables()[i].get());

}

class MaybeParseAsGeneratorForScope;

private:

void setIsFunction()

{

m_isFunction = true;

m_isFunctionBoundary = true;

m_hasArguments = true;

setIsLexicalScope();

m_isGenerator = false;

m_isGeneratorBoundary = false;

m_isArrowFunctionBoundary = false;

m_isArrowFunction = false;

m_isAsyncFunction = false;

m_isAsyncFunctionBoundary = false;

}

void setIsGeneratorFunction()

{

setIsFunction();

m_isGenerator = true;

}

void setIsGenerator()

{

setIsFunction();

m_isGenerator = true;

m_isGeneratorBoundary = true;

m_hasArguments = false;

}

void setIsArrowFunction()

{

setIsFunction();

m_isArrowFunctionBoundary = true;

m_isArrowFunction = true;

}

void setIsAsyncArrowFunction()

{

setIsArrowFunction();

m_isAsyncFunction = true;

}

void setIsAsyncFunction()

{

setIsFunction();

m_isAsyncFunction = true;

}

void setIsAsyncGeneratorFunction()

{

setIsFunction();

m_isAsyncFunction = true;

m_isGenerator = true;

}

void setIsAsyncGeneratorFunctionBody()

{

setIsFunction();

m_hasArguments = false;

m_isGenerator = true;

m_isGeneratorBoundary = true;

m_isAsyncFunction = true;

m_isAsyncFunctionBoundary = true;

}

void setIsAsyncFunctionBody()

{

setIsFunction();

m_hasArguments = false;

m_isAsyncFunction = true;

m_isAsyncFunctionBoundary = true;

}

void setIsAsyncArrowFunctionBody()

{

setIsArrowFunction();

m_hasArguments = false;

m_isAsyncFunction = true;

m_isAsyncFunctionBoundary = true;

}

const VM& m_vm;

bool m_shadowsArguments;

bool m_usesEval;

bool m_needsFullActivation;

bool m_hasDirectSuper;

bool m_needsSuperBinding;

bool m_allowsVarDeclarations;

bool m_allowsLexicalDeclarations;

LexicalScopeFeatures m_lexicalScopeFeatures;

bool m_isFunction;

bool m_isGenerator;

bool m_isGeneratorBoundary;

bool m_isArrowFunction;

bool m_isArrowFunctionBoundary;

bool m_isAsyncFunction;

bool m_isAsyncFunctionBoundary;

bool m_isLexicalScope;

bool m_isGlobalCodeScope;

bool m_isSimpleCatchParameterScope;

bool m_isCatchBlockScope;

bool m_isFunctionBoundary;

bool m_isValidStrictMode;

bool m_hasArguments;

bool m_isEvalContext;

bool m_hasNonSimpleParameterList;

bool m_isClassScope;

EvalContextType m_evalContextType;

unsigned m_constructorKind;

unsigned m_expectedSuperBinding;

int m_loopDepth;

int m_switchDepth;

InnerArrowFunctionCodeFeatures m_innerArrowFunctionFeatures;

typedef Vector<ScopeLabelInfo, 2> LabelStack;

std::unique_ptr<LabelStack> m_labels;

UniquedStringImplPtrSet m_declaredParameters;

VariableEnvironment m_declaredVariables;

VariableEnvironment m_lexicalVariables;

Vector<UniquedStringImplPtrSet, 6> m_usedVariables;

UniquedStringImplPtrSet m_variablesBeingHoisted;

UniquedStringImplPtrSet m_sloppyModeHoistableFunctionCandidates;

HashSet<UniquedStringImpl*> m_closedVariableCandidates;

DeclarationStacks::FunctionStack m_functionDeclarations;

};

typedef Vector<Scope, 10> ScopeStack;

struct ScopeRef {

ScopeRef(ScopeStack* scopeStack, unsigned index)

: m_scopeStack(scopeStack)

, m_index(index)

{

}

Scope* operator->() { return &m_scopeStack->at(m_index); }

unsigned index() const { return m_index; }

bool hasContainingScope()

{

return m_index && !m_scopeStack->at(m_index).isFunctionBoundary();

}

ScopeRef containingScope()

{

ASSERT(hasContainingScope());

return ScopeRef(m_scopeStack, m_index - 1);

}

bool operator==(const ScopeRef& other)

{

ASSERT(other.m_scopeStack == m_scopeStack);

return m_index == other.m_index;

}

bool operator!=(const ScopeRef& other)

{

return !(*this == other);

}

private:

ScopeStack* m_scopeStack;

unsigned m_index;

};

enum class ArgumentType { Normal, Spread };

enum class ParsingContext { Program, FunctionConstructor, Eval };

template <typename LexerType>

class Parser {

WTF_MAKE_NONCOPYABLE(Parser);

WTF_MAKE_FAST_ALLOCATED;

public:

Parser(VM&, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, JSParserScriptMode, SourceParseMode, SuperBinding, ConstructorKind defaultConstructorKindForTopLevelFunction = ConstructorKind::None, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None, DebuggerParseData* = nullptr, bool isInsideOrdinaryFunction = false);

~Parser();

template <class ParsedNode>

std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, ParsingContext, std::optional<int> functionConstructorParametersEndPosition = std::nullopt, const PrivateNameEnvironment* = nullptr, const FixedVector<JSTextPosition>* = nullptr);

JSTextPosition positionBeforeLastNewline() const { return m_lexer->positionBeforeLastNewline(); }

JSTokenLocation locationBeforeLastToken() const { return m_lexer->lastTokenLocation(); }

struct CallOrApplyDepthScope {

CallOrApplyDepthScope(Parser* parser)

: m_parser(parser)

, m_parent(parser->m_callOrApplyDepthScope)

, m_depth(m_parent ? m_parent->m_depth + 1 : 0)

, m_depthOfInnermostChild(m_depth)

{

parser->m_callOrApplyDepthScope = this;

}

size_t distanceToInnermostChild() const

{

ASSERT(m_depthOfInnermostChild >= m_depth);

return m_depthOfInnermostChild - m_depth;