1/**
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#ifndef ES2PANDA_PARSER_CORE_PARSER_IMPL_H
17#define ES2PANDA_PARSER_CORE_PARSER_IMPL_H
18
19#include "es2panda.h"
20#include "forwardDeclForParserImpl.h"
21#include "ir/base/scriptFunctionSignature.h"
22#include "lexer/token/sourceLocation.h"
23#include "lexer/token/tokenType.h"
24#include "parser/context/classPrivateContext.h"
25#include "parser/context/parserContext.h"
26#include "parser/parserFlags.h"
27#include "parser/program/program.h"
28#include "util/errorLogger.h"
29#include "util/helpers.h"
30
31namespace ark::es2panda::lexer {
32class RegExpParser;
33}  // namespace ark::es2panda::lexer
34namespace ark::es2panda::parser {
35using ENUMBITOPS_OPERATORS;
36
37enum class TypeAnnotationParsingOptions : uint32_t {
38    NO_OPTS = 0U,
39    IN_UNION = 1U << 0U,
40    ALLOW_CONST = 1U << 1U,
41    IN_INTERSECTION = 1U << 2U,
42    RESTRICT_EXTENDS = 1U << 3U,
43    REPORT_ERROR = 1U << 4U,
44    CAN_BE_TS_TYPE_PREDICATE = 1U << 5U,
45    BREAK_AT_NEW_LINE = 1U << 6U,
46    RETURN_TYPE = 1U << 7U,
47    POTENTIAL_CLASS_LITERAL = 1U << 8U,
48    ALLOW_INTERSECTION = 1U << 9U,
49    ADD_TYPE_PARAMETER_BINDING = 1U << 10U,
50    DISALLOW_PRIMARY_TYPE = 1U << 11U,
51    ALLOW_WILDCARD = 1U << 12U,
52    IGNORE_FUNCTION_TYPE = 1U << 13U,
53    ALLOW_DECLARATION_SITE_VARIANCE = 1U << 14U,
54    DISALLOW_UNION = 1U << 15U,
55    POTENTIAL_NEW_ARRAY = 1U << 16U
56};
57
58class ParserImpl {
59public:
60    explicit ParserImpl(Program *program, const CompilerOptions &options, ParserStatus status = ParserStatus::NO_OPTS);
61    NO_COPY_SEMANTIC(ParserImpl);
62    NO_MOVE_SEMANTIC(ParserImpl);
63    virtual ~ParserImpl() = default;
64
65    void ParseScript(const SourceFile &sourceFile, bool genStdLib);
66
67    ScriptExtension Extension() const;
68
69    [[nodiscard]] virtual bool IsETSParser() const noexcept
70    {
71        return false;
72    }
73
74    ETSParser *AsETSParser()
75    {
76        ASSERT(IsETSParser());
77        return reinterpret_cast<ETSParser *>(this);
78    }
79
80    const ETSParser *AsETSParser() const
81    {
82        ASSERT(IsETSParser());
83        return reinterpret_cast<const ETSParser *>(this);
84    }
85
86    [[noreturn]] void ThrowSyntaxError(std::string_view errorMessage, const lexer::SourcePosition &pos) const;
87
88    void LogSyntaxError(std::string_view errorMessage, const lexer::SourcePosition &pos);
89
90    util::ErrorLogger *ErrorLogger()
91    {
92        return &errorLogger_;
93    }
94
95protected:
96    virtual void ParseProgram(ScriptKind kind);
97    static ExpressionParseFlags CarryExpressionParserFlag(ExpressionParseFlags origin, ExpressionParseFlags carry);
98    static ExpressionParseFlags CarryPatternFlags(ExpressionParseFlags flags);
99
100    void ThrowIfPrivateIdent(ClassElementDescriptor *desc, const char *msg);
101    void ValidateClassKey(ClassElementDescriptor *desc);
102    void ValidatePrivateIdentifier();
103
104    static ir::VariableDeclaratorFlag GetFlag(VariableParsingFlags flags);
105
106    void ThrowAllocationError(std::string_view message) const;
107
108    void ValidateAccessor(ExpressionParseFlags flags, lexer::TokenFlags currentTokenFlags);
109    void CheckPropertyKeyAsyncModifier(ParserStatus *methodStatus);
110    ir::Property *ParseShorthandProperty(const lexer::LexerPosition *startPos);
111    void ParseGeneratorPropertyModifier(ExpressionParseFlags flags, ParserStatus *methodStatus);
112    bool ParsePropertyModifiers(ExpressionParseFlags flags, ir::PropertyKind *propertyKind, ParserStatus *methodStatus);
113    ir::Expression *ParsePropertyValue(const ir::PropertyKind *propertyKind, const ParserStatus *methodStatus,
114                                       ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
115    bool ParsePropertyEnd();
116
117    // ExpressionParser.Cpp
118
119    ir::Expression *ParseKeywordExpression();
120    ir::Expression *ParseBinaryExpression(ir::Expression *left,
121                                          ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
122    void ValidateUpdateExpression(ir::Expression *returnExpression, bool isChainExpression);
123    ir::Expression *ParseMemberExpression(bool ignoreCallExpression = false,
124                                          ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
125    ir::Expression *SetupChainExpr(ir::Expression *const top, lexer::SourcePosition startLoc);
126    ir::MetaProperty *ParsePotentialNewTarget();
127    void CheckInvalidDestructuring(const ir::AstNode *object) const;
128    void ValidateParenthesizedExpression(ir::Expression *lhsExpression);
129    void ValidateGroupedExpression(ir::Expression *lhsExpression);
130    ir::Expression *ParseImportExpression();
131    ir::Expression *ParseOptionalChain(ir::Expression *leftSideExpr);
132    ir::Expression *ParsePropertyKey(ExpressionParseFlags flags);
133    void ValidateAssignmentTarget(ExpressionParseFlags flags, ir::Expression *node);
134    void ValidateLvalueAssignmentTarget(ir::Expression *node);
135    void ValidateArrowParameterBindings(const ir::Expression *node);
136    ir::Identifier *ParseNamedExport(const lexer::Token &exportedToken);
137    virtual void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) {}
138
139    // StatementParser.Cpp
140
141    void CheckFunctionDeclaration(StatementParsingFlags flags);
142    void CheckLabelledFunction(const ir::Statement *node);
143    bool ParseDirective(ArenaVector<ir::Statement *> *statements);
144    void ParseDirectivePrologue(ArenaVector<ir::Statement *> *statements);
145    ir::BlockStatement *ParseFunctionBody();
146    std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseIsForInOf(
147        ir::Expression *leftNode, ExpressionParseFlags exprFlags);
148    std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseForInOf(
149        ir::Expression *leftNode, ExpressionParseFlags exprFlags, bool isAwait);
150    std::tuple<ForStatementKind, ir::Expression *, ir::Expression *> ParseForInOf(ir::AstNode *initNode,
151                                                                                  ExpressionParseFlags exprFlags,
152                                                                                  bool isAwait);
153    std::tuple<ir::Expression *, ir::Expression *> ParseForUpdate(bool isAwait);
154    std::tuple<ir::Expression *, ir::AstNode *> ParseForLoopInitializer();
155    ir::SwitchCaseStatement *ParseSwitchCaseStatement(bool *seenDefault);
156    virtual ir::Expression *ParseCatchParam();
157    ir::CatchClause *ParseCatchClause();
158    ir::VariableDeclaration *ParseContextualLet(VariableParsingFlags flags,
159                                                StatementParsingFlags stmFlags = StatementParsingFlags::ALLOW_LEXICAL);
160
161    friend class Lexer;
162    friend class SavedParserContext;
163    friend class SavedClassPrivateContext;
164    friend class ArrowFunctionContext;
165    friend class ETSNolintParser;
166    friend class lexer::RegExpParser;
167
168    [[noreturn]] void ThrowParameterModifierError(ir::ModifierFlags status) const;
169    [[noreturn]] void ThrowUnexpectedToken(lexer::TokenType tokenType) const;
170    [[noreturn]] void ThrowExpectedToken(lexer::TokenType tokenType) const;
171    [[noreturn]] void ThrowSyntaxError(std::string_view errorMessage) const;
172    [[noreturn]] void ThrowSyntaxError(std::initializer_list<std::string_view> list) const;
173    [[noreturn]] void ThrowSyntaxError(std::initializer_list<std::string_view> list,
174                                       const lexer::SourcePosition &pos) const;
175    void LogExpectedToken(lexer::TokenType tokenType);
176    void LogSyntaxError(std::string_view errorMessage);
177    void LogSyntaxError(std::initializer_list<std::string_view> list);
178    void LogSyntaxError(std::initializer_list<std::string_view> list, const lexer::SourcePosition &pos);
179
180    template <typename T, typename... Args>
181    T *AllocNode(Args &&...args)
182    {
183        auto *ret = util::NodeAllocator::ForceSetParent<T>(
184            Allocator(), std::forward<Args>(args)...);  // Note: replace with AllocNode
185        if (ret == nullptr) {
186            ThrowAllocationError("Unsuccessful allocation during parsing");
187        }
188        return ret;
189    }
190
191    ArenaAllocator *Allocator() const
192    {
193        return program_->Allocator();
194    }
195
196    bool CheckModuleAsModifier();
197
198    // ETS extension
199    virtual bool IsExternal() const
200    {
201        return false;
202    }
203
204    util::StringView ParseSymbolIteratorIdentifier() const noexcept;
205    ir::Identifier *ExpectIdentifier(bool isReference = false, bool isUserDefinedType = false);
206    void ExpectToken(lexer::TokenType tokenType, bool consumeToken = true);
207
208    // ExpressionParser.cpp
209
210    ir::SpreadElement *ParseSpreadElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
211    ir::YieldExpression *ParseYieldExpression();
212    virtual ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags);
213    ir::ArrowFunctionExpression *ParseArrowFunctionExpressionBody(ArrowFunctionContext *arrowFunctionContext,
214                                                                  ArrowFunctionDescriptor *desc,
215                                                                  ir::TSTypeParameterDeclaration *typeParamDecl,
216                                                                  ir::TypeNode *returnTypeAnnotation);
217    ir::Expression *ParseAssignmentExpression(ir::Expression *lhsExpression,
218                                              ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
219    ir::Expression *ParseAssignmentBinaryExpression(lexer::TokenType tokenType, ir::Expression *lhsExpression,
220                                                    ExpressionParseFlags flags);
221    ir::Expression *ParseAssignmentEqualExpression(lexer::TokenType tokenType, ir::Expression *lhsExpression,
222                                                   ExpressionParseFlags flags);
223    ir::SequenceExpression *ParseSequenceExpression(ir::Expression *startExpr, bool acceptRest = false);
224    ir::FunctionExpression *ParseFunctionExpression(ParserStatus newStatus = ParserStatus::NO_OPTS);
225    ir::ArrowFunctionExpression *ParseArrowFunctionExpression(ir::Expression *expr,
226                                                              ir::TSTypeParameterDeclaration *typeParamDecl,
227                                                              ir::TypeNode *returnTypeAnnotation, bool isAsync);
228    ir::CallExpression *ParseCallExpression(ir::Expression *callee, bool isOptionalChain = false,
229                                            bool handleEval = true);
230    ArenaVector<ir::Expression *> ParseCallExpressionArguments(bool &trailingComma);
231
232    ir::TemplateLiteral *ParseTemplateLiteral();
233    ir::Expression *ParseLeftHandSideExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
234    void ParseNameSpaceImport(ArenaVector<ir::AstNode *> *specifiers);
235    void ParseNamedImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
236    ir::StringLiteral *ParseFromClause(bool requireFrom = true);
237
238    ir::BooleanLiteral *ParseBooleanLiteral();
239    ir::NullLiteral *ParseNullLiteral();
240    ir::Literal *ParseNumberLiteral();
241    ir::CharLiteral *ParseCharLiteral();
242    ir::StringLiteral *ParseStringLiteral();
243    ir::UndefinedLiteral *ParseUndefinedLiteral();
244    virtual ir::ThisExpression *ParseThisExpression();
245    ir::RegExpLiteral *ParseRegularExpression();
246    ir::SuperExpression *ParseSuperExpression();
247    ir::MemberExpression *ParseElementAccess(ir::Expression *primaryExpr, bool isOptional = false);
248    ir::MemberExpression *ParsePrivatePropertyAccess(ir::Expression *primaryExpr);
249    ir::MemberExpression *ParsePropertyAccess(ir::Expression *primaryExpr, bool isOptional = false);
250    void CreateAmendedBinaryExpression(ir::Expression *left, ir::Expression *right, lexer::TokenType operatorType);
251
252    // StatementParser
253    ArenaVector<ir::Statement *> ParseStatementList(StatementParsingFlags flags = StatementParsingFlags::ALLOW_LEXICAL);
254    virtual ir::Statement *ParseAssertStatement();
255    virtual void ValidateLabeledStatement(lexer::TokenType type);
256    ir::BlockStatement *ParseBlockStatement();
257    ir::EmptyStatement *ParseEmptyStatement();
258    ir::Statement *ParseForStatement();
259    ir::IfStatement *ParseIfStatement();
260    virtual ir::Statement *ParseFunctionStatement(StatementParsingFlags flags);
261    // NOLINTNEXTLINE(google-default-arguments)
262    virtual ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags,
263                                                      ir::ClassDefinitionModifiers modifiers,
264                                                      ir::ModifierFlags modFlags = ir::ModifierFlags::NONE);
265    // NOLINTNEXTLINE(google-default-arguments)
266    virtual ir::ETSStructDeclaration *ParseStructStatement(StatementParsingFlags flags,
267                                                           ir::ClassDefinitionModifiers modifiers,
268                                                           ir::ModifierFlags modFlags = ir::ModifierFlags::NONE);
269    ir::Statement *ParseVarStatement();
270    ir::Statement *ParseLetStatement(StatementParsingFlags flags);
271    ir::BreakStatement *ParseBreakStatement();
272    ir::ContinueStatement *ParseContinueStatement();
273    ir::DoWhileStatement *ParseDoWhileStatement();
274    ir::WhileStatement *ParseWhileStatement();
275    ir::SwitchStatement *ParseSwitchStatement();
276    ir::ReturnStatement *ParseReturnStatement();
277    ir::Statement *ParseExpressionStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
278    ir::LabelledStatement *ParseLabelledStatement(const lexer::LexerPosition &pos);
279    virtual void ValidateRestParameter(ir::Expression *param);
280    virtual bool ValidateBreakLabel(util::StringView label);
281    virtual bool ValidateContinueLabel(util::StringView label);
282    bool InAmbientContext();
283
284    ir::MethodDefinition *BuildImplicitConstructor(ir::ClassDefinitionModifiers modifiers,
285                                                   const lexer::SourcePosition &startLoc);
286
287    virtual void CreateImplicitConstructor(ir::MethodDefinition *&ctor, ArenaVector<ir::AstNode *> &properties,
288                                           ir::ClassDefinitionModifiers modifiers,
289                                           const lexer::SourcePosition &startLoc);
290    void CheckClassGeneratorMethod(ClassElementDescriptor *desc, char32_t *nextCp);
291    void ParseClassAccessor(ClassElementDescriptor *desc, char32_t *nextCp);
292    ir::Expression *ParseClassKey(ClassElementDescriptor *desc);
293    ir::ClassElement *ParseClassProperty(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
294                                         ir::Expression *propName, ir::TypeNode *typeAnnotation);
295    void AddPrivateElement(const ir::ClassElement *elem);
296    ir::ScriptFunction *ParseFunction(ParserStatus newStatus = ParserStatus::NO_OPTS);
297    ir::ModifierFlags GetAccessability(ir::ModifierFlags modifiers);
298    void CheckAccessorPair(const ArenaVector<ir::AstNode *> &properties, const ir::Expression *propName,
299                           ir::MethodDefinitionKind methodKind, ir::ModifierFlags access);
300    ir::Identifier *ParseNamedImport(const lexer::Token &importedToken);
301    void ConsumeSemicolon(ir::Statement *statement);
302    ir::ExportAllDeclaration *ParseExportAllDeclaration(const lexer::SourcePosition &startLoc);
303    ir::ExportNamedDeclaration *ParseExportNamedSpecifiers(const lexer::SourcePosition &startLoc);
304    ir::Statement *ParseVariableDeclaration(VariableParsingFlags flags = VariableParsingFlags::NO_OPTS);
305    void ValidateDeclaratorId();
306    void CheckRestrictedBinding() const;
307    void CheckRestrictedBinding(lexer::TokenType keywordType) const;
308    void CheckRestrictedBinding(const util::StringView &ident, const lexer::SourcePosition &pos) const;
309
310    ir::VariableDeclarator *ParseVariableDeclarator(VariableParsingFlags flags);
311    ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous = false,
312                                                      ParserStatus newStatus = ParserStatus::NO_OPTS);
313    ir::ETSStructDeclaration *ParseStructDeclaration(ir::ClassDefinitionModifiers modifiers,
314                                                     ir::ModifierFlags flags = ir::ModifierFlags::NONE);
315    ir::ClassDeclaration *ParseClassDeclaration(ir::ClassDefinitionModifiers modifiers,
316                                                ir::ModifierFlags flags = ir::ModifierFlags::NONE);
317    FunctionSignature ParseFunctionSignature(ParserStatus status, ir::Identifier *className = nullptr);
318
319    [[nodiscard]] virtual std::unique_ptr<lexer::Lexer> InitLexer(const SourceFile &sourceFile);
320    // NOLINTNEXTLINE(google-default-arguments)
321    virtual ir::Statement *ParseStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
322    // NOLINTNEXTLINE(google-default-arguments)
323    virtual ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
324    // NOLINTNEXTLINE(google-default-arguments)
325    virtual ir::Expression *ParseExpressionOrTypeAnnotation(lexer::TokenType type, ExpressionParseFlags flags);
326    // NOLINTNEXTLINE(google-default-arguments)
327    virtual ir::Expression *ParsePatternElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS,
328                                                bool allowDefault = true);
329    void ParsePatternElementErrorCheck(ExpressionParseFlags flags, bool allowDefault);
330    virtual bool ParsePotentialNonNullExpression(ir::Expression **returnExpression, lexer::SourcePosition startLoc);
331    virtual ir::AstNode *ParseImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
332    virtual ir::Statement *ParseImportDeclaration(StatementParsingFlags flags);
333    // NOLINTNEXTLINE(google-default-arguments)
334    virtual ir::Expression *ParsePropertyDefinition(
335        [[maybe_unused]] ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
336    // NOLINTNEXTLINE(google-default-arguments)
337    virtual ir::ObjectExpression *ParseObjectExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
338    // NOLINTNEXTLINE(google-default-arguments)
339    virtual ir::ArrayExpression *ParseArrayExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
340    void ParseArrayExpressionErrorCheck(ir::ArrayExpression *arrayExpressionNode, ExpressionParseFlags flags,
341                                        bool inPattern);
342    virtual ir::ArrowFunctionExpression *ParsePotentialArrowExpression(ir::Expression **returnExpression,
343                                                                       const lexer::SourcePosition &startLoc);
344    virtual bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression,
345                                                   const lexer::SourcePosition &startLoc, bool ignoreCallExpression);
346    virtual ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpression);
347    virtual bool IsNamedFunctionExpression();
348    virtual ir::Identifier *ParsePrimaryExpressionIdent(ExpressionParseFlags flags);
349    virtual void ValidateArrowFunctionRestParameter(ir::SpreadElement *restElement);
350    virtual ir::Statement *ParsePotentialExpressionStatement(StatementParsingFlags flags);
351    virtual ArenaVector<ir::Expression *> ParseFunctionParams();
352    virtual ir::Expression *CreateParameterThis(util::StringView className);
353    virtual ir::Expression *ParseFunctionParameter();
354    virtual void ConvertThisKeywordToIdentIfNecessary() {}
355    virtual void ParseCatchParamTypeAnnotation(ir::AnnotatedExpression *param);
356    // NOLINTNEXTLINE(google-default-arguments)
357    virtual ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers,
358                                                      ir::ModifierFlags flags = ir::ModifierFlags::NONE);
359    virtual ir::Identifier *ParseClassIdent(ir::ClassDefinitionModifiers modifiers);
360    virtual ir::Statement *ParsePotentialConstEnum(VariableParsingFlags flags);
361    virtual ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties,
362                                           ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags);
363    virtual bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor,
364                                   ArenaVector<ir::AstNode *> &properties);
365    virtual void ValidateClassMethodStart(ClassElementDescriptor *desc, ir::TypeNode *typeAnnotation);
366    virtual ir::MethodDefinition *ParseClassMethod(ClassElementDescriptor *desc,
367                                                   const ArenaVector<ir::AstNode *> &properties,
368                                                   ir::Expression *propName, lexer::SourcePosition *propEnd);
369    virtual void ValidateClassSetter(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
370                                     ir::Expression *propName, ir::ScriptFunction *func);
371    virtual void ValidateClassGetter(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
372                                     ir::Expression *propName, ir::ScriptFunction *func);
373    virtual ir::ModifierFlags ParseModifiers();
374    virtual ir::Statement *ParseConstStatement(StatementParsingFlags flags);
375
376    virtual ir::AnnotatedExpression *ParseVariableDeclaratorKey(VariableParsingFlags flags);
377    virtual ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc,
378                                                            VariableParsingFlags flags);
379    virtual ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
380                                                                       const lexer::SourcePosition &startLoc);
381    virtual bool IsModifierKind(const lexer::Token &token);
382    virtual void ConsumeClassPrivateIdentifier(ClassElementDescriptor *desc, char32_t *nextCp);
383    virtual void ThrowPossibleOutOfBoundaryJumpError(bool allowBreak);
384    virtual void ThrowIllegalBreakError();
385    virtual void ThrowIllegalContinueError();
386    virtual void ThrowIfBodyEmptyError(ir::Statement *consequent);
387    virtual void ThrowMultipleDefaultError();
388    virtual void ThrowIllegalNewLineErrorAfterThrow();
389    virtual void ThrowIfVarDeclaration(VariableParsingFlags flags);
390    virtual ir::Expression *ParsePrefixAssertionExpression();
391    // NOLINTNEXTLINE(google-default-arguments)
392    virtual ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList(
393        ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
394    virtual void ThrowErrorIfStaticConstructor(ir::ModifierFlags flags);
395    virtual std::tuple<bool, bool, bool> ParseComputedClassFieldOrIndexSignature(ir::Expression **propName);
396    // NOLINTNEXTLINE(google-default-arguments)
397    virtual ir::Expression *ParseUnaryOrPrefixUpdateExpression(
398        ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
399    virtual ir::Expression *ParsePrimaryExpressionWithLiterals(ExpressionParseFlags flags);
400    ir::Expression *ParseHashMaskOperator();
401    ir::Expression *ParseClassExpression();
402    ir::Expression *ParsePunctuators(ExpressionParseFlags flags);
403    // NOLINTNEXTLINE(google-default-arguments)
404    virtual ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
405    virtual ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc,
406                                                       bool ignoreCallExpression, bool *isChainExpression);
407    ir::Expression *ParsePostPrimaryExpressionBackTick(ir::Expression *returnExpression,
408                                                       lexer::SourcePosition startLoc);
409    ir::Expression *ParsePostPrimaryExpressionDot(ir::Expression *returnExpression, lexer::TokenType tokenType,
410                                                  bool *isChainExpression);
411    virtual ir::ClassElement *ParseClassStaticBlock();
412    virtual ParserStatus ValidateArrowParameter(ir::Expression *expr, bool *seenOptional);
413    void ValidateArrowParameterAssignment(ir::AssignmentExpression *expr);
414    virtual ArrowFunctionDescriptor ConvertToArrowParameter(ir::Expression *expr, bool isAsync);
415    virtual ir::Expression *ParseNewExpression();
416
417    virtual ir::TSTypeParameterDeclaration *ParseFunctionTypeParameters()
418    {
419        return nullptr;
420    }
421
422    virtual ir::TypeNode *ParseFunctionReturnType([[maybe_unused]] ParserStatus status)
423    {
424        return nullptr;
425    }
426
427    virtual ir::ScriptFunctionFlags ParseFunctionThrowMarker([[maybe_unused]] const bool isRethrowsAllowed)
428    {
429        return ir::ScriptFunctionFlags::NONE;
430    }
431
432    using NodeFormatType = std::tuple<bool, char, std::size_t>;
433    virtual ir::Identifier *ParseIdentifierFormatPlaceholder(std::optional<NodeFormatType> nodeFormat) const;
434    virtual ir::Statement *ParseStatementFormatPlaceholder() const;
435    virtual ir::AstNode *ParseTypeParametersFormatPlaceholder() const;
436    virtual ArenaVector<ir::AstNode *> &ParseAstNodesArrayFormatPlaceholder() const;
437    virtual ArenaVector<ir::Statement *> &ParseStatementsArrayFormatPlaceholder() const;
438    virtual ArenaVector<ir::Expression *> &ParseExpressionsArrayFormatPlaceholder() const;
439
440    virtual std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParseFunctionBody(
441        const ArenaVector<ir::Expression *> &params, ParserStatus newStatus, ParserStatus contextStatus);
442    virtual ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers);
443    virtual ir::Statement *ParseExportDeclaration(StatementParsingFlags flags);
444
445    // NOLINTNEXTLINE(google-default-arguments)
446    virtual ir::ExportDefaultDeclaration *ParseExportDefaultDeclaration(const lexer::SourcePosition &startLoc,
447                                                                        bool isExportEquals = false);
448    virtual ir::ExportNamedDeclaration *ParseNamedExportDeclaration(const lexer::SourcePosition &startLoc);
449    virtual void ValidateForInStatement() {};
450    virtual ir::Statement *ParseTryStatement();
451    virtual ir::ThrowStatement *ParseThrowStatement();
452    virtual ir::DebuggerStatement *ParseDebuggerStatement();
453    // NOLINTNEXTLINE(google-default-arguments)
454    virtual ir::Statement *ParseModuleDeclaration(StatementParsingFlags flags = StatementParsingFlags::NONE)
455    {
456        return ParsePotentialExpressionStatement(flags);
457    };
458
459    virtual ir::Statement *ParseInterfaceDeclaration([[maybe_unused]] bool isStatic)
460    {
461        ThrowUnexpectedToken(lexer::TokenType::KEYW_INTERFACE);
462    }
463
464    // NOLINTNEXTLINE(google-default-arguments)
465    virtual ir::Statement *ParseEnumDeclaration([[maybe_unused]] bool isConst = false,
466                                                [[maybe_unused]] bool isStatic = false)
467    {
468        ThrowUnexpectedToken(lexer::TokenType::KEYW_ENUM);
469    }
470
471    virtual std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseSuperClass();
472    virtual ir::Expression *ParseSuperClassReference();
473
474    using ClassBody = std::tuple<ir::MethodDefinition *, ArenaVector<ir::AstNode *>, lexer::SourceRange>;
475    ClassBody ParseClassBody(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags = ir::ModifierFlags::NONE);
476
477    Program *GetProgram() const
478    {
479        return program_;
480    }
481
482    void SetProgram(Program *program)
483    {
484        program_ = program;
485    }
486
487    lexer::Lexer *Lexer() const
488    {
489        return lexer_;
490    }
491
492    void SetLexer(lexer::Lexer *lexer)
493    {
494        lexer_ = lexer;
495    }
496
497    ParserContext &GetContext()
498    {
499        return context_;
500    }
501
502    const ParserContext &GetContext() const
503    {
504        return context_;
505    }
506
507    const CompilerOptions &GetOptions() const
508    {
509        return options_;
510    }
511
512    uint32_t &ClassId()
513    {
514        return classId_;
515    }
516
517private:
518    Program *program_;
519    ParserContext context_;
520    ClassPrivateContext classPrivateContext_;
521    uint32_t classId_ {};
522    lexer::Lexer *lexer_ {};
523    const CompilerOptions &options_;
524    util::ErrorLogger errorLogger_;
525};
526}  // namespace ark::es2panda::parser
527
528template <>
529struct enumbitops::IsAllowedType<ark::es2panda::parser::TypeAnnotationParsingOptions> : std::true_type {
530};
531
532#endif
533