• 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_ETS_PARSER_H
17 #define ES2PANDA_PARSER_CORE_ETS_PARSER_H
18 
19 #include <optional>
20 #include "parserFlags.h"
21 #include "util/arktsconfig.h"
22 #include "TypedParser.h"
23 
24 namespace panda::es2panda::ir {
25 class ETSPackageDeclaration;
26 enum class ClassDefinitionModifiers : uint32_t;
27 enum class PrimitiveType;
28 }  // namespace panda::es2panda::ir
29 
30 namespace panda::es2panda::parser {
31 
32 // NOLINTBEGIN(modernize-avoid-c-arrays)
33 inline constexpr char const FORMAT_SIGNATURE = '@';
34 inline constexpr char const TYPE_FORMAT_NODE = 'T';
35 inline constexpr char const STATEMENT_FORMAT_NODE = 'S';
36 inline constexpr char const EXPRESSION_FORMAT_NODE = 'E';
37 inline constexpr char const IDENTIFIER_FORMAT_NODE = 'I';
38 inline constexpr char const DEFAULT_SOURCE_FILE[] = "<auxiliary_tmp>.ets";
39 // NOLINTEND(modernize-avoid-c-arrays)
40 
41 class ETSParser final : public TypedParser {
42 public:
43     ETSParser(Program *program, const CompilerOptions &options, ParserStatus status = ParserStatus::NO_OPTS)
TypedParser(program,options,status)44         : TypedParser(program, options, status), globalProgram_(GetProgram())
45     {
46     }
47 
48     ETSParser() = delete;
49     NO_COPY_SEMANTIC(ETSParser);
50     NO_MOVE_SEMANTIC(ETSParser);
51 
52     ~ETSParser() final = default;
53 
IsETSParser()54     [[nodiscard]] bool IsETSParser() const noexcept override
55     {
56         return true;
57     }
58 
59     //  Methods to create AST node(s) from the specified string (part of valid ETS-code!)
60     //  NOTE: the correct initial scope should be entered BEFORE calling any of these methods,
61     //  and correct parent and, probably, variable set to the node(s) after obtaining
62 
63     ir::Expression *CreateExpression(std::string_view sourceCode,
64                                      ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS,
65                                      std::string_view fileName = DEFAULT_SOURCE_FILE);
66 
67     ir::Expression *CreateFormattedExpression(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes,
68                                               std::string_view fileName = DEFAULT_SOURCE_FILE);
69 
70     template <typename... Args>
CreateFormattedExpression(std::string_view const sourceCode,std::string_view const fileName,Args &&...args)71     ir::Expression *CreateFormattedExpression(std::string_view const sourceCode, std::string_view const fileName,
72                                               Args &&...args)
73     {
74         std::vector<ir::AstNode *> insertingNodes {};
75         insertingNodes.reserve(sizeof...(Args));
76         (insertingNodes.emplace_back(std::forward<Args>(args)), ...);
77         return CreateFormattedExpression(sourceCode, insertingNodes, fileName);
78     }
79 
80     ArenaVector<ir::Statement *> CreateStatements(std::string_view sourceCode,
81                                                   std::string_view fileName = DEFAULT_SOURCE_FILE);
82 
83     ArenaVector<ir::Statement *> CreateFormattedStatements(std::string_view sourceCode,
84                                                            std::vector<ir::AstNode *> &insertingNodes,
85                                                            std::string_view fileName = DEFAULT_SOURCE_FILE);
86 
87     template <typename... Args>
CreateFormattedStatements(std::string_view const sourceCode,std::string_view const fileName,Args &&...args)88     ArenaVector<ir::Statement *> CreateFormattedStatements(std::string_view const sourceCode,
89                                                            std::string_view const fileName, Args &&...args)
90     {
91         std::vector<ir::AstNode *> insertingNodes {};
92         (insertingNodes.emplace(std::forward<Args>(args)), ...);
93         return CreateFormattedStatements(sourceCode, insertingNodes, fileName);
94     }
95 
96 private:
97     struct ImportData {
98         Language lang;
99         std::string module;
100         bool hasDecl;
101     };
102 
103     std::map<util::StringView, ir::AstNode *> fieldMap_;
104     std::map<util::StringView, lexer::SourcePosition> exportNameMap_;
105     void ParseProgram(ScriptKind kind) override;
106     [[nodiscard]] std::unique_ptr<lexer::Lexer> InitLexer(const SourceFile &sourceFile) override;
107     void ParsePackageDeclaration(ArenaVector<ir::Statement *> &statements);
108     ArenaVector<ir::AstNode *> ParseTopLevelStatements(ArenaVector<ir::Statement *> &statements);
109     void ParseTopLevelType(ArenaVector<ir::Statement *> &statements, bool &defaultExport, std::size_t currentPos,
110                            std::function<ir::Statement *(ETSParser *)> const &parserFunction);
111     void ParseTopLevelNextToken(ArenaVector<ir::Statement *> &statements, ArenaVector<ir::AstNode *> &globalProperties,
112                                 ir::ScriptFunction *initFunction);
113     void ParseTopLevelNextTokenDefault(ArenaVector<ir::Statement *> &statements, ir::ScriptFunction *initFunction,
114                                        size_t currentPos, lexer::TokenType tokenType, bool defaultExport);
115     ir::ModifierFlags ResolveMemberModifiers();
116     lexer::SourcePosition ParseTopLevelNextTokenResolution(ArenaVector<ir::Statement *> &statements,
117                                                            ArenaVector<ir::AstNode *> &globalProperties,
118                                                            ir::ScriptFunction *initFunction, size_t currentPos,
119                                                            bool defaultExport);
120     void ParseTokenOfNative(panda::es2panda::lexer::TokenType tokenType, ir::ModifierFlags &memberModifiers);
121     void ParseTokenOfFunction(ir::ModifierFlags memberModifiers, lexer::SourcePosition startLoc,
122                               ArenaVector<ir::AstNode *> &globalProperties);
123 #ifdef USE_FTW
124     static int NFTWCallBack(const char *fpath, const struct stat * /*unused*/, int tflag, struct FTW * /*unused*/);
125 #endif
126     void ParseTopLevelDeclaration(ArenaVector<ir::Statement *> &statements);
127     void CollectDefaultSources();
128     void CollectUserSourcesFromIndex(const std::string &path, const std::string &resolvedPath,
129                                      std::vector<std::string> &userPaths);
130     std::string ResolveImportPath(const std::string &path);
131     std::string ResolveFullPathFromRelative(const std::string &path);
132     ImportData GetImportData(const std::string &path);
133     std::tuple<std::vector<std::string>, bool> CollectUserSources(const std::string &path);
134     std::tuple<std::string, bool> GetSourceRegularPath(const std::string &path, const std::string &resolvedPath);
135     void ParseSources(const std::vector<std::string> &paths, bool isExternal = true);
136     std::tuple<ir::ImportSource *, std::vector<std::string>> ParseFromClause(bool requireFrom);
137     void ParseNamedSpecifiers(ArenaVector<ir::AstNode *> *specifiers, bool isExport = false);
138     void ParseNamedExportSpecifiers(ArenaVector<ir::AstNode *> *specifiers, bool defaultExport);
139     void ParseUserSources(std::vector<std::string> userParths);
140     std::vector<std::string> ParseImportDeclarations(ArenaVector<ir::Statement *> &statements);
141     void ParseDefaultSources();
142     void ParseSource(const SourceFile &sourceFile);
143     void CreateGlobalClass();
144     ArenaVector<ir::Statement *> PrepareGlobalClass();
145     ArenaVector<ir::Statement *> PrepareExternalGlobalClass(const SourceFile &sourceFile);
146     void ParseETSGlobalScript(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> &statements);
147     ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers) override;
148 
149     ir::MethodDefinition *ParseClassGetterSetterMethod(const ArenaVector<ir::AstNode *> &properties,
150                                                        ir::ClassDefinitionModifiers modifiers,
151                                                        ir::ModifierFlags memberModifiers);
152     ir::MethodDefinition *ParseInterfaceGetterSetterMethod(ir::ModifierFlags modifiers);
153     ir::Statement *ParseTypeDeclaration(bool allowStatic = false);
154     ir::Statement *ParseTypeDeclarationAbstractFinal(bool allowStatic, ir::ClassDefinitionModifiers modifiers);
155     ir::ModifierFlags ParseClassModifiers();
156     ir::ModifierFlags ParseInterfaceMethodModifiers();
157     ir::ClassProperty *ParseInterfaceField();
158     ir::Expression *ParseInitializer();
159     ir::ArrayExpression *ParseArrayLiteral();
160     ir::Expression *ParseCoercedNumberLiteral();
161     ir::MethodDefinition *ParseInterfaceMethod(ir::ModifierFlags flags, ir::MethodDefinitionKind methodKind);
162     std::tuple<ir::ModifierFlags, bool> ParseClassMemberAccessModifiers();
163     ir::ModifierFlags ParseClassFieldModifiers(bool seenStatic);
164     ir::ModifierFlags ParseClassMethodModifiers(bool seenStatic);
165     ir::MethodDefinition *ParseClassMethodDefinition(ir::Identifier *methodName, ir::ModifierFlags modifiers,
166                                                      ir::Identifier *className = nullptr,
167                                                      ir::Identifier *identNode = nullptr);
168     ir::ScriptFunction *ParseFunction(ParserStatus newStatus, ir::Identifier *className = nullptr);
169     ir::MethodDefinition *ParseClassMethod(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
170                                            ir::Expression *propName, lexer::SourcePosition *propEnd) override;
171     std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParseFunctionBody(
172         const ArenaVector<ir::Expression *> &params, ParserStatus newStatus, ParserStatus contextStatus) override;
173     ir::TypeNode *ParseFunctionReturnType(ParserStatus status) override;
174     ir::ScriptFunctionFlags ParseFunctionThrowMarker(bool isRethrowsAllowed) override;
175     ir::Expression *CreateParameterThis(util::StringView className) override;
176 
177     // NOLINTNEXTLINE(google-default-arguments)
178     void ParseClassFieldDefinition(ir::Identifier *fieldName, ir::ModifierFlags modifiers,
179                                    ArenaVector<ir::AstNode *> *declarations, ir::ScriptFunction *initFunction = nullptr,
180                                    lexer::SourcePosition *letLoc = nullptr);
181     lexer::SourcePosition InitializeGlobalVariable(ir::Identifier *fieldName, ir::Expression *&initializer,
182                                                    ir::ScriptFunction *initFunction, lexer::SourcePosition &startLoc,
183                                                    ir::TypeNode *typeAnnotation);
184     std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseTypeReferencePart(
185         TypeAnnotationParsingOptions *options);
186     ir::TypeNode *ParseTypeReference(TypeAnnotationParsingOptions *options);
187     ir::TypeNode *ParseBaseTypeReference(TypeAnnotationParsingOptions *options);
188     ir::TypeNode *ParsePrimitiveType(TypeAnnotationParsingOptions *options, ir::PrimitiveType type);
189     ir::TypeNode *ParseUnionType(ir::TypeNode *firstType);
190     ir::TSIntersectionType *ParseIntersectionType(ir::Expression *type);
191     ir::TypeNode *GetTypeAnnotationOfPrimitiveType(lexer::TokenType tokenType, TypeAnnotationParsingOptions *options);
192     ir::TypeNode *ParseWildcardType(TypeAnnotationParsingOptions *options);
193     ir::TypeNode *ParseFunctionType();
194     ir::TypeNode *ParseETSTupleType(TypeAnnotationParsingOptions *options);
195     std::pair<bool, std::size_t> CheckDefaultParameters(const ir::ScriptFunction *function) const;
196     ir::MethodDefinition *CreateProxyMethodDefinition(ir::MethodDefinition const *method,
197                                                       ir::Identifier const *identNode);
198     ir::MethodDefinition *CreateProxyConstructorDefinition(ir::MethodDefinition const *method);
199     void AddProxyOverloadToMethodWithDefaultParams(ir::MethodDefinition *method, ir::Identifier *identNode = nullptr);
200     static std::string PrimitiveTypeToName(ir::PrimitiveType type);
201     std::string GetNameForTypeNode(const ir::TypeNode *typeAnnotation, bool adjust = true) const;
202     std::string GetNameForETSUnionType(const ir::TypeNode *typeAnnotation) const;
203     ir::TSInterfaceDeclaration *ParseInterfaceBody(ir::Identifier *name, bool isStatic);
204     bool IsArrowFunctionExpressionStart();
205     ir::ArrowFunctionExpression *ParseArrowFunctionExpression();
206 
207     void ThrowIfVarDeclaration(VariableParsingFlags flags) override;
208     std::pair<ir::TypeNode *, bool> GetTypeAnnotationFromToken(TypeAnnotationParsingOptions *options);
209     ir::TypeNode *ParseLiteralIdent(TypeAnnotationParsingOptions *options);
210     void ParseRightParenthesis(TypeAnnotationParsingOptions *options, ir::TypeNode *&typeAnnotation,
211                                lexer::LexerPosition savedPos);
212     ir::TypeNode *ParseTypeAnnotation(TypeAnnotationParsingOptions *options) override;
213     ir::TSTypeAliasDeclaration *ParseTypeAliasDeclaration() override;
214 
215     void ValidateForInStatement() override;
216 
217     // NOLINTNEXTLINE(google-default-arguments)
218     ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList(
219         ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
220     ir::Statement *ParseTryStatement() override;
221     ir::DebuggerStatement *ParseDebuggerStatement() override;
222     void ParseExport(lexer::SourcePosition startLoc);
223     ir::Statement *ParseImportDeclaration(StatementParsingFlags flags) override;
224     ir::Statement *ParseExportDeclaration(StatementParsingFlags flags) override;
225     ir::AnnotatedExpression *ParseVariableDeclaratorKey(VariableParsingFlags flags) override;
226     ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc,
227                                                     VariableParsingFlags flags) override;
228     ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
229                                                                const lexer::SourcePosition &startLoc) override;
230     ir::AstNode *ParseTypeLiteralOrInterfaceMember() override;
231     void ParseNameSpaceSpecifier(ArenaVector<ir::AstNode *> *specifiers, bool isReExport = false);
232     bool CheckModuleAsModifier();
233     ir::Expression *ParseFunctionParameter() override;
234     ir::AnnotatedExpression *GetAnnotatedExpressionFromParam();
235     // NOLINTNEXTLINE(google-default-arguments)
236     ir::Expression *ParseUnaryOrPrefixUpdateExpression(
237         ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
238     // NOLINTNEXTLINE(google-default-arguments)
239     ir::Expression *ParseDefaultPrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
240     // NOLINTNEXTLINE(google-default-arguments)
241     ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
242     ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc,
243                                                bool ignoreCallExpression, bool *isChainExpression) override;
244     ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpr) override;
245     ir::Statement *ParseAssertStatement() override;
246     void ValidateLabeledStatement(lexer::TokenType type) override;
247     ir::Expression *ParseCatchParam() override;
248     void ParseCatchParamTypeAnnotation([[maybe_unused]] ir::AnnotatedExpression *param) override;
249     ir::Expression *ParseSuperClassReference() override;
250     ir::Identifier *ParseClassIdent(ir::ClassDefinitionModifiers modifiers) override;
251     // NOLINTNEXTLINE(google-default-arguments)
252     ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers,
253                                               ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override;
254     // NOLINTNEXTLINE(google-default-arguments)
255     ir::ETSStructDeclaration *ParseStructStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers,
256                                                    ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override;
257     // NOLINTNEXTLINE(google-default-arguments)
258     ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers,
259                                    ir::ModifierFlags flags = ir::ModifierFlags::NONE,
260                                    ir::Identifier *identNode = nullptr) override;
261     ir::AstNode *ParseInnerTypeDeclaration(ir::ModifierFlags memberModifiers, lexer::LexerPosition savedPos,
262                                            bool isStepToken, bool seenStatic);
263     ir::AstNode *ParseInnerConstructorDeclaration(ir::ModifierFlags memberModifiers,
264                                                   const lexer::SourcePosition &startLoc);
265     ir::AstNode *ParseInnerRest(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers,
266                                 ir::ModifierFlags memberModifiers, ir::Identifier *identNode,
267                                 const lexer::SourcePosition &startLoc);
268     ir::Expression *ParseNewExpression() override;
269     ir::Expression *ParseAsyncExpression();
270     ir::Expression *ParseAwaitExpression();
271     ir::TSTypeParameter *ParseTypeParameter(TypeAnnotationParsingOptions *options) override;
272 
273     NodeFormatType GetFormatPlaceholderIdent() const;
274     ir::AstNode *ParseFormatPlaceholder();
275     ir::Statement *ParseStatementFormatPlaceholder(std::optional<NodeFormatType> nodeFormat = std::nullopt);
276     ir::Expression *ParseExpressionFormatPlaceholder(std::optional<NodeFormatType> nodeFormat = std::nullopt);
277     // NOLINTNEXTLINE(google-default-arguments)
278     ir::Identifier *ParseIdentifierFormatPlaceholder(std::optional<NodeFormatType> nodeFormat = std::nullopt) override;
279     ir::TypeNode *ParseTypeFormatPlaceholder(std::optional<NodeFormatType> nodeFormat = std::nullopt);
280 
281     ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, bool isConst,
282                                             bool isStatic) override;
283     void ParseNumberEnum(ArenaVector<ir::AstNode *> &members);
284     void ParseStringEnum(ArenaVector<ir::AstNode *> &members);
285 
286     ir::Statement *ParseInterfaceDeclaration(bool isStatic) override;
287     ir::ThisExpression *ParseThisExpression() override;
288     ir::TypeNode *ParseThisType(TypeAnnotationParsingOptions *options);
289     ir::Statement *ParseFunctionStatement(StatementParsingFlags flags) override;
290     std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseClassImplementsElement() override;
291     ir::TypeNode *ParseInterfaceExtendsElement() override;
292     // NOLINTNEXTLINE(google-default-arguments)
293     ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers,
294                                               ir::ModifierFlags flags = ir::ModifierFlags::NONE) override;
295     // NOLINTNEXTLINE(google-default-arguments)
296     ir::Statement *ParseEnumDeclaration(bool isConst = false, bool isStatic = false) override;
297     ir::Expression *ParseLaunchExpression(ExpressionParseFlags flags);
298     void ValidateInstanceOfExpression(ir::Expression *expr);
299     void ValidateRestParameter(ir::Expression *param) override;
300     void CheckIndexAccessMethod(ir::ScriptFunction const *function, const lexer::SourcePosition &position) const;
301 
302     bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor,
303                            ArenaVector<ir::AstNode *> &properties) override;
304     // NOLINTNEXTLINE(google-default-arguments)
305     void CreateCCtor(ArenaVector<ir::AstNode *> &properties, const lexer::SourcePosition &loc,
306                      bool inGlobalClass = false) override;
307     void CreateImplicitConstructor(ir::MethodDefinition *&ctor, ArenaVector<ir::AstNode *> &properties,
308                                    ir::ClassDefinitionModifiers modifiers,
309                                    const lexer::SourcePosition &startLoc) override;
310     bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression,
311                                            const lexer::SourcePosition &startLoc, bool ignoreCallExpression) override;
312     bool ParsePotentialNonNullExpression(ir::Expression **expression, lexer::SourcePosition startLoc) override;
313     void MarkNodeAsExported(ir::AstNode *node, lexer::SourcePosition startPos, bool defaultExport,
314                             std::size_t numOfElements = 1);
315 
ArkTSConfig()316     std::shared_ptr<ArkTsConfig> ArkTSConfig() const
317     {
318         return GetOptions().arktsConfig;
319     }
320 
IsETSModule()321     bool IsETSModule() const
322     {
323         return GetOptions().isEtsModule;
324     }
325 
326     bool IsStructKeyword() const;
327 
328     // NOLINTNEXTLINE(google-default-arguments)
329     ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
330 
331     ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags) override;
332 
333     ir::ModifierFlags ParseTypeVarianceModifier(TypeAnnotationParsingOptions *options);
334 
335     ir::ScriptFunction *AddInitMethod(ArenaVector<ir::AstNode *> &globalProperties);
336     ir::Statement *ParseTopLevelStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
337 
338     void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) override;
339 
340     void CheckDeclare();
341 
342     // Methods to create AST node(s) from the specified string (part of valid ETS-code!)
343     // NOTE: the correct initial scope should be entered BEFORE calling any of these methods,
344     // and correct parent and, probably, variable set to the node(s) after obtaining
345     // NOLINTBEGIN(modernize-avoid-c-arrays)
346     inline static constexpr char const DEFAULT_SOURCE_FILE[] = "<auxiliary_tmp>.ets";
347     inline static constexpr char const DEFAULT_PROXY_FILE[] = "<default_method>.ets";
348     // NOLINTEND(modernize-avoid-c-arrays)
349 
350     // NOLINTBEGIN(google-default-arguments)
351     ir::Statement *CreateStatement(std::string_view sourceCode, std::string_view fileName = DEFAULT_SOURCE_FILE);
352     ir::Statement *CreateFormattedStatement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes,
353                                             std::string_view fileName = DEFAULT_SOURCE_FILE);
354     // NOLINTEND(google-default-arguments)
355 
356     template <typename... Args>
CreateFormattedStatement(std::string_view const sourceCode,std::string_view const fileName,Args &&...args)357     ir::Statement *CreateFormattedStatement(std::string_view const sourceCode, std::string_view const fileName,
358                                             Args &&...args)
359     {
360         std::vector<ir::AstNode *> insertingNodes {};
361         (insertingNodes.emplace(std::forward<Args>(args)), ...);
362         return CreateFormattedStatement(sourceCode, insertingNodes, fileName);
363     }
364 
365     // NOLINTBEGIN(google-default-arguments)
366     ir::MethodDefinition *CreateMethodDefinition(ir::ModifierFlags modifiers, std::string_view sourceCode,
367                                                  std::string_view fileName = DEFAULT_SOURCE_FILE);
368     ir::MethodDefinition *CreateConstructorDefinition(ir::ModifierFlags modifiers, std::string_view sourceCode,
369                                                       std::string_view fileName = DEFAULT_SOURCE_FILE);
370     ir::TypeNode *CreateTypeAnnotation(TypeAnnotationParsingOptions *options, std::string_view sourceCode,
371                                        std::string_view fileName = DEFAULT_SOURCE_FILE);
372     // NOLINTEND(google-default-arguments)
373 
374     friend class ExternalSourceParser;
375     friend class InnerSourceParser;
376 
377 public:
ResolvedParsedSourcesMap()378     const std::unordered_map<std::string, std::string> &ResolvedParsedSourcesMap() const
379     {
380         return resolvedParsedSources_;
381     }
382 
383 private:
384     parser::Program *globalProgram_;
385     std::vector<std::string> parsedSources_;
386     std::vector<ir::AstNode *> insertingNodes_ {};
387     std::unordered_map<std::string, std::string> resolvedParsedSources_;
388 };
389 
390 class ExternalSourceParser {
391 public:
392     explicit ExternalSourceParser(ETSParser *parser, Program *newProgram);
393     NO_COPY_SEMANTIC(ExternalSourceParser);
394     NO_MOVE_SEMANTIC(ExternalSourceParser);
395 
396     ~ExternalSourceParser();
397 
398     void *operator new(size_t) = delete;
399     void *operator new[](size_t) = delete;
400 
401 private:
402     ETSParser *parser_;
403     Program *savedProgram_;
404     lexer::Lexer *savedLexer_;
405     varbinder::GlobalScope *savedTopScope_;
406 };
407 
408 class InnerSourceParser {
409 public:
410     explicit InnerSourceParser(ETSParser *parser);
411     NO_COPY_SEMANTIC(InnerSourceParser);
412     NO_MOVE_SEMANTIC(InnerSourceParser);
413 
414     ~InnerSourceParser();
415 
416     void *operator new(size_t) = delete;
417     void *operator new[](size_t) = delete;
418 
419 private:
420     ETSParser *parser_;
421     lexer::Lexer *savedLexer_;
422     util::StringView savedSourceCode_ {};
423     util::StringView savedSourceFile_ {};
424     util::StringView savedSourceFilePath_ {};
425 };
426 
427 }  // namespace panda::es2panda::parser
428 #endif
429