DestructureToVariables,

DestructureToLet,

DestructureToConst,

DestructureToCatchParameters,

DestructureToParameters,

DestructureToExpressions

VarDeclaration,

LetDeclaration,

ConstDeclaration

Imported,

ImportedNamespace,

NotImported

Valid = 0,

InvalidStrictMode = 1 << 0,

InvalidDuplicateDeclaration = 1 << 1

static Ref<ModuleScopeData> create() { return adoptRef(*new ModuleScopeData); }

const IdentifierSet& exportedBindings() const { return m_exportedBindings; }

bool exportName(const Identifier& exportedName)

{

return m_exportedNames.add(exportedName.impl()).isNewEntry;

}

void exportBinding(const Identifier& localName)

{

m_exportedBindings.add(localName.impl());

}

IdentifierSet m_exportedNames { };

IdentifierSet m_exportedBindings { };

Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode)

: 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_strictMode(strictMode)

, m_isFunction(isFunction)

, m_isGenerator(isGenerator)

, m_isArrowFunction(false)

, m_isLexicalScope(false)

, m_isFunctionBoundary(false)

, m_isValidStrictMode(true)

, m_hasArguments(false)

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

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

, m_loopDepth(0)

, m_switchDepth(0)

{

}

Scope(const Scope& rhs)

: m_vm(rhs.m_vm)

, m_shadowsArguments(rhs.m_shadowsArguments)

, m_usesEval(rhs.m_usesEval)

, m_needsFullActivation(rhs.m_needsFullActivation)

, m_hasDirectSuper(rhs.m_hasDirectSuper)

, m_needsSuperBinding(rhs.m_needsSuperBinding)

, m_allowsVarDeclarations(rhs.m_allowsVarDeclarations)

, m_allowsLexicalDeclarations(rhs.m_allowsLexicalDeclarations)

, m_strictMode(rhs.m_strictMode)

, m_isFunction(rhs.m_isFunction)

, m_isGenerator(rhs.m_isGenerator)

, m_isArrowFunction(rhs.m_isArrowFunction)

, m_isLexicalScope(rhs.m_isLexicalScope)

, m_isFunctionBoundary(rhs.m_isFunctionBoundary)

, m_isValidStrictMode(rhs.m_isValidStrictMode)

, m_hasArguments(rhs.m_hasArguments)

, m_constructorKind(rhs.m_constructorKind)

, m_expectedSuperBinding(rhs.m_expectedSuperBinding)

, m_loopDepth(rhs.m_loopDepth)

, m_switchDepth(rhs.m_switchDepth)

, m_moduleScopeData(rhs.m_moduleScopeData)

{

if (rhs.m_labels) {

m_labels = std::make_unique<LabelStack>();

typedef LabelStack::const_iterator iterator;

iterator end = rhs.m_labels->end();

for (iterator it = rhs.m_labels->begin(); it != end; ++it)

m_labels->append(ScopeLabelInfo { it->uid, it->isLoop });

}

}

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 = std::make_unique<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 0;

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 0;

}

void setSourceParseMode(SourceParseMode mode)

{

switch (mode) {

case SourceParseMode::GeneratorBodyMode:

setIsGenerator();

break;

case SourceParseMode::GeneratorWrapperFunctionMode:

setIsGeneratorFunction();

break;

case SourceParseMode::NormalFunctionMode:

case SourceParseMode::GetterMode:

case SourceParseMode::SetterMode:

case SourceParseMode::MethodMode:

setIsFunction();

break;

case SourceParseMode::ArrowFunctionMode:

setIsArrowFunction();

break;

case SourceParseMode::ProgramMode:

break;

case SourceParseMode::ModuleAnalyzeMode:

case SourceParseMode::ModuleEvaluateMode:

setIsModule();

break;

}

}

bool isFunction() const { return m_isFunction; }

bool isFunctionBoundary() const { return m_isFunctionBoundary; }

bool isGenerator() const { return m_isGenerator; }

bool hasArguments() const { return m_hasArguments; }

void setIsLexicalScope()

{

m_isLexicalScope = true;

m_allowsLexicalDeclarations = true;

}

bool isLexicalScope() { return m_isLexicalScope; }

const IdentifierSet& closedVariableCandidates() const { return m_closedVariableCandidates; }

VariableEnvironment& declaredVariables() { return m_declaredVariables; }

VariableEnvironment& lexicalVariables() { return m_lexicalVariables; }

VariableEnvironment& finalizeLexicalEnvironment()

{

if (m_usesEval || m_needsFullActivation)

m_lexicalVariables.markAllVariablesAsCaptured();

else

computeLexicallyCapturedVariablesAndPurgeCandidates();

return m_lexicalVariables;

}

ModuleScopeData& moduleScopeData() const

{

ASSERT(m_moduleScopeData);

return *m_moduleScopeData;

}

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()) {

auto end = m_closedVariableCandidates.end();

for (auto iter = m_closedVariableCandidates.begin(); iter != end; ++iter)

m_lexicalVariables.markVariableAsCapturedIfDefined(iter->get());

}

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

{

for (auto entry : m_lexicalVariables) {

if (entry.value.isCaptured())

m_closedVariableCandidates.remove(entry.key);

}

}

}

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;

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

result |= DeclarationResult::InvalidDuplicateDeclaration;

return result;

}

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)

result |= DeclarationResult::InvalidDuplicateDeclaration;

if (!isValidStrictMode)

result |= DeclarationResult::InvalidStrictMode;

return result;

}

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".

}

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

{

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

}

ALWAYS_INLINE bool hasDeclaredParameter(const Identifier& ident)

{

return hasDeclaredParameter(ident.impl());

}

bool hasDeclaredParameter(const RefPtr<UniquedStringImpl>& ident)

{

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

}

void declareWrite(const Identifier* ident)

{

ASSERT(m_strictMode);

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

}

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());

addResult.iterator->value.clearIsVar();

bool isValidStrictMode = addResult.isNewEntry && m_vm->propertyNames->eval != *ident && !isArgumentsIdent;

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;

}

void getUsedVariables(IdentifierSet& usedVariables)

{

usedVariables.swap(m_usedVariables);

}

void useVariable(const Identifier* ident, bool isEval)

{

m_usesEval |= isEval;

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

}

void setNeedsFullActivation() { m_needsFullActivation = true; }

bool needsFullActivation() const { return m_needsFullActivation; }

bool isArrowFunction() { return m_isArrowFunction; }

bool hasDirectSuper() { return m_hasDirectSuper; }

void setHasDirectSuper() { m_hasDirectSuper = true; }

bool needsSuperBinding() { return m_needsSuperBinding; }

void setNeedsSuperBinding() { m_needsSuperBinding = true; }

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 collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)

{

if (nestedScope->m_usesEval)

m_usesEval = true;

{

for (const RefPtr<UniquedStringImpl>& impl : nestedScope->m_usedVariables) {

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->isArrowFunction())

continue;

m_usedVariables.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()) {

IdentifierSet::iterator end = nestedScope->m_closedVariableCandidates.end();

IdentifierSet::iterator begin = nestedScope->m_closedVariableCandidates.begin();

m_closedVariableCandidates.add(begin, end);

}

if (nestedScope->m_writtenVariables.size()) {

IdentifierSet::iterator end = nestedScope->m_writtenVariables.end();

for (IdentifierSet::iterator ptr = nestedScope->m_writtenVariables.begin(); ptr != end; ++ptr) {

if (nestedScope->m_declaredVariables.contains(*ptr) || nestedScope->m_lexicalVariables.contains(*ptr))

continue;

m_writtenVariables.add(*ptr);

}

}

}

void getCapturedVars(IdentifierSet& capturedVariables, bool& modifiedParameter, bool& modifiedArguments)

{

if (m_needsFullActivation || m_usesEval) {

modifiedParameter = true;

for (auto& entry : m_declaredVariables)

capturedVariables.add(entry.key);

return;

}

for (IdentifierSet::iterator ptr = m_closedVariableCandidates.begin(); ptr != m_closedVariableCandidates.end(); ++ptr) {

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

if (!m_declaredVariables.contains(*ptr))

continue;

capturedVariables.add(*ptr);

}

modifiedParameter = false;

if (shadowsArguments())

modifiedArguments = true;

if (m_declaredParameters.size()) {

IdentifierSet::iterator end = m_writtenVariables.end();

for (IdentifierSet::iterator ptr = m_writtenVariables.begin(); ptr != end; ++ptr) {

if (*ptr == m_vm->propertyNames->arguments.impl())

modifiedArguments = true;

if (!m_declaredParameters.contains(*ptr))

continue;

modifiedParameter = true;

break;

}

}

}

void setStrictMode() { m_strictMode = true; }

bool strictMode() const { return m_strictMode; }

bool isValidStrictMode() const { return m_isValidStrictMode; }

bool shadowsArguments() const { return m_shadowsArguments; }

void copyCapturedVariablesToVector(const IdentifierSet& capturedVariables, Vector<RefPtr<UniquedStringImpl>>& vector)

{

IdentifierSet::iterator end = capturedVariables.end();

for (IdentifierSet::iterator it = capturedVariables.begin(); it != end; ++it) {

if (m_declaredVariables.contains(*it) || m_lexicalVariables.contains(*it))

continue;

vector.append(*it);

}

}

void fillParametersForSourceProviderCache(SourceProviderCacheItemCreationParameters& parameters)

{

ASSERT(m_isFunction);

parameters.usesEval = m_usesEval;

parameters.strictMode = m_strictMode;

parameters.needsFullActivation = m_needsFullActivation;

copyCapturedVariablesToVector(m_writtenVariables, parameters.writtenVariables);

copyCapturedVariablesToVector(m_usedVariables, parameters.usedVariables);

}

void restoreFromSourceProviderCache(const SourceProviderCacheItem* info)

{

ASSERT(m_isFunction);

m_usesEval = info->usesEval;

m_strictMode = info->strictMode;

m_needsFullActivation = info->needsFullActivation;

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

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

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

m_writtenVariables.add(info->writtenVariables()[i]);

}

void setIsFunction()

{

m_isFunction = true;

m_isFunctionBoundary = true;

m_hasArguments = true;

setIsLexicalScope();

m_isGenerator = false;

}

void setIsGeneratorFunction()

{

setIsFunction();

m_isGenerator = true;

}

void setIsGenerator()

{

setIsFunction();

m_isGenerator = true;

m_hasArguments = false;

}

void setIsArrowFunction()

{

setIsFunction();

m_isArrowFunction = true;

}

void setIsModule()

{

m_moduleScopeData = ModuleScopeData::create();

}

const VM* m_vm;

bool m_shadowsArguments : 1;

bool m_usesEval : 1;

bool m_needsFullActivation : 1;

bool m_hasDirectSuper : 1;

bool m_needsSuperBinding : 1;

bool m_allowsVarDeclarations : 1;

bool m_allowsLexicalDeclarations : 1;

bool m_strictMode : 1;

bool m_isFunction : 1;

bool m_isGenerator : 1;

bool m_isArrowFunction : 1;

bool m_isLexicalScope : 1;

bool m_isFunctionBoundary : 1;

bool m_isValidStrictMode : 1;

bool m_hasArguments : 1;

unsigned m_constructorKind : 2;

unsigned m_expectedSuperBinding : 2;

int m_loopDepth;

int m_switchDepth;

typedef Vector<ScopeLabelInfo, 2> LabelStack;

std::unique_ptr<LabelStack> m_labels;

IdentifierSet m_declaredParameters;

VariableEnvironment m_declaredVariables;

VariableEnvironment m_lexicalVariables;

IdentifierSet m_usedVariables;

IdentifierSet m_closedVariableCandidates;

IdentifierSet m_writtenVariables;

RefPtr<ModuleScopeData> m_moduleScopeData { };

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);

}

ScopeStack* m_scopeStack;

unsigned m_index;

WTF_MAKE_NONCOPYABLE(Parser);

WTF_MAKE_FAST_ALLOCATED;

Parser(

VM*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode, SuperBinding,

ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode = ThisTDZMode::CheckIfNeeded);

~Parser();

template <class ParsedNode>

std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, SourceParseMode);

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

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

struct AllowInOverride {

AllowInOverride(Parser* parser)

: m_parser(parser)

, m_oldAllowsIn(parser->m_allowsIn)

{

parser->m_allowsIn = true;

}

~AllowInOverride()

{

m_parser->m_allowsIn = m_oldAllowsIn;

}

Parser* m_parser;

bool m_oldAllowsIn;

};

struct AutoPopScopeRef : public ScopeRef {

AutoPopScopeRef(Parser* parser, ScopeRef scope)

: ScopeRef(scope)

, m_parser(parser)

{

}

~AutoPopScopeRef()

{

if (m_parser)

m_parser->popScope(*this, false);

}

void setPopped()

{

m_parser = 0;

}

private:

Parser* m_parser;

};

struct AutoCleanupLexicalScope {

// We can allocate this object on the stack without actually knowing beforehand if we're

// going to create a new lexical scope. If we decide to create a new lexical scope, we

// can pass the scope into this obejct and it will take care of the cleanup for us if the parse fails.

// This is helpful if we may fail from syntax errors after creating a lexical scope conditionally.

AutoCleanupLexicalScope()

: m_scope(nullptr, UINT_MAX)

, m_parser(nullptr)

{

}

~AutoCleanupLexicalScope()

{

// This should only ever be called if we fail from a syntax error. Otherwise

// it's the intention that a user of this class pops this scope manually on a

// successful parse.

if (isValid())

m_parser->popScope(*this, false);

}

void setIsValid(ScopeRef& scope, Parser* parser)

{

RELEASE_ASSERT(scope->isLexicalScope());

m_scope = scope;

m_parser = parser;

}

bool isValid() const { return !!m_parser; }

void setPopped()

{

m_parser = nullptr;

}

ScopeRef& scope() { return m_scope; }

private:

ScopeRef m_scope;

Parser* m_parser;

};

enum ExpressionErrorClass {

ErrorIndicatesNothing,

ErrorIndicatesPattern

};

struct ExpressionErrorClassifier {

ExpressionErrorClassifier(Parser* parser)

: m_class(ErrorIndicatesNothing)

, m_previous(parser->m_expressionErrorClassifier)

, m_parser(parser)

{

m_parser->m_expressionErrorClassifier = this;

}

~ExpressionErrorClassifier()

{

m_parser->m_expressionErrorClassifier = m_previous;

}

void classifyExpressionError(ExpressionErrorClass classification)

{

if (m_class != ErrorIndicatesNothing)

return;

m_class = classification;

}

void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)

{

if (m_class != oldClassification)

return;

m_class = classification;

}

void propagateExpressionErrorClass()

{

if (m_previous && m_class != ErrorIndicatesNothing)

m_previous->m_class = m_class;

}

bool indicatesPossiblePattern() const { return m_class == ErrorIndicatesPattern; }

private:

ExpressionErrorClass m_class;

ExpressionErrorClassifier* m_previous;

Parser* m_parser;

};

ALWAYS_INLINE void classifyExpressionError(ExpressionErrorClass classification)

{

if (m_expressionErrorClassifier)

m_expressionErrorClassifier->classifyExpressionError(classification);

}

ALWAYS_INLINE void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)

{

if (m_expressionErrorClassifier)

m_expressionErrorClassifier->reclassifyExpressionError(oldClassification, classification);

}

ALWAYS_INLINE DestructuringKind destructuringKindFromDeclarationType(DeclarationType type)

{

switch (type) {

case DeclarationType::VarDeclaration:

return DestructuringKind::DestructureToVariables;

case DeclarationType::LetDeclaration:

return DestructuringKind::DestructureToLet;

case DeclarationType::ConstDeclaration:

return DestructuringKind::DestructureToConst;

}

RELEASE_ASSERT_NOT_REACHED();

return DestructuringKind::DestructureToVariables;

}

ALWAYS_INLINE AssignmentContext assignmentContextFromDeclarationType(DeclarationType type)

{

switch (type) {

case DeclarationType::ConstDeclaration:

return AssignmentContext::ConstDeclarationStatement;

default:

return AssignmentContext::DeclarationStatement;

}

}

ALWAYS_INLINE bool isEvalOrArguments(const Identifier* ident) { return isEvalOrArgumentsIdentifier(m_vm, ident); }

ScopeRef currentScope()

{

return ScopeRef(&m_scopeStack, m_scopeStack.size() - 1);

}

ScopeRef currentVariableScope()

{

unsigned i = m_scopeStack.size() - 1;

ASSERT(i < m_scopeStack.size());

while (!m_scopeStack[i].allowsVarDeclarations()) {

i--;

ASSERT(i < m_scopeStack.size());

}

return ScopeRef(&m_scopeStack, i);

}

ScopeRef currentFunctionScope()

{

unsigned i = m_scopeStack.size() - 1;

ASSERT(i < m_scopeStack.size());

while (i && !m_scopeStack[i].isFunctionBoundary()) {

i--;

ASSERT(i < m_scopeStack.size());

}

// When reaching the top level scope (it can be non function scope), we return it.

return ScopeRef(&m_scopeStack, i);

}

ScopeRef closestParentNonArrowFunctionNonLexicalScope()

{

unsigned i = m_scopeStack.size() - 1;

ASSERT(i < m_scopeStack.size() && m_scopeStack.size());

while (i && (!m_scopeStack[i].isFunctionBoundary() || m_scopeStack[i].isArrowFunction()))

i--;

// When reaching the top level scope (it can be non function scope), we return it.

return ScopeRef(&m_scopeStack, i);

}

ScopeRef pushScope()

{

bool isFunction = false;

bool isStrict = false;

bool isGenerator = false;

if (!m_scopeStack.isEmpty()) {

isStrict = m_scopeStack.last().strictMode();

isFunction = m_scopeStack.last().isFunction();

isGenerator = m_scopeStack.last().isGenerator();

}

m_scopeStack.append(Scope(m_vm, isFunction, isGenerator, isStrict));

return currentScope();

}

void popScopeInternal(ScopeRef& scope, bool shouldTrackClosedVariables)

{

ASSERT_UNUSED(scope, scope.index() == m_scopeStack.size() - 1);

ASSERT(m_scopeStack.size() > 1);

m_scopeStack[m_scopeStack.size() - 2].collectFreeVariables(&m_scopeStack.last(), shouldTrackClosedVariables);

if (!m_scopeStack.last().isFunctionBoundary() && m_scopeStack.last().needsFullActivation())

m_scopeStack[m_scopeStack.size() - 2].setNeedsFullActivation();

m_scopeStack.removeLast();

}

ALWAYS_INLINE void popScope(ScopeRef& scope, bool shouldTrackClosedVariables)

{

popScopeInternal(scope, shouldTrackClosedVariables);

}

ALWAYS_INLINE void popScope(AutoPopScopeRef& scope, bool shouldTrackClosedVariables)

{

scope.setPopped();

popScopeInternal(scope, shouldTrackClosedVariables);

}

ALWAYS_INLINE void popScope(AutoCleanupLexicalScope& cleanupScope, bool shouldTrackClosedVariables)

{

RELEASE_ASSERT(cleanupScope.isValid());

ScopeRef& scope = cleanupScope.scope();

cleanupScope.setPopped();

popScopeInternal(scope, shouldTrackClosedVariables);

}

DeclarationResultMask declareVariable(const Identifier* ident, DeclarationType type = DeclarationType::VarDeclaration, DeclarationImportType importType = DeclarationImportType::NotImported)

{

if (type == DeclarationType::VarDeclaration)

return currentVariableScope()->declareVariable(ident);

unsigned i = m_scopeStack.size() - 1;

ASSERT(i < m_scopeStack.size());

ASSERT(type == DeclarationType::LetDeclaration || type == DeclarationType::ConstDeclaration);

// Lexical variables declared at a top level scope that shadow arguments or vars are not allowed.

if (m_statementDepth == 1 && (hasDeclaredParameter(*ident) || hasDeclaredVariable(*ident)))

return DeclarationResult::InvalidDuplicateDeclaration;

while (!m_scopeStack[i].allowsLexicalDeclarations()) {

i--;

ASSERT(i < m_scopeStack.size());

}

return m_scopeStack[i].declareLexicalVariable(ident, type == DeclarationType::ConstDeclaration, importType);

}

NEVER_INLINE bool hasDeclaredVariable(const Identifier& ident)

{

unsigned i = m_scopeStack.size() - 1;

ASSERT(i < m_scopeStack.size());

while (!m_scopeStack[i].allowsVarDeclarations()) {

i--;

ASSERT(i < m_scopeStack.size());

}

return m_scopeStack[i].hasDeclaredVariable(ident);

}

NEVER_INLINE bool hasDeclaredParameter(const Identifier& ident)

{

unsigned i = m_scopeStack.size() - 1;

ASSERT(i < m_scopeStack.size());

while (!m_scopeStack[i].allowsVarDeclarations()) {

i--;

ASSERT(i < m_scopeStack.size());

}

return m_scopeStack[i].hasDeclaredParameter(ident);

}

void declareWrite(const Identifier* ident)

{

if (!m_syntaxAlreadyValidated || strictMode())

m_scopeStack.last().declareWrite(ident);

}

bool exportName(const Identifier& ident)

{

ASSERT(currentScope().index() == 0);

return currentScope()->moduleScopeData().exportName(ident);