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_ETS_PARSER_H
17#define ES2PANDA_PARSER_CORE_ETS_PARSER_H
18
19#include "util/arktsconfig.h"
20#include "util/importPathManager.h"
21#include "TypedParser.h"
22#include "ir/base/classDefinition.h"
23#include <utility>
24
25namespace ark::es2panda::ir {
26class ETSPackageDeclaration;
27enum class ClassDefinitionModifiers : uint32_t;
28enum class PrimitiveType;
29}  // namespace ark::es2panda::ir
30
31namespace ark::es2panda::parser {
32
33class ETSParser final : public TypedParser {
34public:
35    ETSParser(Program *program, const CompilerOptions &options, ParserStatus status = ParserStatus::NO_OPTS);
36
37    ETSParser() = delete;
38    NO_COPY_SEMANTIC(ETSParser);
39    NO_MOVE_SEMANTIC(ETSParser);
40
41    ~ETSParser() final = default;
42
43    [[nodiscard]] bool IsETSParser() const noexcept override;
44
45    void AddDirectImportsToDirectExternalSources(const ArenaVector<util::StringView> &directImportsFromMainSource,
46                                                 parser::Program *newProg) const;
47    ArenaVector<ir::ETSImportDeclaration *> ParseDefaultSources(std::string_view srcFile, std::string_view importSrc);
48
49public:
50    //============================================================================================//
51    // Methods to create AST node(s) from the specified string (part of valid ETS-code!)
52    // NOTE: ScopeInitPhase, SetParent should be called on created subtree after calling any of these methods,
53    //============================================================================================//
54
55    template <typename>
56    static constexpr bool STATIC_FALSE = false;
57
58    std::string_view FormattingFileName()
59    {
60        return GetContext().FormattingFileName();
61    }
62
63    template <typename T>
64    void SetFormattingFileName(T &&fileName)
65    {
66        GetContext().SetFormattingFileName(std::forward<T>(fileName));
67    }
68
69    template <typename T>
70    void ProcessFormattedArg(std::vector<ir::AstNode *> &nodes, T &&arg)
71    {
72        if constexpr (std::is_convertible_v<std::decay_t<T>, ir::AstNode *>) {
73            nodes.emplace_back(std::forward<T>(arg));
74        } else if constexpr (std::is_same_v<std::decay_t<T>, util::StringView>) {
75            nodes.emplace_back(AllocNode<ir::Identifier>(std::forward<T>(arg), Allocator()));
76        } else if constexpr (std::is_same_v<std::decay_t<T>, util::UString>) {
77            nodes.emplace_back(AllocNode<ir::Identifier>(arg.View(), Allocator()));
78        } else if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
79            nodes.emplace_back(
80                AllocNode<ir::Identifier>(util::UString(std::forward<T>(arg), Allocator()).View(), Allocator()));
81        } else if constexpr (std::is_constructible_v<std::string, std::decay_t<T>>) {
82            nodes.emplace_back(AllocNode<ir::Identifier>(
83                util::UString(std::string {std::forward<T>(arg)}, Allocator()).View(), Allocator()));
84        } else if constexpr (std::is_convertible_v<std::decay_t<T>, checker::Type *>) {
85            nodes.emplace_back(AllocNode<ir::OpaqueTypeNode>(std::forward<T>(arg)));
86        } else if constexpr (std::is_same_v<std::decay_t<T>, ArenaVector<ir::AstNode *>>) {
87            nodes.emplace_back(AllocNode<ir::TSInterfaceBody>(std::forward<T>(arg)));
88        } else if constexpr (std::is_same_v<std::decay_t<T>, ArenaVector<ir::Expression *>>) {
89            nodes.emplace_back(AllocNode<ir::SequenceExpression>(std::forward<T>(arg)));
90        } else if constexpr (std::is_same_v<std::decay_t<T>, ArenaVector<ir::Statement *>>) {
91            nodes.emplace_back(AllocNode<ir::BlockExpression>(std::forward<T>(arg)));
92        } else if constexpr (std::is_same_v<std::decay_t<T>, ArenaVector<checker::Type *>>) {
93            for (auto *type : arg) {
94                nodes.emplace_back(AllocNode<ir::OpaqueTypeNode>(type));
95            }
96        } else {
97            static_assert(STATIC_FALSE<T>, "Format argument has invalid type.");
98        }
99    }
100
101    ir::Expression *CreateExpression(std::string_view sourceCode,
102                                     ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
103
104    ir::Expression *CreateFormattedExpression(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes);
105
106    template <typename... Args>
107    ir::Expression *CreateFormattedExpression(std::string_view const sourceCode, Args &&...args)
108    {
109        std::vector<ir::AstNode *> insertingNodes {};
110        insertingNodes.reserve(sizeof...(Args));
111        (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...);
112        return CreateFormattedExpression(sourceCode, insertingNodes);
113    }
114
115    ir::Statement *CreateFormattedStatement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes);
116
117    template <typename... Args>
118    ir::Statement *CreateFormattedStatement(std::string_view const sourceCode, Args &&...args)
119    {
120        std::vector<ir::AstNode *> insertingNodes {};
121        insertingNodes.reserve(sizeof...(Args));
122        (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...);
123        return CreateFormattedStatement(sourceCode, insertingNodes);
124    }
125
126    ArenaVector<ir::Statement *> CreateStatements(std::string_view sourceCode);
127
128    ArenaVector<ir::Statement *> CreateFormattedStatements(std::string_view sourceCode,
129                                                           std::vector<ir::AstNode *> &insertingNodes);
130
131    template <typename... Args>
132    ArenaVector<ir::Statement *> CreateFormattedStatements(std::string_view const sourceCode, Args &&...args)
133    {
134        std::vector<ir::AstNode *> insertingNodes {};
135        insertingNodes.reserve(sizeof...(Args));
136        (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...);
137        return CreateFormattedStatements(sourceCode, insertingNodes);
138    }
139
140    ir::ClassDeclaration *CreateFormattedClassDeclaration(std::string_view sourceCode,
141                                                          std::vector<ir::AstNode *> &insertingNodes,
142                                                          bool allowStatic = false);
143
144    template <typename... Args>
145    ir::ClassDeclaration *CreateFormattedClassDeclaration(std::string_view sourceCode, bool allowStatic, Args &&...args)
146    {
147        std::vector<ir::AstNode *> insertingNodes {};
148        insertingNodes.reserve(sizeof...(Args));
149        (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...);
150        return CreateFormattedClassDeclaration(sourceCode, insertingNodes, allowStatic);
151    }
152
153    ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes,
154                                             const ArenaVector<ir::AstNode *> &properties,
155                                             ir::ClassDefinitionModifiers modifiers);
156
157    template <typename... Args>
158    ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, const ArenaVector<ir::AstNode *> &properties,
159                                             ir::ClassDefinitionModifiers modifiers, Args &&...args)
160    {
161        std::vector<ir::AstNode *> insertingNodes {};
162        insertingNodes.reserve(sizeof...(Args));
163        (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...);
164        return CreateFormattedClassElement(sourceCode, insertingNodes, properties, modifiers);
165    }
166
167    template <typename... Args>
168    ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, ir::ClassDefinition *classDefinition,
169                                             Args &&...args)
170    {
171        return CreateFormattedClassElement(sourceCode, classDefinition->Body(), classDefinition->Modifiers(),
172                                           std::forward<Args...>(args...));
173    }
174
175    ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view sourceCode,
176                                                     std::vector<ir::AstNode *> &insertingNodes);
177
178    template <typename... Args>
179    ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view const sourceCode, Args &&...args)
180    {
181        std::vector<ir::AstNode *> insertingNodes {};
182        insertingNodes.reserve(sizeof...(Args));
183        (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...);
184        return CreateFormattedClassFieldDefinition(sourceCode, insertingNodes);
185    }
186
187    ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view sourceCode,
188                                                      std::vector<ir::AstNode *> &insertingNodes);
189
190    template <typename... Args>
191    ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view const sourceCode, Args &&...args)
192    {
193        std::vector<ir::AstNode *> insertingNodes {};
194        insertingNodes.reserve(sizeof...(Args));
195        (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...);
196        return CreateFormattedClassMethodDefinition(sourceCode, insertingNodes);
197    }
198
199    ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode,
200                                                    std::vector<ir::AstNode *> &insertingNodes);
201
202    template <typename... Args>
203    ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode, Args &&...args)
204    {
205        std::vector<ir::AstNode *> insertingNodes {};
206        insertingNodes.reserve(sizeof...(Args));
207        (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...);
208        return CreateFormattedTopLevelStatement(sourceCode, insertingNodes);
209    }
210
211private:
212    NodeFormatType GetFormatPlaceholderType() const;
213
214    ir::Statement *ParseStatementFormatPlaceholder() const override;
215    ir::Expression *ParseExpressionFormatPlaceholder();
216    ir::Identifier *ParseIdentifierFormatPlaceholder(std::optional<NodeFormatType> nodeFormat) const override;
217    ir::TypeNode *ParseTypeFormatPlaceholder(std::optional<NodeFormatType> nodeFormat = std::nullopt);
218    ir::AstNode *ParseTypeParametersFormatPlaceholder() const override;
219
220    ArenaVector<ir::AstNode *> &ParseAstNodesArrayFormatPlaceholder() const override;
221    ArenaVector<ir::Statement *> &ParseStatementsArrayFormatPlaceholder() const override;
222    ArenaVector<ir::Expression *> &ParseExpressionsArrayFormatPlaceholder() const override;
223
224    ir::Statement *CreateStatement(std::string_view sourceCode);
225
226    ir::MethodDefinition *CreateConstructorDefinition(ir::ModifierFlags modifiers, std::string_view sourceCode);
227
228    ir::ClassDeclaration *CreateClassDeclaration(std::string_view sourceCode, bool allowStatic = false);
229    ir::AstNode *CreateClassElement(std::string_view sourceCode, const ArenaVector<ir::AstNode *> &properties,
230                                    ir::ClassDefinitionModifiers modifiers);
231
232    ir::TypeNode *CreateTypeAnnotation(TypeAnnotationParsingOptions *options, std::string_view sourceCode);
233    ir::Statement *CreateTopLevelStatement(std::string_view const sourceCode);
234
235    //============================================================================================//
236    //  END: Methods to create AST node(s)...
237    //============================================================================================//
238
239private:
240    void ParseProgram(ScriptKind kind) override;
241    [[nodiscard]] std::unique_ptr<lexer::Lexer> InitLexer(const SourceFile &sourceFile) override;
242    ir::ETSPackageDeclaration *ParsePackageDeclaration();
243    void AddPackageSourcesToParseList();
244    ArenaVector<ir::Statement *> ParseTopLevelStatements();
245
246    static bool IsClassMethodModifier(lexer::TokenType type) noexcept;
247
248#ifdef USE_FTW
249    static int NFTWCallBack(const char *fpath, const struct stat * /*unused*/, int tflag, struct FTW * /*unused*/);
250#endif
251    ir::ImportSource *ParseSourceFromClause(bool requireFrom);
252    void ParseNamedExportSpecifiers(ArenaVector<ir::AstNode *> *specifiers, bool defaultExport);
253    void ParseUserSources(std::vector<std::string> userParths);
254    ArenaVector<ir::Statement *> ParseTopLevelDeclaration();
255    void TryParseSource(const util::ImportPathManager::ParseInfo &parseListIdx, util::UString *extSrc,
256                        const ArenaVector<util::StringView> &directImportsFromMainSource,
257                        std::vector<Program *> &programs);
258    std::vector<Program *> ParseSources(bool firstSource = false);
259    std::tuple<ir::ImportSource *, std::vector<std::string>> ParseFromClause(bool requireFrom);
260    bool IsDefaultImport();
261    std::pair<ArenaVector<ir::ImportSpecifier *>, ArenaVector<ir::ImportDefaultSpecifier *>> ParseNamedSpecifiers();
262    ir::ExportNamedDeclaration *ParseSingleExport(ir::ModifierFlags modifiers);
263    ArenaVector<ir::ETSImportDeclaration *> ParseImportDeclarations();
264    parser::Program *ParseSource(const SourceFile &sourceFile);
265    void AddExternalSource(const std::vector<Program *> &programs);
266    ir::ETSScript *ParseETSGlobalScript(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> &statements);
267    ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers) override;
268
269    ir::MethodDefinition *ParseClassGetterSetterMethod(const ArenaVector<ir::AstNode *> &properties,
270                                                       ir::ClassDefinitionModifiers modifiers,
271                                                       ir::ModifierFlags memberModifiers);
272    ir::MethodDefinition *ParseInterfaceGetterSetterMethod(const ir::ModifierFlags modifiers);
273    ir::Statement *ParseIdentKeyword();
274    ir::Statement *ParseTypeDeclaration(bool allowStatic = false);
275    ir::Statement *ParseTypeDeclarationAbstractFinal(bool allowStatic, ir::ClassDefinitionModifiers modifiers);
276    ir::ModifierFlags ParseClassModifiers();
277    ir::ModifierFlags ParseInterfaceMethodModifiers();
278    ir::ClassProperty *ParseInterfaceField();
279    ir::Expression *ParseCoercedNumberLiteral();
280    ir::MethodDefinition *ParseInterfaceMethod(ir::ModifierFlags flags, ir::MethodDefinitionKind methodKind);
281    std::tuple<ir::ModifierFlags, bool> ParseClassMemberAccessModifiers();
282    ir::ModifierFlags ParseClassFieldModifiers(bool seenStatic);
283    ir::ModifierFlags ParseClassMethodModifierFlag();
284    ir::ModifierFlags ParseClassMethodModifiers(bool seenStatic);
285    ir::MethodDefinition *ParseClassMethodDefinition(ir::Identifier *methodName, ir::ModifierFlags modifiers,
286                                                     ir::Identifier *className = nullptr);
287    ir::ScriptFunction *ParseFunction(ParserStatus newStatus, ir::Identifier *className = nullptr);
288    ir::MethodDefinition *ParseClassMethod(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
289                                           ir::Expression *propName, lexer::SourcePosition *propEnd) override;
290    std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParseFunctionBody(
291        const ArenaVector<ir::Expression *> &params, ParserStatus newStatus, ParserStatus contextStatus) override;
292    ir::TypeNode *ParseFunctionReturnType(ParserStatus status) override;
293    ir::ScriptFunctionFlags ParseFunctionThrowMarker(bool isRethrowsAllowed) override;
294    ir::Expression *CreateParameterThis(util::StringView className) override;
295    ir::TypeNode *ConvertToOptionalUnionType(ir::TypeNode *typeNode);
296    // NOLINTNEXTLINE(google-default-arguments)
297    void ParseClassFieldDefinition(ir::Identifier *fieldName, ir::ModifierFlags modifiers,
298                                   ArenaVector<ir::AstNode *> *declarations);
299    std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseTypeReferencePart(
300        TypeAnnotationParsingOptions *options);
301    ir::TypeNode *ParseTypeReference(TypeAnnotationParsingOptions *options);
302    ir::TypeNode *ParseBaseTypeReference(TypeAnnotationParsingOptions *options);
303    ir::TypeNode *ParsePrimitiveType(TypeAnnotationParsingOptions *options, ir::PrimitiveType type);
304    ir::TypeNode *ParseUnionType(ir::TypeNode *firstType);
305    ir::TypeNode *GetTypeAnnotationOfPrimitiveType(lexer::TokenType tokenType, TypeAnnotationParsingOptions *options);
306    ir::TypeNode *ParseWildcardType(TypeAnnotationParsingOptions *options);
307    ir::TypeNode *ParseFunctionType();
308    ir::TypeNode *ParseETSTupleType(TypeAnnotationParsingOptions *options);
309    bool ParseTriplePeriod(bool spreadTypePresent);
310    std::pair<bool, std::size_t> CheckDefaultParameters(const ir::ScriptFunction *function) const;
311    static std::string PrimitiveTypeToName(ir::PrimitiveType type);
312    std::string GetNameForTypeNode(const ir::TypeNode *typeAnnotation) const;
313    std::string GetNameForETSUnionType(const ir::TypeNode *typeAnnotation) const;
314    ir::TSInterfaceDeclaration *ParseInterfaceBody(ir::Identifier *name, bool isStatic);
315    bool IsArrowFunctionExpressionStart();
316    ir::ArrowFunctionExpression *ParseArrowFunctionExpression();
317
318    void ThrowIfVarDeclaration(VariableParsingFlags flags) override;
319    std::optional<lexer::SourcePosition> GetDefaultParamPosition(ArenaVector<ir::Expression *> params);
320
321    ir::TypeNode *ParsePotentialFunctionalType(TypeAnnotationParsingOptions *options, lexer::SourcePosition startLoc);
322    std::pair<ir::TypeNode *, bool> GetTypeAnnotationFromToken(TypeAnnotationParsingOptions *options);
323    std::pair<ir::TypeNode *, bool> GetTypeAnnotationFromParentheses(TypeAnnotationParsingOptions *options);
324    ir::TypeNode *ParseLiteralIdent(TypeAnnotationParsingOptions *options);
325    void ParseRightParenthesis(TypeAnnotationParsingOptions *options, ir::TypeNode *&typeAnnotation,
326                               lexer::LexerPosition savedPos);
327    ir::TypeNode *ParseTypeAnnotation(TypeAnnotationParsingOptions *options) override;
328    ir::TSTypeAliasDeclaration *ParseTypeAliasDeclaration() override;
329
330    void ValidateForInStatement() override;
331
332    // NOLINTNEXTLINE(google-default-arguments)
333    ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList(
334        ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
335    ir::Statement *ParseTryStatement() override;
336    ir::DebuggerStatement *ParseDebuggerStatement() override;
337    ir::Statement *ParseExport(lexer::SourcePosition startLoc, ir::ModifierFlags modifiers);
338    ir::Statement *ParseImportDeclaration(StatementParsingFlags flags) override;
339    ir::Statement *ParseExportDeclaration(StatementParsingFlags flags) override;
340    ir::AnnotatedExpression *ParseVariableDeclaratorKey(VariableParsingFlags flags) override;
341    ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc,
342                                                    VariableParsingFlags flags) override;
343    ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
344                                                               const lexer::SourcePosition &startLoc) override;
345    ir::AstNode *ParseTypeLiteralOrInterfaceMember() override;
346    void ParseNameSpaceSpecifier(ArenaVector<ir::AstNode *> *specifiers, bool isReExport = false);
347    bool CheckModuleAsModifier();
348    ir::Expression *ParseFunctionParameterExpression(ir::AnnotatedExpression *paramIdent,
349                                                     ir::ETSUndefinedType *defaultUndef);
350    std::pair<ir::Expression *, std::string> TypeAnnotationValue(ir::TypeNode *typeAnnotation);
351    ir::ETSParameterExpression *ParseFunctionParameterTail(ir::AnnotatedExpression *paramIdent, bool defaultUndefined);
352    ir::Expression *ParseFunctionParameter() override;
353    ir::AnnotatedExpression *GetAnnotatedExpressionFromParam();
354    ir::ETSUnionType *CreateOptionalParameterTypeNode(ir::TypeNode *typeAnnotation, ir::ETSUndefinedType *defaultUndef);
355    ir::Expression *ResolveArgumentUnaryExpr(ExpressionParseFlags flags);
356    // NOLINTNEXTLINE(google-default-arguments)
357    ir::Expression *ParseUnaryOrPrefixUpdateExpression(
358        ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
359    // NOLINTNEXTLINE(google-default-arguments)
360    ir::Expression *ParseDefaultPrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
361    // NOLINTNEXTLINE(google-default-arguments)
362    ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
363    ir::Expression *ParsePrimaryExpressionWithLiterals(ExpressionParseFlags flags) override;
364    ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc,
365                                               bool ignoreCallExpression, bool *isChainExpression) override;
366    ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpr) override;
367    ir::Statement *ParseAssertStatement() override;
368    void ValidateLabeledStatement(lexer::TokenType type) override;
369    ir::Expression *ParseCatchParam() override;
370    void ParseCatchParamTypeAnnotation([[maybe_unused]] ir::AnnotatedExpression *param) override;
371    ir::Expression *ParseSuperClassReference() override;
372    ir::Identifier *ParseClassIdent(ir::ClassDefinitionModifiers modifiers) override;
373    // NOLINTNEXTLINE(google-default-arguments)
374    ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers,
375                                              ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override;
376    // NOLINTNEXTLINE(google-default-arguments)
377    ir::ETSStructDeclaration *ParseStructStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers,
378                                                   ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override;
379    ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers,
380                                   ir::ModifierFlags flags) override;
381    ir::AstNode *ParseInnerTypeDeclaration(ir::ModifierFlags memberModifiers, lexer::LexerPosition savedPos,
382                                           bool isStepToken, bool seenStatic);
383    ir::AstNode *ParseInnerConstructorDeclaration(ir::ModifierFlags memberModifiers,
384                                                  const lexer::SourcePosition &startLoc);
385    ir::AstNode *ParseInnerRest(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers,
386                                ir::ModifierFlags memberModifiers, const lexer::SourcePosition &startLoc);
387    void CheckAccessorDeclaration(ir::ModifierFlags memberModifiers);
388
389    ir::AstNode *ParseAmbientSignature();
390
391    ir::ClassDefinition *CreateClassDefinitionForNewExpression(ArenaVector<ir::Expression *> &arguments,
392                                                               ir::TypeNode *typeReference,
393                                                               ir::TypeNode *baseTypeReference);
394    ir::Identifier *CreateInvokeIdentifier();
395
396    ir::Expression *ParseNewExpression() override;
397    ir::Expression *ParseAsyncExpression();
398    ir::Expression *ParseAwaitExpression();
399    ir::TSTypeParameter *ParseTypeParameter(TypeAnnotationParsingOptions *options) override;
400
401    bool IsStringEnum();
402    ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, bool isConst,
403                                            bool isStatic) override;
404    void ParseNumberEnum(ArenaVector<ir::AstNode *> &members);
405    void ParseStringEnum(ArenaVector<ir::AstNode *> &members);
406
407    ir::Statement *ParseInterfaceDeclaration(bool isStatic) override;
408    ir::ThisExpression *ParseThisExpression() override;
409    ir::TypeNode *ParseThisType(TypeAnnotationParsingOptions *options);
410    ir::Statement *ParseFunctionStatement(StatementParsingFlags flags) override;
411    ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous, ir::ModifierFlags modifiers);
412    std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseClassImplementsElement() override;
413    ir::TypeNode *ParseInterfaceExtendsElement() override;
414    // NOLINTNEXTLINE(google-default-arguments)
415    ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers,
416                                              ir::ModifierFlags flags = ir::ModifierFlags::NONE) override;
417    bool CheckInNamespaceContextIsExported();
418    ir::NamespaceDeclaration *ParseNamespaceDeclaration(ir::ModifierFlags flags);
419    ir::NamespaceDefinition *ParseNamespaceDefinition(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags);
420    using NamespaceBody = std::tuple<ir::MethodDefinition *, ArenaVector<ir::AstNode *>, lexer::SourceRange>;
421    NamespaceBody ParseNamespaceBody(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags);
422    // NOLINTNEXTLINE(google-default-arguments)
423    ir::Statement *ParseEnumDeclaration(bool isConst = false, bool isStatic = false) override;
424    ir::Statement *ParsePotentialConstEnum(VariableParsingFlags flags) override;
425    ir::Expression *ParseLaunchExpression(ExpressionParseFlags flags);
426    void ValidateInstanceOfExpression(ir::Expression *expr);
427    void ValidateRestParameter(ir::Expression *param) override;
428    bool ValidateBreakLabel(util::StringView label) override;
429    bool ValidateContinueLabel(util::StringView label) override;
430    void CheckPredefinedMethods(ir::ScriptFunction const *function, const lexer::SourcePosition &position) const;
431
432    bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor,
433                           ArenaVector<ir::AstNode *> &properties) override;
434    void CreateImplicitConstructor(ir::MethodDefinition *&ctor, ArenaVector<ir::AstNode *> &properties,
435                                   ir::ClassDefinitionModifiers modifiers,
436                                   const lexer::SourcePosition &startLoc) override;
437    bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression,
438                                           const lexer::SourcePosition &startLoc, bool ignoreCallExpression) override;
439    bool ParsePotentialNonNullExpression(ir::Expression **expression, lexer::SourcePosition startLoc) override;
440
441    std::pair<ir::ModifierFlags, lexer::SourcePosition> ParseMemberModifiers();
442
443    std::shared_ptr<ArkTsConfig> ArkTSConfig() const
444    {
445        return GetOptions().arktsConfig;
446    }
447
448    bool IsETSModule() const
449    {
450        return GetOptions().isEtsModule;
451    }
452
453    bool IsStructKeyword() const;
454
455    bool IsExternal() const override
456    {
457        return util::Helpers::IsStdLib(GetProgram());
458    }
459
460    // NOLINTNEXTLINE(google-default-arguments)
461    ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
462
463    ir::Expression *ParseExpressionOrTypeAnnotation(lexer::TokenType type, ExpressionParseFlags flags) override;
464
465    ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags) override;
466
467    ir::ModifierFlags ParseTypeVarianceModifier(TypeAnnotationParsingOptions *const options);
468
469    ir::Statement *ParseTopLevelDeclStatement(StatementParsingFlags flags);
470    ir::Statement *ParseTopLevelStatement();
471
472    void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) override;
473
474    void CheckDeclare();
475
476    friend class ExternalSourceParser;
477    friend class InnerSourceParser;
478
479private:
480    std::optional<ir::Expression *> GetPostPrimaryExpression(ir::Expression *returnExpression,
481                                                             lexer::SourcePosition startLoc, bool ignoreCallExpression,
482                                                             [[maybe_unused]] bool *isChainExpression);
483    parser::Program *globalProgram_;
484    std::vector<ir::AstNode *> insertingNodes_ {};
485    std::unique_ptr<util::ImportPathManager> importPathManager_ {nullptr};
486};
487
488class ExternalSourceParser {
489public:
490    explicit ExternalSourceParser(ETSParser *parser, Program *newProgram);
491    NO_COPY_SEMANTIC(ExternalSourceParser);
492    NO_MOVE_SEMANTIC(ExternalSourceParser);
493
494    ~ExternalSourceParser();
495
496    void *operator new(size_t) = delete;
497    void *operator new[](size_t) = delete;
498
499private:
500    ETSParser *parser_;
501    Program *savedProgram_;
502    lexer::Lexer *savedLexer_;
503    varbinder::GlobalScope *savedTopScope_;
504};
505
506class InnerSourceParser {
507public:
508    explicit InnerSourceParser(ETSParser *parser);
509    NO_COPY_SEMANTIC(InnerSourceParser);
510    NO_MOVE_SEMANTIC(InnerSourceParser);
511
512    ~InnerSourceParser();
513
514    void *operator new(size_t) = delete;
515    void *operator new[](size_t) = delete;
516
517private:
518    ETSParser *parser_;
519    lexer::Lexer *savedLexer_;
520    util::StringView savedSourceCode_ {};
521    util::StringView savedSourceFile_ {};
522    util::StringView savedSourceFilePath_ {};
523};
524
525class SavedFormattingFileName {
526public:
527    SavedFormattingFileName(ETSParser *parser, std::string_view fname)
528        : parser_(parser), savedFname_(parser->FormattingFileName())
529    {
530        parser->SetFormattingFileName(fname);
531    }
532
533    NO_COPY_SEMANTIC(SavedFormattingFileName);
534    NO_MOVE_SEMANTIC(SavedFormattingFileName);
535
536    ~SavedFormattingFileName()
537    {
538        parser_->SetFormattingFileName(savedFname_);
539    }
540
541private:
542    ETSParser *parser_;
543    std::string_view savedFname_;
544};
545
546}  // namespace ark::es2panda::parser
547#endif
548