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