Lines Matching refs:ir
22 #include "ir/base/classDefinition.h"
25 namespace ark::es2panda::ir {
29 } // namespace ark::es2panda::ir
47 ArenaVector<ir::ETSImportDeclaration *> ParseDefaultSources(std::string_view srcFile, std::string_view importSrc);
70 void ProcessFormattedArg(std::vector<ir::AstNode *> &nodes, T &&arg)
72 if constexpr (std::is_convertible_v<std::decay_t<T>, ir::AstNode *>) {
75 nodes.emplace_back(AllocNode<ir::Identifier>(std::forward<T>(arg), Allocator()));
77 nodes.emplace_back(AllocNode<ir::Identifier>(arg.View(), Allocator()));
80 AllocNode<ir::Identifier>(util::UString(std::forward<T>(arg), Allocator()).View(), Allocator()));
82 nodes.emplace_back(AllocNode<ir::Identifier>(
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)));
94 nodes.emplace_back(AllocNode<ir::OpaqueTypeNode>(type));
101 ir::Expression *CreateExpression(std::string_view sourceCode,
104 ir::Expression *CreateFormattedExpression(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes);
107 ir::Expression *CreateFormattedExpression(std::string_view const sourceCode, Args &&...args)
109 std::vector<ir::AstNode *> insertingNodes {};
115 ir::Statement *CreateFormattedStatement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes);
118 ir::Statement *CreateFormattedStatement(std::string_view const sourceCode, Args &&...args)
120 std::vector<ir::AstNode *> insertingNodes {};
126 ArenaVector<ir::Statement *> CreateStatements(std::string_view sourceCode);
128 ArenaVector<ir::Statement *> CreateFormattedStatements(std::string_view sourceCode,
129 std::vector<ir::AstNode *> &insertingNodes);
132 ArenaVector<ir::Statement *> CreateFormattedStatements(std::string_view const sourceCode, Args &&...args)
134 std::vector<ir::AstNode *> insertingNodes {};
140 ir::ClassDeclaration *CreateFormattedClassDeclaration(std::string_view sourceCode,
141 std::vector<ir::AstNode *> &insertingNodes,
145 ir::ClassDeclaration *CreateFormattedClassDeclaration(std::string_view sourceCode, bool allowStatic, Args &&...args)
147 std::vector<ir::AstNode *> insertingNodes {};
153 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes,
154 const ArenaVector<ir::AstNode *> &properties,
155 ir::ClassDefinitionModifiers modifiers);
158 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, const ArenaVector<ir::AstNode *> &properties,
159 ir::ClassDefinitionModifiers modifiers, Args &&...args)
161 std::vector<ir::AstNode *> insertingNodes {};
168 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, ir::ClassDefinition *classDefinition,
175 ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view sourceCode,
176 std::vector<ir::AstNode *> &insertingNodes);
179 ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view const sourceCode, Args &&...args)
181 std::vector<ir::AstNode *> insertingNodes {};
187 ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view sourceCode,
188 std::vector<ir::AstNode *> &insertingNodes);
191 ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view const sourceCode, Args &&...args)
193 std::vector<ir::AstNode *> insertingNodes {};
199 ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode,
200 std::vector<ir::AstNode *> &insertingNodes);
203 ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode, Args &&...args)
205 std::vector<ir::AstNode *> insertingNodes {};
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;
220 ArenaVector<ir::AstNode *> &ParseAstNodesArrayFormatPlaceholder() const override;
221 ArenaVector<ir::Statement *> &ParseStatementsArrayFormatPlaceholder() const override;
222 ArenaVector<ir::Expression *> &ParseExpressionsArrayFormatPlaceholder() const override;
224 ir::Statement *CreateStatement(std::string_view sourceCode);
226 ir::MethodDefinition *CreateConstructorDefinition(ir::ModifierFlags modifiers, std::string_view sourceCode);
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);
232 ir::TypeNode *CreateTypeAnnotation(TypeAnnotationParsingOptions *options, std::string_view sourceCode);
233 ir::Statement *CreateTopLevelStatement(std::string_view const sourceCode);
242 ir::ETSPackageDeclaration *ParsePackageDeclaration();
244 ArenaVector<ir::Statement *> ParseTopLevelStatements();
251 ir::ImportSource *ParseSourceFromClause(bool requireFrom);
252 void ParseNamedExportSpecifiers(ArenaVector<ir::AstNode *> *specifiers, bool defaultExport);
254 ArenaVector<ir::Statement *> ParseTopLevelDeclaration();
259 std::tuple<ir::ImportSource *, std::vector<std::string>> ParseFromClause(bool requireFrom);
261 std::pair<ArenaVector<ir::ImportSpecifier *>, ArenaVector<ir::ImportDefaultSpecifier *>> ParseNamedSpecifiers();
262 ir::ExportNamedDeclaration *ParseSingleExport(ir::ModifierFlags modifiers);
263 ArenaVector<ir::ETSImportDeclaration *> ParseImportDeclarations();
266 ir::ETSScript *ParseETSGlobalScript(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> &statements);
267 ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers) override;
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 *> ¶ms, 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);
297 void ParseClassFieldDefinition(ir::Identifier *fieldName, ir::ModifierFlags modifiers,
298 ArenaVector<ir::AstNode *> *declarations);
299 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseTypeReferencePart(
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);
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);
316 ir::ArrowFunctionExpression *ParseArrowFunctionExpression();
319 std::optional<lexer::SourcePosition> GetDefaultParamPosition(ArenaVector<ir::Expression *> params);
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,
327 ir::TypeNode *ParseTypeAnnotation(TypeAnnotationParsingOptions *options) override;
328 ir::TSTypeAliasDeclaration *ParseTypeAliasDeclaration() override;
333 ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList(
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,
343 ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
345 ir::AstNode *ParseTypeLiteralOrInterfaceMember() override;
346 void ParseNameSpaceSpecifier(ArenaVector<ir::AstNode *> *specifiers, bool isReExport = false);
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);
357 ir::Expression *ParseUnaryOrPrefixUpdateExpression(
360 ir::Expression *ParseDefaultPrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
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,
366 ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpr) override;
367 ir::Statement *ParseAssertStatement() 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;
374 ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers,
375 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override;
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,
383 ir::AstNode *ParseInnerConstructorDeclaration(ir::ModifierFlags memberModifiers,
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);
389 ir::AstNode *ParseAmbientSignature();
391 ir::ClassDefinition *CreateClassDefinitionForNewExpression(ArenaVector<ir::Expression *> &arguments,
392 ir::TypeNode *typeReference,
393 ir::TypeNode *baseTypeReference);
394 ir::Identifier *CreateInvokeIdentifier();
396 ir::Expression *ParseNewExpression() override;
397 ir::Expression *ParseAsyncExpression();
398 ir::Expression *ParseAwaitExpression();
399 ir::TSTypeParameter *ParseTypeParameter(TypeAnnotationParsingOptions *options) override;
402 ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, bool isConst,
404 void ParseNumberEnum(ArenaVector<ir::AstNode *> &members);
405 void ParseStringEnum(ArenaVector<ir::AstNode *> &members);
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;
415 ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers,
416 ir::ModifierFlags flags = ir::ModifierFlags::NONE) override;
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);
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;
430 void CheckPredefinedMethods(ir::ScriptFunction const *function, const lexer::SourcePosition &position) const;
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,
437 bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression,
439 bool ParsePotentialNonNullExpression(ir::Expression **expression, lexer::SourcePosition startLoc) override;
441 std::pair<ir::ModifierFlags, lexer::SourcePosition> ParseMemberModifiers();
461 ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override;
463 ir::Expression *ParseExpressionOrTypeAnnotation(lexer::TokenType type, ExpressionParseFlags flags) override;
465 ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags) override;
467 ir::ModifierFlags ParseTypeVarianceModifier(TypeAnnotationParsingOptions *const options);
469 ir::Statement *ParseTopLevelDeclStatement(StatementParsingFlags flags);
470 ir::Statement *ParseTopLevelStatement();
472 void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) override;
480 std::optional<ir::Expression *> GetPostPrimaryExpression(ir::Expression *returnExpression,
484 std::vector<ir::AstNode *> insertingNodes_ {};