Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at */
#ifndef frontend_ParseContext_h
#define frontend_ParseContext_h
#include "ds/Nestable.h"
#include "frontend/ErrorReporter.h"
#include "frontend/NameAnalysisTypes.h" // DeclaredNameInfo, FunctionBoxVector
#include "frontend/NameCollections.h"
#include "frontend/ParserAtom.h" // TaggedParserAtomIndex
#include "frontend/ScriptIndex.h" // ScriptIndex
#include "frontend/SharedContext.h"
#include "js/friend/ErrorMessages.h" // JSMSG_*
#include "vm/GeneratorAndAsyncKind.h" // js::GeneratorKind, js::FunctionAsyncKind
namespace js {
namespace frontend {
class ParserBase;
class UsedNameTracker;
struct CompilationState;
const char* DeclarationKindString(DeclarationKind kind);
// Returns true if the declaration is `var` or equivalent.
bool DeclarationKindIsVar(DeclarationKind kind);
bool DeclarationKindIsParameter(DeclarationKind kind);
* The struct ParseContext stores information about the current parsing context,
* which is part of the parser state (see the field Parser::pc). The current
* parsing context is either the global context, or the function currently being
* parsed. When the parser encounters a function definition, it creates a new
* ParseContext, makes it the new current context.
class ParseContext : public Nestable<ParseContext> {
// The intra-function statement stack.
// Used for early error checking that depend on the nesting structure of
// statements, such as continue/break targets, labels, and unbraced
// lexical declarations.
class Statement : public Nestable<Statement> {
StatementKind kind_;
using Nestable<Statement>::enclosing;
using Nestable<Statement>::findNearest;
Statement(ParseContext* pc, StatementKind kind)
: Nestable<Statement>(&pc->innermostStatement_), kind_(kind) {}
template <typename T>
inline bool is() const;
template <typename T>
inline T& as();
StatementKind kind() const { return kind_; }
void refineForKind(StatementKind newForKind) {
MOZ_ASSERT(kind_ == StatementKind::ForLoop);
MOZ_ASSERT(newForKind == StatementKind::ForInLoop ||
newForKind == StatementKind::ForOfLoop);
kind_ = newForKind;
class LabelStatement : public Statement {
TaggedParserAtomIndex label_;
LabelStatement(ParseContext* pc, TaggedParserAtomIndex label)
: Statement(pc, StatementKind::Label), label_(label) {}
TaggedParserAtomIndex label() const { return label_; }
struct ClassStatement : public Statement {
FunctionBox* constructorBox;
explicit ClassStatement(ParseContext* pc)
: Statement(pc, StatementKind::Class), constructorBox(nullptr) {}
// The intra-function scope stack.
// Tracks declared and used names within a scope.
class Scope : public Nestable<Scope> {
// Names declared in this scope. Corresponds to the union of
// VarDeclaredNames and LexicallyDeclaredNames in the ES spec.
// A 'var' declared name is a member of the declared name set of every
// scope in its scope contour.
// A lexically declared name is a member only of the declared name set of
// the scope in which it is declared.
PooledMapPtr<DeclaredNameMap> declared_;
// FunctionBoxes in this scope that need to be considered for Annex
// B.3.3 semantics. This is checked on Scope exit, as by then we have
// all the declared names and would know if Annex B.3.3 is applicable.
PooledVectorPtr<FunctionBoxVector> possibleAnnexBFunctionBoxes_;
// Monotonically increasing id.
uint32_t id_;
// Flag for determining if we can apply an optimization to store bindings in
// stack slots, which is applied in generator or async functions, or in
// async modules.
// This limit is a performance heuristic. Stack slots reduce allocations,
// and `Local` opcodes are a bit faster than `AliasedVar` ones; but at each
// `yield` or `await` the stack slots must be memcpy'd into a
// GeneratorObject. At some point the memcpy is too much. The limit is
// plenty for typical human-authored code.
enum class GeneratorOrAsyncScopeFlag : uint32_t {
// Scope is small enough that bindings can be stored in stack slots.
Optimizable = 0,
// Scope is too big and all bindings should be closed over.
TooManyBindings = UINT32_MAX,
// Scope size info, relevant for scopes in generators, async functions, and
// async modules only.
static constexpr uint32_t InnerScopeSlotCountInitialValue = 0;
union {
// The estimated number of slots needed for nested scopes inside this one.
// Calculated while parsing the scope and inner scopes.
// Valid only if isOptimizableFlagCalculated_ is false.
uint32_t innerScopeSlotCount_ = InnerScopeSlotCountInitialValue;
// Set when leaving the scope.
// Valid only if isOptimizableFlagCalculated_ is true.
GeneratorOrAsyncScopeFlag optimizableFlag_;
} generatorOrAsyncScopeInfo_;
#ifdef DEBUG
bool isGeneratorOrAsyncScopeInfoUsed_ = false;
bool isOptimizableFlagCalculated_ = false;
uint32_t innerScopeSlotCount() {
#ifdef DEBUG
isGeneratorOrAsyncScopeInfoUsed_ = true;
return generatorOrAsyncScopeInfo_.innerScopeSlotCount_;
void setInnerScopeSlotCount(uint32_t slotCount) {
generatorOrAsyncScopeInfo_.innerScopeSlotCount_ = slotCount;
#ifdef DEBUG
isGeneratorOrAsyncScopeInfoUsed_ = true;
void propagateInnerScopeSlotCount(uint32_t slotCount) {
if (slotCount > innerScopeSlotCount()) {
void setGeneratorOrAsyncScopeIsOptimizable() {
#ifdef DEBUG
isGeneratorOrAsyncScopeInfoUsed_ = true;
isOptimizableFlagCalculated_ = true;
generatorOrAsyncScopeInfo_.optimizableFlag_ =
void setGeneratorOrAsyncScopeHasTooManyBindings() {
#ifdef DEBUG
isGeneratorOrAsyncScopeInfoUsed_ = true;
isOptimizableFlagCalculated_ = true;
generatorOrAsyncScopeInfo_.optimizableFlag_ =
bool maybeReportOOM(ParseContext* pc, bool result) {
if (!result) {
return result;
using DeclaredNamePtr = DeclaredNameMap::Ptr;
using AddDeclaredNamePtr = DeclaredNameMap::AddPtr;
using Nestable<Scope>::enclosing;
explicit inline Scope(ParserBase* parser);
explicit inline Scope(FrontendContext* fc, ParseContext* pc,
UsedNameTracker& usedNames);
void dump(ParseContext* pc, ParserBase* parser);
uint32_t id() const { return id_; }
[[nodiscard]] bool init(ParseContext* pc) {
if (id_ == UINT32_MAX) {
pc->errorReporter_.errorNoOffset(JSMSG_NEED_DIET, "script");
return false;
return declared_.acquire(pc->sc()->fc_);
bool isEmpty() const { return declared_->all().empty(); }
uint32_t declaredCount() const {
size_t count = declared_->count();
MOZ_ASSERT(count <= UINT32_MAX);
return uint32_t(count);
DeclaredNamePtr lookupDeclaredName(TaggedParserAtomIndex name) {
return declared_->lookup(name);
AddDeclaredNamePtr lookupDeclaredNameForAdd(TaggedParserAtomIndex name) {
return declared_->lookupForAdd(name);
[[nodiscard]] bool addDeclaredName(ParseContext* pc, AddDeclaredNamePtr& p,
TaggedParserAtomIndex name,
DeclarationKind kind, uint32_t pos,
ClosedOver closedOver = ClosedOver::No) {
return maybeReportOOM(
pc, declared_->add(p, name, DeclaredNameInfo(kind, pos, closedOver)));
// Add a FunctionBox as a possible candidate for Annex B.3.3 semantics.
[[nodiscard]] bool addPossibleAnnexBFunctionBox(ParseContext* pc,
FunctionBox* funbox);
// Check if the candidate function boxes for Annex B.3.3 should in
// fact get Annex B semantics. Checked on Scope exit.
[[nodiscard]] bool propagateAndMarkAnnexBFunctionBoxes(ParseContext* pc,
ParserBase* parser);
// Add and remove catch parameter names. Used to implement the odd
// semantics of catch bodies.
bool addCatchParameters(ParseContext* pc, Scope& catchParamScope);
void removeCatchParameters(ParseContext* pc, Scope& catchParamScope);
void useAsVarScope(ParseContext* pc) {
pc->varScope_ = this;
// Maximum number of fixed stack slots in a generator or async function
// script. If a script would have more, we instead store some variables in
// heap EnvironmentObjects.
// This limit is a performance heuristic. Stack slots reduce allocations,
// and `Local` opcodes are a bit faster than `AliasedVar` ones; but at each
// `yield` or `await` the stack slots must be memcpy'd into a
// GeneratorObject. At some point the memcpy is too much. The limit is
// plenty for typical human-authored code.
// NOTE: This just limits the number of fixed slots, not the entire stack
// slots. `yield` and `await` can happen with more slots if there
// are many stack values, and the number of values copied to the
// generator's stack storage array can be more than the limit.
static constexpr uint32_t FixedSlotLimit = 256;
// This is called as we leave a function, var, or lexical scope in a
// generator or async function. `ownSlotCount` is the number of `bindings_`
// that are not closed over.
void setOwnStackSlotCount(uint32_t ownSlotCount) {
uint32_t slotCount = ownSlotCount + innerScopeSlotCount();
if (slotCount > FixedSlotLimit) {
slotCount = innerScopeSlotCount();
} else {
// Propagate total size to enclosing scope.
if (Scope* parent = enclosing()) {
bool tooBigToOptimize() const {
// NOTE: This is called also for scopes in non-generator/non-async.
// generatorOrAsyncScopeInfo_ is used only from generator or async,
// and if it's not used, it holds the initial value, which is the
// same value as GeneratorOrAsyncScopeFlag::Optimizable.
static_assert(InnerScopeSlotCountInitialValue ==
MOZ_ASSERT(!isGeneratorOrAsyncScopeInfoUsed_ ||
return generatorOrAsyncScopeInfo_.optimizableFlag_ !=
// An iterator for the set of names a scope binds: the set of all
// declared names for 'var' scopes, and the set of lexically declared
// names, plus synthetic names, for non-'var' scopes.
class BindingIter {
friend class Scope;
DeclaredNameMap::Range declaredRange_;
mozilla::DebugOnly<uint32_t> count_;
bool isVarScope_;
BindingIter(Scope& scope, bool isVarScope)
: declaredRange_(scope.declared_->all()),
isVarScope_(isVarScope) {
bool isLexicallyDeclared() {
return BindingKindIsLexical(kind()) ||
kind() == BindingKind::Synthetic ||
kind() == BindingKind::PrivateMethod;
void settle() {
// Both var and lexically declared names are binding in a var
// scope.
if (isVarScope_) {
// Otherwise, only lexically declared names are binding. Pop the range
// until we find such a name.
while (!declaredRange_.empty()) {
if (isLexicallyDeclared()) {
bool done() const { return declaredRange_.empty(); }
explicit operator bool() const { return !done(); }
TaggedParserAtomIndex name() {
return declaredRange_.front().key();
DeclarationKind declarationKind() {
return declaredRange_.front().value()->kind();
BindingKind kind() {
return DeclarationKindToBindingKind(declarationKind());
bool closedOver() {
return declaredRange_.front().value()->closedOver();
void setClosedOver() {
return declaredRange_.front().value()->setClosedOver();
void operator++(int) {
MOZ_ASSERT(count_ != UINT32_MAX);
inline BindingIter bindings(ParseContext* pc);
class VarScope : public Scope {
explicit inline VarScope(ParserBase* parser);
explicit inline VarScope(FrontendContext* fc, ParseContext* pc,
UsedNameTracker& usedNames);
// Context shared between parsing and bytecode generation.
SharedContext* sc_;
// A mechanism used for error reporting.
ErrorReporter& errorReporter_;
// The innermost statement, i.e., top of the statement stack.
Statement* innermostStatement_;
// The innermost scope, i.e., top of the scope stack.
// The outermost scope in the stack is usually varScope_. In the case of
// functions, the outermost scope is functionScope_, which may be
// varScope_. See comment above functionScope_.
Scope* innermostScope_;
// If isFunctionBox() and the function is a named lambda, the DeclEnv
// scope for named lambdas.
mozilla::Maybe<Scope> namedLambdaScope_;
// If isFunctionBox(), the scope for the function. If there are no
// parameter expressions, this is scope for the entire function. If there
// are parameter expressions, this holds the special function names
// ('.this', 'arguments') and the formal parameters.
mozilla::Maybe<Scope> functionScope_;
// The body-level scope. This always exists, but not necessarily at the
// beginning of parsing the script in the case of functions with parameter
// expressions.
Scope* varScope_;
// Simple formal parameter names, in order of appearance. Only used when
// isFunctionBox().
PooledVectorPtr<AtomVector> positionalFormalParameterNames_;
// Closed over binding names, in order of appearance. Null-delimited
// between scopes. Only used when syntax parsing.
PooledVectorPtr<AtomVector> closedOverBindingsForLazy_;
// All inner functions in this context. Only used when syntax parsing.
// The Functions (or FunctionCreateionDatas) are traced as part of the
// CompilationStencil function vector.
Vector<ScriptIndex, 4> innerFunctionIndexesForLazy;
// In a function context, points to a Directive struct that can be updated
// to reflect new directives encountered in the Directive Prologue that
// require reparsing the function. In global/module/generator-tail contexts,
// we don't need to reparse when encountering a DirectivePrologue so this
// pointer may be nullptr.
Directives* newDirectives;
// lastYieldOffset stores the offset of the last yield that was parsed.
// NoYieldOffset is its initial value.
static const uint32_t NoYieldOffset = UINT32_MAX;
uint32_t lastYieldOffset;
// lastAwaitOffset stores the offset of the last await that was parsed.
// NoAwaitOffset is its initial value.
static const uint32_t NoAwaitOffset = UINT32_MAX;
uint32_t lastAwaitOffset;
// Monotonically increasing id.
uint32_t scriptId_;
// Set when encountering a inside a method. We need to mark
// the nearest super scope as needing a home object.
bool superScopeNeedsHomeObject_;
ParseContext(FrontendContext* fc, ParseContext*& parent, SharedContext* sc,
ErrorReporter& errorReporter, CompilationState& compilationState,
Directives* newDirectives, bool isFull);
[[nodiscard]] bool init();
SharedContext* sc() { return sc_; }
// `true` if we are in the body of a function definition.
bool isFunctionBox() const { return sc_->isFunctionBox(); }
FunctionBox* functionBox() { return sc_->asFunctionBox(); }
Statement* innermostStatement() { return innermostStatement_; }
Scope* innermostScope() {
// There is always at least one scope: the 'var' scope.
return innermostScope_;
Scope& namedLambdaScope() {
return *namedLambdaScope_;
Scope& functionScope() {
return *functionScope_;
Scope& varScope() {
return *varScope_;
bool isFunctionExtraBodyVarScopeInnermost() {
return isFunctionBox() && functionBox()->hasParameterExprs &&
innermostScope() == varScope_;
template <typename Predicate /* (Statement*) -> bool */>
Statement* findInnermostStatement(Predicate predicate) {
return Statement::findNearest(innermostStatement_, predicate);
template <typename T, typename Predicate /* (Statement*) -> bool */>
T* findInnermostStatement(Predicate predicate) {
return Statement::findNearest<T>(innermostStatement_, predicate);
template <typename T>
T* findInnermostStatement() {
return Statement::findNearest<T>(innermostStatement_);
AtomVector& positionalFormalParameterNames() {
return *positionalFormalParameterNames_;
AtomVector& closedOverBindingsForLazy() {
return *closedOverBindingsForLazy_;
enum class BreakStatementError : uint8_t {
// Unlabeled break must be inside loop or switch.
// Return Err(true) if we have encountered at least one loop,
// Err(false) otherwise.
[[nodiscard]] inline JS::Result<Ok, BreakStatementError> checkBreakStatement(
TaggedParserAtomIndex label);
enum class ContinueStatementError : uint8_t {
[[nodiscard]] inline JS::Result<Ok, ContinueStatementError>
checkContinueStatement(TaggedParserAtomIndex label);
// True if we are at the topmost level of a entire script or function body.
// For example, while parsing this code we would encounter f1 and f2 at
// body level, but we would not encounter f3 or f4 at body level:
// function f1() { function f2() { } }
// if (cond) { function f3() { if (cond) { function f4() { } } } }
bool atBodyLevel() { return !innermostStatement_; }
bool atGlobalLevel() { return atBodyLevel() && sc_->isGlobalContext(); }
// True if we are at the topmost level of a module only.
bool atModuleLevel() { return atBodyLevel() && sc_->isModuleContext(); }
// True if we are at the topmost level of an entire script or module. For
// example, in the comment on |atBodyLevel()| above, we would encounter |f1|
// and the outermost |if (cond)| at top level, and everything else would not
// be at top level.
bool atTopLevel() { return atBodyLevel() && sc_->isTopLevelContext(); }
bool atModuleTopLevel() {
// True if we are at the topmost level of an entire module.
// For example, this is used to determine if an await statement should
// mark a module as an async module during parsing.
// Example module:
// import x from "y";
// await; // mark as Top level await.
// if (cond) {
// await; // mark as Top level await.
// }
// async function z() {
// await x.baz(); // do not mark as Top level await.
// }
return sc_->isModuleContext() && sc_->isTopLevelContext();
// True if this is the outermost ParserContext for current compile. For
// delazification, this lets us identify if the lazy PrivateScriptData is for
// current parser context.
bool isOutermostOfCurrentCompile() const {
MOZ_ASSERT(!!enclosing() == !!scriptId());
return (scriptId() == 0);
void setSuperScopeNeedsHomeObject() {
superScopeNeedsHomeObject_ = true;
bool superScopeNeedsHomeObject() const { return superScopeNeedsHomeObject_; }
bool useAsmOrInsideUseAsm() const {
return sc_->isFunctionBox() && sc_->asFunctionBox()->useAsmOrInsideUseAsm();
// A generator is marked as a generator before its body is parsed.
GeneratorKind generatorKind() const {
return sc_->isFunctionBox() ? sc_->asFunctionBox()->generatorKind()
: GeneratorKind::NotGenerator;
bool isGenerator() const {
return generatorKind() == GeneratorKind::Generator;
bool isAsync() const {
return sc_->isSuspendableContext() &&
bool isGeneratorOrAsync() const { return isGenerator() || isAsync(); }
bool needsDotGeneratorName() const { return isGeneratorOrAsync(); }
FunctionAsyncKind asyncKind() const {
return isAsync() ? FunctionAsyncKind::AsyncFunction
: FunctionAsyncKind::SyncFunction;
bool isArrowFunction() const {
return sc_->isFunctionBox() && sc_->asFunctionBox()->isArrow();
bool isMethod() const {
return sc_->isFunctionBox() && sc_->asFunctionBox()->isMethod();
bool isGetterOrSetter() const {
return sc_->isFunctionBox() && (sc_->asFunctionBox()->isGetter() ||
bool allowReturn() const {
return sc_->isFunctionBox() && sc_->asFunctionBox()->allowReturn();
uint32_t scriptId() const { return scriptId_; }
bool computeAnnexBAppliesToLexicalFunctionInInnermostScope(
FunctionBox* funbox, ParserBase* parser, bool* annexBApplies);
bool tryDeclareVar(TaggedParserAtomIndex name, ParserBase* parser,
DeclarationKind kind, uint32_t beginPos,
mozilla::Maybe<DeclarationKind>* redeclaredKind,
uint32_t* prevPos);
bool hasUsedName(const UsedNameTracker& usedNames,
TaggedParserAtomIndex name);
bool hasClosedOverName(const UsedNameTracker& usedNames,
TaggedParserAtomIndex name);
bool hasUsedFunctionSpecialName(const UsedNameTracker& usedNames,
TaggedParserAtomIndex name);
bool hasClosedOverFunctionSpecialName(const UsedNameTracker& usedNames,
TaggedParserAtomIndex name);
bool declareFunctionThis(const UsedNameTracker& usedNames,
bool canSkipLazyClosedOverBindings);
bool declareFunctionArgumentsObject(const UsedNameTracker& usedNames,
bool canSkipLazyClosedOverBindings);
bool declareNewTarget(const UsedNameTracker& usedNames,
bool canSkipLazyClosedOverBindings);
bool declareDotGeneratorName();
bool declareTopLevelDotGeneratorName();
// Used to determine if we have non-length uses of the arguments binding.
// This works by incrementing this counter each time we encounter the
// arguments name, and decrementing each time it is combined into
// arguments.length; as a result, if this is non-zero at the end of parsing,
// we have identified a non-length use of the arguments binding.
size_t numberOfArgumentsNames = 0;
[[nodiscard]] bool isVarRedeclaredInInnermostScope(
TaggedParserAtomIndex name, ParserBase* parser, DeclarationKind kind,
mozilla::Maybe<DeclarationKind>* out);
[[nodiscard]] bool isVarRedeclaredInEval(
TaggedParserAtomIndex name, ParserBase* parser, DeclarationKind kind,
mozilla::Maybe<DeclarationKind>* out);
enum DryRunOption { NotDryRun, DryRunInnermostScopeOnly };
template <DryRunOption dryRunOption>
bool tryDeclareVarHelper(TaggedParserAtomIndex name, ParserBase* parser,
DeclarationKind kind, uint32_t beginPos,
mozilla::Maybe<DeclarationKind>* redeclaredKind,
uint32_t* prevPos);
} // namespace frontend
} // namespace js
#endif // frontend_ParseContext_h