diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /js/src/frontend/SyntaxParseHandler.h | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'js/src/frontend/SyntaxParseHandler.h')
-rw-r--r-- | js/src/frontend/SyntaxParseHandler.h | 825 |
1 files changed, 825 insertions, 0 deletions
diff --git a/js/src/frontend/SyntaxParseHandler.h b/js/src/frontend/SyntaxParseHandler.h new file mode 100644 index 0000000000..aa06eaa246 --- /dev/null +++ b/js/src/frontend/SyntaxParseHandler.h @@ -0,0 +1,825 @@ +/* -*- 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 http://mozilla.org/MPL/2.0/. */ + +#ifndef frontend_SyntaxParseHandler_h +#define frontend_SyntaxParseHandler_h + +#include "mozilla/Assertions.h" +#include "mozilla/Maybe.h" // mozilla::Maybe +#include "mozilla/Result.h" // mozilla::Result, mozilla::UnusedZero + +#include <string.h> + +#include "jstypes.h" + +#include "frontend/CompilationStencil.h" // CompilationState +#include "frontend/FunctionSyntaxKind.h" // FunctionSyntaxKind +#include "frontend/NameAnalysisTypes.h" // PrivateNameKind +#include "frontend/ParseNode.h" +#include "frontend/ParserAtom.h" // TaggedParserAtomIndex +#include "frontend/TokenStream.h" + +namespace js { +namespace frontend { +enum SyntaxParseHandlerNode { + NodeFailure = 0, + NodeGeneric, + NodeGetProp, + NodeStringExprStatement, + NodeReturn, + NodeBreak, + NodeThrow, + NodeEmptyStatement, + + NodeVarDeclaration, + NodeLexicalDeclaration, + + // A non-arrow function expression with block body, from bog-standard + // ECMAScript. + NodeFunctionExpression, + + NodeFunctionArrow, + NodeFunctionStatement, + + // This is needed for proper assignment-target handling. ES6 formally + // requires function calls *not* pass IsValidSimpleAssignmentTarget, + // but at last check there were still sites with |f() = 5| and similar + // in code not actually executed (or at least not executed enough to be + // noticed). + NodeFunctionCall, + + NodeOptionalFunctionCall, + + // Node representing normal names which don't require any special + // casing. + NodeName, + + // Nodes representing the names "arguments" and "eval". + NodeArgumentsName, + NodeEvalName, + + // Node representing the "async" name, which may actually be a + // contextual keyword. + NodePotentialAsyncKeyword, + + // Node representing private names. + NodePrivateName, + + NodeDottedProperty, + NodeOptionalDottedProperty, + NodeElement, + NodeOptionalElement, + // A distinct node for [PrivateName], to make detecting delete this.#x + // detectable in syntax parse + NodePrivateMemberAccess, + NodeOptionalPrivateMemberAccess, + + // Destructuring target patterns can't be parenthesized: |([a]) = [3];| + // must be a syntax error. (We can't use NodeGeneric instead of these + // because that would trigger invalid-left-hand-side ReferenceError + // semantics when SyntaxError semantics are desired.) + NodeParenthesizedArray, + NodeParenthesizedObject, + + // In rare cases a parenthesized |node| doesn't have the same semantics + // as |node|. Each such node has a special Node value, and we use a + // different Node value to represent the parenthesized form. See also + // is{Unp,P}arenthesized*(Node), parenthesize(Node), and the various + // functions that deal in NodeUnparenthesized* below. + + // Valuable for recognizing potential destructuring patterns. + NodeUnparenthesizedArray, + NodeUnparenthesizedObject, + + // The directive prologue at the start of a FunctionBody or ScriptBody + // is the longest sequence (possibly empty) of string literal + // expression statements at the start of a function. Thus we need this + // to treat |"use strict";| as a possible Use Strict Directive and + // |("use strict");| as a useless statement. + NodeUnparenthesizedString, + + // For destructuring patterns an assignment element with + // an initializer expression is not allowed be parenthesized. + // i.e. |{x = 1} = obj| + NodeUnparenthesizedAssignment, + + // This node is necessary to determine if the base operand in an + // exponentiation operation is an unparenthesized unary expression. + // We want to reject |-2 ** 3|, but still need to allow |(-2) ** 3|. + NodeUnparenthesizedUnary, + + // This node is necessary to determine if the LHS of a property access is + // super related. + NodeSuperBase +}; + +} // namespace frontend +} // namespace js + +template <> +struct mozilla::detail::UnusedZero<js::frontend::SyntaxParseHandlerNode> { + static const bool value = true; +}; + +namespace js { +namespace frontend { + +// Parse handler used when processing the syntax in a block of code, to generate +// the minimal information which is required to detect syntax errors and allow +// bytecode to be emitted for outer functions. +// +// When parsing, we start at the top level with a full parse, and when possible +// only check the syntax for inner functions, so that they can be lazily parsed +// into bytecode when/if they first run. Checking the syntax of a function is +// several times faster than doing a full parse/emit, and lazy parsing improves +// both performance and memory usage significantly when pages contain large +// amounts of code that never executes (which happens often). +class SyntaxParseHandler { + // Remember the last encountered name or string literal during syntax parses. + TaggedParserAtomIndex lastAtom; + TokenPos lastStringPos; + + public: + struct NodeError {}; + + using Node = SyntaxParseHandlerNode; + + using NodeResult = mozilla::Result<Node, NodeError>; + using NodeErrorResult = mozilla::GenericErrorResult<NodeError>; + +#define DECLARE_TYPE(typeName) \ + using typeName##Type = Node; \ + using typeName##Result = mozilla::Result<Node, NodeError>; + FOR_EACH_PARSENODE_SUBCLASS(DECLARE_TYPE) +#undef DECLARE_TYPE + + using NullNode = Node; + + bool isNonArrowFunctionExpression(Node node) const { + return node == NodeFunctionExpression; + } + + bool isPropertyOrPrivateMemberAccess(Node node) { + return node == NodeDottedProperty || node == NodeElement || + node == NodePrivateMemberAccess; + } + + bool isOptionalPropertyOrPrivateMemberAccess(Node node) { + return node == NodeOptionalDottedProperty || node == NodeOptionalElement || + node == NodeOptionalPrivateMemberAccess; + } + + bool isFunctionCall(Node node) { + // Note: super() is a special form, *not* a function call. + return node == NodeFunctionCall; + } + + static bool isUnparenthesizedDestructuringPattern(Node node) { + return node == NodeUnparenthesizedArray || + node == NodeUnparenthesizedObject; + } + + static bool isParenthesizedDestructuringPattern(Node node) { + // Technically this isn't a destructuring target at all -- the grammar + // doesn't treat it as such. But we need to know when this happens to + // consider it a SyntaxError rather than an invalid-left-hand-side + // ReferenceError. + return node == NodeParenthesizedArray || node == NodeParenthesizedObject; + } + + public: + SyntaxParseHandler(FrontendContext* fc, CompilationState& compilationState) { + MOZ_ASSERT(!compilationState.input.isDelazifying()); + } + + static NullNode null() { return NodeFailure; } + static constexpr NodeErrorResult errorResult() { + return NodeErrorResult(NodeError()); + } + +#define DECLARE_AS(typeName) \ + static typeName##Type as##typeName(Node node) { return node; } + FOR_EACH_PARSENODE_SUBCLASS(DECLARE_AS) +#undef DECLARE_AS + + NameNodeResult newName(TaggedParserAtomIndex name, const TokenPos& pos) { + lastAtom = name; + if (name == TaggedParserAtomIndex::WellKnown::arguments()) { + return NodeArgumentsName; + } + if (pos.begin + strlen("async") == pos.end && + name == TaggedParserAtomIndex::WellKnown::async()) { + return NodePotentialAsyncKeyword; + } + if (name == TaggedParserAtomIndex::WellKnown::eval()) { + return NodeEvalName; + } + return NodeName; + } + + UnaryNodeResult newComputedName(Node expr, uint32_t start, uint32_t end) { + return NodeGeneric; + } + + UnaryNodeResult newSyntheticComputedName(Node expr, uint32_t start, + uint32_t end) { + return NodeGeneric; + } + + NameNodeResult newObjectLiteralPropertyName(TaggedParserAtomIndex atom, + const TokenPos& pos) { + return NodeName; + } + + NameNodeResult newPrivateName(TaggedParserAtomIndex atom, + const TokenPos& pos) { + return NodePrivateName; + } + + NumericLiteralResult newNumber(double value, DecimalPoint decimalPoint, + const TokenPos& pos) { + return NodeGeneric; + } + + BigIntLiteralResult newBigInt() { return NodeGeneric; } + + BooleanLiteralResult newBooleanLiteral(bool cond, const TokenPos& pos) { + return NodeGeneric; + } + + NameNodeResult newStringLiteral(TaggedParserAtomIndex atom, + const TokenPos& pos) { + lastAtom = atom; + lastStringPos = pos; + return NodeUnparenthesizedString; + } + + NameNodeResult newTemplateStringLiteral(TaggedParserAtomIndex atom, + const TokenPos& pos) { + return NodeGeneric; + } + + CallSiteNodeResult newCallSiteObject(uint32_t begin) { return NodeGeneric; } + + void addToCallSiteObject(CallSiteNodeType callSiteObj, Node rawNode, + Node cookedNode) {} + + ThisLiteralResult newThisLiteral(const TokenPos& pos, Node thisName) { + return NodeGeneric; + } + NullLiteralResult newNullLiteral(const TokenPos& pos) { return NodeGeneric; } + RawUndefinedLiteralResult newRawUndefinedLiteral(const TokenPos& pos) { + return NodeGeneric; + } + + RegExpLiteralResult newRegExp(Node reobj, const TokenPos& pos) { + return NodeGeneric; + } + + ConditionalExpressionResult newConditional(Node cond, Node thenExpr, + Node elseExpr) { + return NodeGeneric; + } + + UnaryNodeResult newDelete(uint32_t begin, Node expr) { + return NodeUnparenthesizedUnary; + } + + UnaryNodeResult newTypeof(uint32_t begin, Node kid) { + return NodeUnparenthesizedUnary; + } + + UnaryNodeResult newUnary(ParseNodeKind kind, uint32_t begin, Node kid) { + return NodeUnparenthesizedUnary; + } + + UnaryNodeResult newUpdate(ParseNodeKind kind, uint32_t begin, Node kid) { + return NodeGeneric; + } + + UnaryNodeResult newSpread(uint32_t begin, Node kid) { return NodeGeneric; } + + NodeResult appendOrCreateList(ParseNodeKind kind, Node left, Node right, + ParseContext* pc) { + return NodeGeneric; + } + + // Expressions + + ListNodeResult newArrayLiteral(uint32_t begin) { + return NodeUnparenthesizedArray; + } + [[nodiscard]] bool addElision(ListNodeType literal, const TokenPos& pos) { + return true; + } + [[nodiscard]] bool addSpreadElement(ListNodeType literal, uint32_t begin, + Node inner) { + return true; + } + void addArrayElement(ListNodeType literal, Node element) {} + + ListNodeResult newArguments(const TokenPos& pos) { return NodeGeneric; } + CallNodeResult newCall(Node callee, ListNodeType args, JSOp callOp) { + return NodeFunctionCall; + } + + CallNodeResult newOptionalCall(Node callee, ListNodeType args, JSOp callOp) { + return NodeOptionalFunctionCall; + } + + CallNodeResult newSuperCall(Node callee, ListNodeType args, bool isSpread) { + return NodeGeneric; + } + CallNodeResult newTaggedTemplate(Node tag, ListNodeType args, JSOp callOp) { + return NodeGeneric; + } + + ListNodeResult newObjectLiteral(uint32_t begin) { + return NodeUnparenthesizedObject; + } + +#ifdef ENABLE_RECORD_TUPLE + ListNodeResult newRecordLiteral(uint32_t begin) { return NodeGeneric; } + + ListNodeResult newTupleLiteral(uint32_t begin) { return NodeGeneric; } +#endif + + ListNodeResult newClassMemberList(uint32_t begin) { return NodeGeneric; } + ClassNamesResult newClassNames(Node outer, Node inner, const TokenPos& pos) { + return NodeGeneric; + } + ClassNodeResult newClass(Node name, Node heritage, Node methodBlock, +#ifdef ENABLE_DECORATORS + ListNodeType decorators, + FunctionNodeType addInitializerFunction, +#endif + const TokenPos& pos) { + return NodeGeneric; + } + + LexicalScopeNodeResult newLexicalScope(Node body) { + return NodeLexicalDeclaration; + } + + ClassBodyScopeNodeResult newClassBodyScope(Node body) { + return NodeLexicalDeclaration; + } + + NewTargetNodeResult newNewTarget(NullaryNodeType newHolder, + NullaryNodeType targetHolder, + NameNodeType newTargetName) { + return NodeGeneric; + } + NullaryNodeResult newPosHolder(const TokenPos& pos) { return NodeGeneric; } + UnaryNodeResult newSuperBase(Node thisName, const TokenPos& pos) { + return NodeSuperBase; + } + + [[nodiscard]] bool addPrototypeMutation(ListNodeType literal, uint32_t begin, + Node expr) { + return true; + } + BinaryNodeResult newPropertyDefinition(Node key, Node val) { + return NodeGeneric; + } + void addPropertyDefinition(ListNodeType literal, BinaryNodeType propdef) {} + [[nodiscard]] bool addPropertyDefinition(ListNodeType literal, Node key, + Node expr) { + return true; + } + [[nodiscard]] bool addShorthand(ListNodeType literal, NameNodeType name, + NameNodeType expr) { + return true; + } + [[nodiscard]] bool addSpreadProperty(ListNodeType literal, uint32_t begin, + Node inner) { + return true; + } + [[nodiscard]] bool addObjectMethodDefinition(ListNodeType literal, Node key, + FunctionNodeType funNode, + AccessorType atype) { + return true; + } + [[nodiscard]] NodeResult newDefaultClassConstructor( + Node key, FunctionNodeType funNode) { + return NodeGeneric; + } + [[nodiscard]] NodeResult newClassMethodDefinition( + Node key, FunctionNodeType funNode, AccessorType atype, bool isStatic, + mozilla::Maybe<FunctionNodeType> initializerIfPrivate +#ifdef ENABLE_DECORATORS + , + ListNodeType decorators +#endif + ) { + return NodeGeneric; + } + [[nodiscard]] NodeResult newClassFieldDefinition( + Node name, FunctionNodeType initializer, bool isStatic +#ifdef ENABLE_DECORATORS + , + ListNodeType decorators, ClassMethodType accessorGetterNode, + ClassMethodType accessorSetterNode +#endif + ) { + return NodeGeneric; + } + + [[nodiscard]] NodeResult newStaticClassBlock(FunctionNodeType block) { + return NodeGeneric; + } + + [[nodiscard]] bool addClassMemberDefinition(ListNodeType memberList, + Node member) { + return true; + } + UnaryNodeResult newYieldExpression(uint32_t begin, Node value) { + return NodeGeneric; + } + UnaryNodeResult newYieldStarExpression(uint32_t begin, Node value) { + return NodeGeneric; + } + UnaryNodeResult newAwaitExpression(uint32_t begin, Node value) { + return NodeUnparenthesizedUnary; + } + UnaryNodeResult newOptionalChain(uint32_t begin, Node value) { + return NodeGeneric; + } + + // Statements + + ListNodeResult newStatementList(const TokenPos& pos) { return NodeGeneric; } + void addStatementToList(ListNodeType list, Node stmt) {} + void setListEndPosition(ListNodeType list, const TokenPos& pos) {} + void addCaseStatementToList(ListNodeType list, CaseClauseType caseClause) {} + [[nodiscard]] bool prependInitialYield(ListNodeType stmtList, Node genName) { + return true; + } + NullaryNodeResult newEmptyStatement(const TokenPos& pos) { + return NodeEmptyStatement; + } + + BinaryNodeResult newImportAttribute(Node keyNode, Node valueNode) { + return NodeGeneric; + } + BinaryNodeResult newModuleRequest(Node moduleSpec, Node importAttributeList, + const TokenPos& pos) { + return NodeGeneric; + } + BinaryNodeResult newImportDeclaration(Node importSpecSet, Node moduleRequest, + const TokenPos& pos) { + return NodeGeneric; + } + BinaryNodeResult newImportSpec(Node importNameNode, Node bindingName) { + return NodeGeneric; + } + UnaryNodeResult newImportNamespaceSpec(uint32_t begin, Node bindingName) { + return NodeGeneric; + } + UnaryNodeResult newExportDeclaration(Node kid, const TokenPos& pos) { + return NodeGeneric; + } + BinaryNodeResult newExportFromDeclaration(uint32_t begin, Node exportSpecSet, + Node moduleRequest) { + return NodeGeneric; + } + BinaryNodeResult newExportDefaultDeclaration(Node kid, Node maybeBinding, + const TokenPos& pos) { + return NodeGeneric; + } + BinaryNodeResult newExportSpec(Node bindingName, Node exportName) { + return NodeGeneric; + } + UnaryNodeResult newExportNamespaceSpec(uint32_t begin, Node exportName) { + return NodeGeneric; + } + NullaryNodeResult newExportBatchSpec(const TokenPos& pos) { + return NodeGeneric; + } + BinaryNodeResult newImportMeta(NullaryNodeType importHolder, + NullaryNodeType metaHolder) { + return NodeGeneric; + } + BinaryNodeResult newCallImport(NullaryNodeType importHolder, Node singleArg) { + return NodeGeneric; + } + BinaryNodeResult newCallImportSpec(Node specifierArg, Node optionalArg) { + return NodeGeneric; + } + + BinaryNodeResult newSetThis(Node thisName, Node value) { return value; } + + UnaryNodeResult newExprStatement(Node expr, uint32_t end) { + return expr == NodeUnparenthesizedString ? NodeStringExprStatement + : NodeGeneric; + } + + TernaryNodeResult newIfStatement(uint32_t begin, Node cond, Node thenBranch, + Node elseBranch) { + return NodeGeneric; + } + BinaryNodeResult newDoWhileStatement(Node body, Node cond, + const TokenPos& pos) { + return NodeGeneric; + } + BinaryNodeResult newWhileStatement(uint32_t begin, Node cond, Node body) { + return NodeGeneric; + } + SwitchStatementResult newSwitchStatement( + uint32_t begin, Node discriminant, + LexicalScopeNodeType lexicalForCaseList, bool hasDefault) { + return NodeGeneric; + } + CaseClauseResult newCaseOrDefault(uint32_t begin, Node expr, Node body) { + return NodeGeneric; + } + ContinueStatementResult newContinueStatement(TaggedParserAtomIndex label, + const TokenPos& pos) { + return NodeGeneric; + } + BreakStatementResult newBreakStatement(TaggedParserAtomIndex label, + const TokenPos& pos) { + return NodeBreak; + } + UnaryNodeResult newReturnStatement(Node expr, const TokenPos& pos) { + return NodeReturn; + } + UnaryNodeResult newExpressionBody(Node expr) { return NodeReturn; } + BinaryNodeResult newWithStatement(uint32_t begin, Node expr, Node body) { + return NodeGeneric; + } + + LabeledStatementResult newLabeledStatement(TaggedParserAtomIndex label, + Node stmt, uint32_t begin) { + return NodeGeneric; + } + + UnaryNodeResult newThrowStatement(Node expr, const TokenPos& pos) { + return NodeThrow; + } + TernaryNodeResult newTryStatement(uint32_t begin, Node body, + LexicalScopeNodeType catchScope, + Node finallyBlock) { + return NodeGeneric; + } + DebuggerStatementResult newDebuggerStatement(const TokenPos& pos) { + return NodeGeneric; + } + + NameNodeResult newPropertyName(TaggedParserAtomIndex name, + const TokenPos& pos) { + lastAtom = name; + return NodeGeneric; + } + + PropertyAccessResult newPropertyAccess(Node expr, NameNodeType key) { + return NodeDottedProperty; + } + + PropertyAccessResult newOptionalPropertyAccess(Node expr, NameNodeType key) { + return NodeOptionalDottedProperty; + } + + PropertyByValueResult newPropertyByValue(Node lhs, Node index, uint32_t end) { + MOZ_ASSERT(!isPrivateName(index)); + return NodeElement; + } + + PropertyByValueResult newOptionalPropertyByValue(Node lhs, Node index, + uint32_t end) { + return NodeOptionalElement; + } + + PrivateMemberAccessResult newPrivateMemberAccess(Node lhs, Node privateName, + uint32_t end) { + return NodePrivateMemberAccess; + } + + PrivateMemberAccessResult newOptionalPrivateMemberAccess(Node lhs, + Node privateName, + uint32_t end) { + return NodeOptionalPrivateMemberAccess; + } + + [[nodiscard]] bool setupCatchScope(LexicalScopeNodeType lexicalScope, + Node catchName, Node catchBody) { + return true; + } + + [[nodiscard]] bool setLastFunctionFormalParameterDefault( + FunctionNodeType funNode, Node defaultValue) { + return true; + } + + void checkAndSetIsDirectRHSAnonFunction(Node pn) {} + + ParamsBodyNodeResult newParamsBody(const TokenPos& pos) { + return NodeGeneric; + } + + FunctionNodeResult newFunction(FunctionSyntaxKind syntaxKind, + const TokenPos& pos) { + switch (syntaxKind) { + case FunctionSyntaxKind::Statement: + return NodeFunctionStatement; + case FunctionSyntaxKind::Arrow: + return NodeFunctionArrow; + default: + // All non-arrow function expressions are initially presumed to have + // block body. This will be overridden later *if* the function + // expression permissibly has an AssignmentExpression body. + return NodeFunctionExpression; + } + } + + void setFunctionFormalParametersAndBody(FunctionNodeType funNode, + ParamsBodyNodeType paramsBody) {} + void setFunctionBody(FunctionNodeType funNode, LexicalScopeNodeType body) {} + void setFunctionBox(FunctionNodeType funNode, FunctionBox* funbox) {} + void addFunctionFormalParameter(FunctionNodeType funNode, Node argpn) {} + + ForNodeResult newForStatement(uint32_t begin, TernaryNodeType forHead, + Node body, unsigned iflags) { + return NodeGeneric; + } + + TernaryNodeResult newForHead(Node init, Node test, Node update, + const TokenPos& pos) { + return NodeGeneric; + } + + TernaryNodeResult newForInOrOfHead(ParseNodeKind kind, Node target, + Node iteratedExpr, const TokenPos& pos) { + return NodeGeneric; + } + + AssignmentNodeResult finishInitializerAssignment(NameNodeType nameNode, + Node init) { + return NodeUnparenthesizedAssignment; + } + + void setBeginPosition(Node pn, Node oth) {} + void setBeginPosition(Node pn, uint32_t begin) {} + + void setEndPosition(Node pn, Node oth) {} + void setEndPosition(Node pn, uint32_t end) {} + + uint32_t getFunctionNameOffset(Node func, TokenStreamAnyChars& ts) { + // XXX This offset isn't relevant to the offending function name. But + // we may not *have* that function name around, because of how lazy + // parsing works -- the actual name could be outside + // |tokenStream.userbuf|'s observed region. So the current offset + // is the best we can do. + return ts.currentToken().pos.begin; + } + + ListNodeResult newList(ParseNodeKind kind, const TokenPos& pos) { + MOZ_ASSERT(kind != ParseNodeKind::VarStmt); + MOZ_ASSERT(kind != ParseNodeKind::LetDecl); + MOZ_ASSERT(kind != ParseNodeKind::ConstDecl); + MOZ_ASSERT(kind != ParseNodeKind::ParamsBody); + return NodeGeneric; + } + + ListNodeResult newList(ParseNodeKind kind, Node kid) { + return newList(kind, TokenPos()); + } + + DeclarationListNodeResult newDeclarationList(ParseNodeKind kind, + const TokenPos& pos) { + if (kind == ParseNodeKind::VarStmt) { + return NodeVarDeclaration; + } + MOZ_ASSERT(kind == ParseNodeKind::LetDecl || + kind == ParseNodeKind::ConstDecl); + return NodeLexicalDeclaration; + } + + ListNodeResult newCommaExpressionList(Node kid) { return NodeGeneric; } + + void addList(ListNodeType list, Node kid) { + MOZ_ASSERT(list == NodeGeneric || list == NodeUnparenthesizedArray || + list == NodeUnparenthesizedObject || + list == NodeVarDeclaration || list == NodeLexicalDeclaration || + list == NodeFunctionCall); + } + + CallNodeResult newNewExpression(uint32_t begin, Node ctor, ListNodeType args, + bool isSpread) { + return NodeGeneric; + } + + AssignmentNodeResult newAssignment(ParseNodeKind kind, Node lhs, Node rhs) { + return kind == ParseNodeKind::AssignExpr ? NodeUnparenthesizedAssignment + : NodeGeneric; + } + + AssignmentNodeResult newInitExpr(Node lhs, Node rhs) { return NodeGeneric; } + + bool isUnparenthesizedAssignment(Node node) { + return node == NodeUnparenthesizedAssignment; + } + + bool isUnparenthesizedUnaryExpression(Node node) { + return node == NodeUnparenthesizedUnary; + } + + bool isReturnStatement(Node node) { return node == NodeReturn; } + + bool isStatementPermittedAfterReturnStatement(Node pn) { + return pn == NodeFunctionStatement || isNonArrowFunctionExpression(pn) || + pn == NodeVarDeclaration || pn == NodeBreak || pn == NodeThrow || + pn == NodeEmptyStatement; + } + + bool isSuperBase(Node pn) { return pn == NodeSuperBase; } + + void setListHasNonConstInitializer(ListNodeType literal) {} + + // NOTE: This is infallible. + [[nodiscard]] Node parenthesize(Node node) { + // A number of nodes have different behavior upon parenthesization, but + // only in some circumstances. Convert these nodes to special + // parenthesized forms. + if (node == NodeUnparenthesizedArray) { + return NodeParenthesizedArray; + } + if (node == NodeUnparenthesizedObject) { + return NodeParenthesizedObject; + } + + // Other nodes need not be recognizable after parenthesization; convert + // them to a generic node. + if (node == NodeUnparenthesizedString || + node == NodeUnparenthesizedAssignment || + node == NodeUnparenthesizedUnary) { + return NodeGeneric; + } + + // Convert parenthesized |async| to a normal name node. + if (node == NodePotentialAsyncKeyword) { + return NodeName; + } + + // In all other cases, the parenthesized form of |node| is equivalent + // to the unparenthesized form: return |node| unchanged. + return node; + } + + // NOTE: This is infallible. + template <typename NodeType> + [[nodiscard]] NodeType setLikelyIIFE(NodeType node) { + return node; // Remain in syntax-parse mode. + } + + bool isName(Node node) { + return node == NodeName || node == NodeArgumentsName || + node == NodeEvalName || node == NodePotentialAsyncKeyword; + } + + bool isArgumentsName(Node node) { return node == NodeArgumentsName; } + bool isEvalName(Node node) { return node == NodeEvalName; } + bool isAsyncKeyword(Node node) { return node == NodePotentialAsyncKeyword; } + + bool isPrivateName(Node node) { return node == NodePrivateName; } + bool isPrivateMemberAccess(Node node) { + return node == NodePrivateMemberAccess; + } + + TaggedParserAtomIndex maybeDottedProperty(Node node) { + // Note: |super.apply(...)| is a special form that calls an "apply" + // method retrieved from one value, but using a *different* value as + // |this|. It's not really eligible for the funapply/funcall + // optimizations as they're currently implemented (assuming a single + // value is used for both retrieval and |this|). + if (node != NodeDottedProperty && node != NodeOptionalDottedProperty) { + return TaggedParserAtomIndex::null(); + } + return lastAtom; + } + + TaggedParserAtomIndex isStringExprStatement(Node pn, TokenPos* pos) { + if (pn == NodeStringExprStatement) { + *pos = lastStringPos; + return lastAtom; + } + return TaggedParserAtomIndex::null(); + } + + bool reuseLazyInnerFunctions() { return false; } + bool reuseClosedOverBindings() { return false; } + TaggedParserAtomIndex nextLazyClosedOverBinding() { + MOZ_CRASH( + "SyntaxParseHandler::canSkipLazyClosedOverBindings must return false"); + } + + void setPrivateNameKind(Node node, PrivateNameKind kind) {} +}; + +} // namespace frontend +} // namespace js + +#endif /* frontend_SyntaxParseHandler_h */ |