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 
31 namespace ark::es2panda::lexer {
32 class RegExpParser;
33 }  // namespace ark::es2panda::lexer
34 namespace ark::es2panda::parser {
35 using ENUMBITOPS_OPERATORS;
36 
37 enum 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 
58 class ParserImpl {
59 public:
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 
AsETSParser()74     ETSParser *AsETSParser()
75     {
76         ASSERT(IsETSParser());
77         return reinterpret_cast<ETSParser *>(this);
78     }
79 
AsETSParser() const80     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 
ErrorLogger()90     util::ErrorLogger *ErrorLogger()
91     {
92         return &errorLogger_;
93     }
94 
95 protected:
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);
ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr)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>
AllocNode(Args &&....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 
Allocator() const191     ArenaAllocator *Allocator() const
192     {
193         return program_->Allocator();
194     }
195 
196     bool CheckModuleAsModifier();
197 
198     // ETS extension
IsExternal() const199     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();
ConvertThisKeywordToIdentIfNecessary()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 
ParseFunctionTypeParameters()417     virtual ir::TSTypeParameterDeclaration *ParseFunctionTypeParameters()
418     {
419         return nullptr;
420     }
421 
ParseFunctionReturnType([[maybe_unused]] ParserStatus status)422     virtual ir::TypeNode *ParseFunctionReturnType([[maybe_unused]] ParserStatus status)
423     {
424         return nullptr;
425     }
426 
ParseFunctionThrowMarker([[maybe_unused]] const bool isRethrowsAllowed)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);
ValidateForInStatement()449     virtual void ValidateForInStatement() {};
450     virtual ir::Statement *ParseTryStatement();
451     virtual ir::ThrowStatement *ParseThrowStatement();
452     virtual ir::DebuggerStatement *ParseDebuggerStatement();
453     // NOLINTNEXTLINE(google-default-arguments)
ParseModuleDeclaration(StatementParsingFlags flags = StatementParsingFlags::NONE)454     virtual ir::Statement *ParseModuleDeclaration(StatementParsingFlags flags = StatementParsingFlags::NONE)
455     {
456         return ParsePotentialExpressionStatement(flags);
457     };
458 
ParseInterfaceDeclaration([[maybe_unused]] bool isStatic)459     virtual ir::Statement *ParseInterfaceDeclaration([[maybe_unused]] bool isStatic)
460     {
461         ThrowUnexpectedToken(lexer::TokenType::KEYW_INTERFACE);
462     }
463 
464     // NOLINTNEXTLINE(google-default-arguments)
ParseEnumDeclaration([[maybe_unused]] bool isConst = false, [[maybe_unused]] bool isStatic = false)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 
GetProgram() const477     Program *GetProgram() const
478     {
479         return program_;
480     }
481 
SetProgram(Program *program)482     void SetProgram(Program *program)
483     {
484         program_ = program;
485     }
486 
Lexer() const487     lexer::Lexer *Lexer() const
488     {
489         return lexer_;
490     }
491 
SetLexer(lexer::Lexer *lexer)492     void SetLexer(lexer::Lexer *lexer)
493     {
494         lexer_ = lexer;
495     }
496 
GetContext()497     ParserContext &GetContext()
498     {
499         return context_;
500     }
501 
GetContext() const502     const ParserContext &GetContext() const
503     {
504         return context_;
505     }
506 
GetOptions() const507     const CompilerOptions &GetOptions() const
508     {
509         return options_;
510     }
511 
ClassId()512     uint32_t &ClassId()
513     {
514         return classId_;
515     }
516 
517 private:
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 
528 template <>
529 struct enumbitops::IsAllowedType<ark::es2panda::parser::TypeAnnotationParsingOptions> : std::true_type {
530 };
531 
532 #endif
533