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 25 namespace ark::es2panda::ir { 26 class ETSPackageDeclaration; 27 enum class ClassDefinitionModifiers : uint32_t; 28 enum class PrimitiveType; 29 } // namespace ark::es2panda::ir 30 31 namespace ark::es2panda::parser { 32 33 class ETSParser final : public TypedParser { 34 public: 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 49 public: 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 FormattingFileName()58 std::string_view FormattingFileName() 59 { 60 return GetContext().FormattingFileName(); 61 } 62 63 template <typename T> SetFormattingFileName(T && fileName)64 void SetFormattingFileName(T &&fileName) 65 { 66 GetContext().SetFormattingFileName(std::forward<T>(fileName)); 67 } 68 69 template <typename T> ProcessFormattedArg(std::vector<ir::AstNode * > & nodes,T && arg)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> CreateFormattedExpression(std::string_view const sourceCode,Args &&...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> CreateFormattedStatement(std::string_view const sourceCode,Args &&...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> CreateFormattedStatements(std::string_view const sourceCode,Args &&...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 ir::Statement *ParseAnnotation(StatementParsingFlags flags, ir::ModifierFlags memberModifiers); 140 ArenaVector<ir::AnnotationUsage *> ParseAnnotations(ir::ModifierFlags &flags, bool isTopLevelSt = true); 141 ir::ClassDeclaration *CreateFormattedClassDeclaration(std::string_view sourceCode, 142 std::vector<ir::AstNode *> &insertingNodes, 143 bool allowStatic = false); 144 145 template <typename... Args> CreateFormattedClassDeclaration(std::string_view sourceCode,bool allowStatic,Args &&...args)146 ir::ClassDeclaration *CreateFormattedClassDeclaration(std::string_view sourceCode, bool allowStatic, Args &&...args) 147 { 148 std::vector<ir::AstNode *> insertingNodes {}; 149 insertingNodes.reserve(sizeof...(Args)); 150 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 151 return CreateFormattedClassDeclaration(sourceCode, insertingNodes, allowStatic); 152 } 153 154 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes, 155 const ArenaVector<ir::AstNode *> &properties, 156 ir::ClassDefinitionModifiers modifiers); 157 158 template <typename... Args> CreateFormattedClassElement(std::string_view sourceCode,const ArenaVector<ir::AstNode * > & properties,ir::ClassDefinitionModifiers modifiers,Args &&...args)159 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, const ArenaVector<ir::AstNode *> &properties, 160 ir::ClassDefinitionModifiers modifiers, Args &&...args) 161 { 162 std::vector<ir::AstNode *> insertingNodes {}; 163 insertingNodes.reserve(sizeof...(Args)); 164 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 165 return CreateFormattedClassElement(sourceCode, insertingNodes, properties, modifiers); 166 } 167 168 template <typename... Args> CreateFormattedClassElement(std::string_view sourceCode,ir::ClassDefinition * classDefinition,Args &&...args)169 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, ir::ClassDefinition *classDefinition, 170 Args &&...args) 171 { 172 return CreateFormattedClassElement(sourceCode, classDefinition->Body(), classDefinition->Modifiers(), 173 std::forward<Args...>(args...)); 174 } 175 176 ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view sourceCode, 177 std::vector<ir::AstNode *> &insertingNodes); 178 179 template <typename... Args> CreateFormattedClassFieldDefinition(std::string_view const sourceCode,Args &&...args)180 ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view const sourceCode, Args &&...args) 181 { 182 std::vector<ir::AstNode *> insertingNodes {}; 183 insertingNodes.reserve(sizeof...(Args)); 184 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 185 return CreateFormattedClassFieldDefinition(sourceCode, insertingNodes); 186 } 187 188 ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view sourceCode, 189 std::vector<ir::AstNode *> &insertingNodes); 190 191 template <typename... Args> CreateFormattedClassMethodDefinition(std::string_view const sourceCode,Args &&...args)192 ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view const sourceCode, Args &&...args) 193 { 194 std::vector<ir::AstNode *> insertingNodes {}; 195 insertingNodes.reserve(sizeof...(Args)); 196 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 197 return CreateFormattedClassMethodDefinition(sourceCode, insertingNodes); 198 } 199 200 ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode, 201 std::vector<ir::AstNode *> &insertingNodes); 202 203 template <typename... Args> CreateFormattedTopLevelStatement(std::string_view sourceCode,Args &&...args)204 ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode, Args &&...args) 205 { 206 std::vector<ir::AstNode *> insertingNodes {}; 207 insertingNodes.reserve(sizeof...(Args)); 208 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 209 return CreateFormattedTopLevelStatement(sourceCode, insertingNodes); 210 } 211 212 private: 213 NodeFormatType GetFormatPlaceholderType(); 214 215 ir::Statement *ParseStatementFormatPlaceholder() override; 216 ir::Expression *ParseExpressionFormatPlaceholder(); 217 ir::Identifier *ParseIdentifierFormatPlaceholder(std::optional<NodeFormatType> nodeFormat) override; 218 ir::TypeNode *ParseTypeFormatPlaceholder(std::optional<NodeFormatType> nodeFormat = std::nullopt); 219 ir::AstNode *ParseTypeParametersFormatPlaceholder() override; 220 221 ArenaVector<ir::AstNode *> &ParseAstNodesArrayFormatPlaceholder() override; 222 ArenaVector<ir::Statement *> &ParseStatementsArrayFormatPlaceholder() override; 223 ArenaVector<ir::Expression *> &ParseExpressionsArrayFormatPlaceholder() override; 224 225 ir::Statement *CreateStatement(std::string_view sourceCode); 226 227 ir::MethodDefinition *CreateConstructorDefinition(ir::ModifierFlags modifiers, std::string_view sourceCode); 228 229 ir::ClassDeclaration *CreateClassDeclaration(std::string_view sourceCode, bool allowStatic = false); 230 ir::AstNode *CreateClassElement(std::string_view sourceCode, const ArenaVector<ir::AstNode *> &properties, 231 ir::ClassDefinitionModifiers modifiers); 232 233 ir::TypeNode *CreateTypeAnnotation(TypeAnnotationParsingOptions *options, std::string_view sourceCode); 234 ir::Statement *CreateTopLevelStatement(std::string_view const sourceCode); 235 236 //============================================================================================// 237 // END: Methods to create AST node(s)... 238 //============================================================================================// 239 240 private: 241 void ParseProgram(ScriptKind kind) override; 242 [[nodiscard]] std::unique_ptr<lexer::Lexer> InitLexer(const SourceFile &sourceFile) override; 243 ir::ETSPackageDeclaration *ParsePackageDeclaration(); 244 void AddPackageSourcesToParseList(); 245 ArenaVector<ir::Statement *> ParseTopLevelStatements(); 246 247 static bool IsClassMethodModifier(lexer::TokenType type) noexcept; 248 249 #ifdef USE_FTW 250 static int NFTWCallBack(const char *fpath, const struct stat * /*unused*/, int tflag, struct FTW * /*unused*/); 251 #endif 252 ir::ImportSource *ParseSourceFromClause(bool requireFrom); 253 void ParseNamedExportSpecifiers(ArenaVector<ir::AstNode *> *specifiers, bool defaultExport); 254 void ParseUserSources(std::vector<std::string> userParths); 255 ArenaVector<ir::Statement *> ParseTopLevelDeclaration(); 256 void ParseSourceList(const util::ImportPathManager::ParseInfo &parseListIdx, util::UString *extSrc, 257 const ArenaVector<util::StringView> &directImportsFromMainSource, 258 std::vector<Program *> &programs); 259 std::vector<Program *> ParseSources(bool firstSource = false); 260 std::tuple<ir::ImportSource *, std::vector<std::string>> ParseFromClause(bool requireFrom); 261 bool IsDefaultImport(); 262 bool ParseNamedSpecifiesHelper(bool *logError); 263 void ParseNamedSpecifiesDefaultImport(ArenaVector<ir::ImportDefaultSpecifier *> *resultDefault, 264 const std::string &fileName); 265 std::pair<ArenaVector<ir::ImportSpecifier *>, ArenaVector<ir::ImportDefaultSpecifier *>> ParseNamedSpecifiers(); 266 ir::ExportNamedDeclaration *ParseSingleExport(ir::ModifierFlags modifiers); 267 ArenaVector<ir::ETSImportDeclaration *> ParseImportDeclarations(); 268 parser::Program *ParseSource(const SourceFile &sourceFile); 269 void AddExternalSource(const std::vector<Program *> &programs); 270 ir::ETSScript *ParseETSGlobalScript(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> &statements); 271 ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers) override; 272 273 ir::MethodDefinition *ParseClassGetterSetterMethod(const ArenaVector<ir::AstNode *> &properties, 274 ir::ClassDefinitionModifiers modifiers, 275 ir::ModifierFlags memberModifiers); 276 ir::MethodDefinition *ParseInterfaceGetterSetterMethod(const ir::ModifierFlags modifiers); 277 ir::Statement *ParseIdentKeyword(); 278 ir::Statement *ParseTypeDeclaration(bool allowStatic = false); 279 ir::Statement *ParseTypeDeclarationAbstractFinal(bool allowStatic, ir::ClassDefinitionModifiers modifiers); 280 ir::ModifierFlags ParseClassModifiers(); 281 ir::ModifierFlags ParseInterfaceMethodModifiers(); 282 ir::ClassProperty *ParseInterfaceField(); 283 ir::MethodDefinition *ParseInterfaceMethod(ir::ModifierFlags flags, ir::MethodDefinitionKind methodKind); 284 std::tuple<ir::ModifierFlags, bool> ParseClassMemberAccessModifiers(); 285 ir::ModifierFlags ParseClassFieldModifiers(bool seenStatic); 286 ir::ModifierFlags ParseClassMethodModifierFlag(); 287 ir::ModifierFlags ParseClassMethodModifiers(bool seenStatic); 288 ir::MethodDefinition *ParseClassMethodDefinition(ir::Identifier *methodName, ir::ModifierFlags modifiers, 289 ir::Identifier *className = nullptr); 290 ir::ScriptFunction *ParseFunction(ParserStatus newStatus, ir::TypeNode *typeAnnotation = nullptr); 291 ir::MethodDefinition *ParseClassMethod(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties, 292 ir::Expression *propName, lexer::SourcePosition *propEnd) override; 293 std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParseFunctionBody( 294 const ArenaVector<ir::Expression *> ¶ms, ParserStatus newStatus, ParserStatus contextStatus) override; 295 ir::TypeNode *ParseFunctionReturnType(ParserStatus status) override; 296 ir::ScriptFunctionFlags ParseFunctionThrowMarker(bool isRethrowsAllowed) override; 297 ir::Expression *CreateParameterThis(ir::TypeNode *typeAnnotation) override; 298 ir::TypeNode *ConvertToOptionalUnionType(ir::TypeNode *typeNode); 299 // NOLINTNEXTLINE(google-default-arguments) 300 void ParseClassFieldDefinition(ir::Identifier *fieldName, ir::ModifierFlags modifiers, 301 ArenaVector<ir::AstNode *> *declarations); 302 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseTypeReferencePart( 303 TypeAnnotationParsingOptions *options); 304 ir::TypeNode *ParseTypeReference(TypeAnnotationParsingOptions *options); 305 ir::TypeNode *ParseBaseTypeReference(TypeAnnotationParsingOptions *options); 306 ir::TypeNode *ParsePrimitiveType(TypeAnnotationParsingOptions *options, ir::PrimitiveType type); 307 ir::TypeNode *ParseUnionType(ir::TypeNode *firstType); 308 ir::TypeNode *GetTypeAnnotationOfPrimitiveType(lexer::TokenType tokenType, TypeAnnotationParsingOptions *options); 309 ir::TypeNode *ParseWildcardType(TypeAnnotationParsingOptions *options); 310 ir::TypeNode *ParseFunctionType(); 311 ir::TypeNode *ParseETSTupleType(TypeAnnotationParsingOptions *options); 312 ir::TypeNode *ParseTsArrayType(ir::TypeNode *typeNode, TypeAnnotationParsingOptions *options); 313 bool ParseTriplePeriod(bool spreadTypePresent); 314 std::pair<bool, std::size_t> CheckDefaultParameters(const ir::ScriptFunction *function) const; 315 static std::string PrimitiveTypeToName(ir::PrimitiveType type); 316 std::string GetNameForTypeNode(const ir::TypeNode *typeAnnotation) const; 317 std::string GetNameForETSUnionType(const ir::TypeNode *typeAnnotation) const; 318 ir::TSInterfaceDeclaration *ParseInterfaceBody(ir::Identifier *name, bool isStatic); 319 bool IsArrowFunctionExpressionStart(); 320 ir::ArrowFunctionExpression *ParseArrowFunctionExpression(); 321 322 void ReportIfVarDeclaration(VariableParsingFlags flags) override; 323 std::optional<lexer::SourcePosition> GetDefaultParamPosition(ArenaVector<ir::Expression *> params); 324 325 ir::TypeNode *ParsePotentialFunctionalType(TypeAnnotationParsingOptions *options, lexer::SourcePosition startLoc); 326 std::pair<ir::TypeNode *, bool> GetTypeAnnotationFromToken(TypeAnnotationParsingOptions *options); 327 std::pair<ir::TypeNode *, bool> GetTypeAnnotationFromParentheses(TypeAnnotationParsingOptions *options); 328 ir::TypeNode *ParseLiteralIdent(TypeAnnotationParsingOptions *options); 329 void ParseRightParenthesis(TypeAnnotationParsingOptions *options, ir::TypeNode *&typeAnnotation, 330 lexer::LexerPosition savedPos); 331 ir::TypeNode *ParseTypeAnnotationNoPreferParam(TypeAnnotationParsingOptions *options); 332 ir::TypeNode *ParseTypeAnnotation(TypeAnnotationParsingOptions *options) override; 333 ir::TSTypeAliasDeclaration *ParseTypeAliasDeclaration() override; 334 335 bool ValidateForInStatement() override; 336 bool ValidAnnotationValue(ir::Expression *initializer); 337 338 // NOLINTNEXTLINE(google-default-arguments) 339 ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList( 340 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 341 ir::Statement *ParseTryStatement() override; 342 ir::DebuggerStatement *ParseDebuggerStatement() override; 343 ir::Statement *ParseExport(lexer::SourcePosition startLoc, ir::ModifierFlags modifiers); 344 ir::Statement *ParseImportDeclaration(StatementParsingFlags flags) override; 345 ir::Statement *ParseExportDeclaration(StatementParsingFlags flags) override; 346 ir::AnnotatedExpression *ParseVariableDeclaratorKey(VariableParsingFlags flags) override; 347 ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc, 348 VariableParsingFlags flags) override; 349 ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags, 350 const lexer::SourcePosition &startLoc) override; 351 ir::AstNode *ParseTypeLiteralOrInterfaceMember() override; 352 void ParseNameSpaceSpecifier(ArenaVector<ir::AstNode *> *specifiers, bool isReExport = false); 353 bool CheckModuleAsModifier(); 354 ir::Expression *ParseFunctionParameterExpression(ir::AnnotatedExpression *paramIdent, 355 ir::ETSUndefinedType *defaultUndef); 356 std::pair<ir::Expression *, std::string> TypeAnnotationValue(ir::TypeNode *typeAnnotation); 357 ir::ETSParameterExpression *ParseFunctionParameterTail(ir::AnnotatedExpression *paramIdent, bool defaultUndefined); 358 ir::Expression *ParseFunctionParameter() override; 359 ir::AnnotatedExpression *GetAnnotatedExpressionFromParam(); 360 ir::ETSUnionType *CreateOptionalParameterTypeNode(ir::TypeNode *typeAnnotation, ir::ETSUndefinedType *defaultUndef); 361 ir::Expression *ResolveArgumentUnaryExpr(ExpressionParseFlags flags); 362 // NOLINTNEXTLINE(google-default-arguments) 363 ir::Expression *ParseUnaryOrPrefixUpdateExpression( 364 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 365 // NOLINTNEXTLINE(google-default-arguments) 366 ir::Expression *ParsePropertyDefinition(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 367 // NOLINTNEXTLINE(google-default-arguments) 368 ir::Expression *ParseDefaultPrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 369 // NOLINTNEXTLINE(google-default-arguments) 370 ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 371 ir::Expression *ParsePrimaryExpressionWithLiterals(ExpressionParseFlags flags) override; 372 ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc, 373 bool ignoreCallExpression, bool *isChainExpression) override; 374 ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpr) override; 375 ir::Statement *ParseAssertStatement() override; 376 bool ValidateLabeledStatement(lexer::TokenType type) override; 377 ir::Expression *ParseCatchParam() override; 378 void ParseCatchParamTypeAnnotation([[maybe_unused]] ir::AnnotatedExpression *param) override; 379 ir::Expression *ParseSuperClassReference() override; 380 ir::Identifier *ParseClassIdent(ir::ClassDefinitionModifiers modifiers) override; 381 // NOLINTNEXTLINE(google-default-arguments) 382 ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers, 383 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override; 384 // NOLINTNEXTLINE(google-default-arguments) 385 ir::ETSStructDeclaration *ParseStructStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers, 386 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override; 387 ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers, 388 ir::ModifierFlags flags) override; 389 void UpdateMemberModifiers(ir::ModifierFlags &memberModifiers, bool &seenStatic); 390 void ApplyAnnotationsToNode(ir::AstNode *node, ArenaVector<ir::AnnotationUsage *> &&annotations, 391 lexer::SourcePosition pos); 392 ir::ModifierFlags ParseMemberAccessModifiers(); 393 template <bool IS_USAGE> 394 ir::Expression *ParseAnnotationName(); 395 ir::AnnotationDeclaration *ParseAnnotationDeclaration( 396 [[maybe_unused]] ir::ModifierFlags flags = ir::ModifierFlags::NONE); 397 ir::AstNode *ParseAnnotationProperty(ir::Identifier *fieldName, 398 ir::ModifierFlags memberModifiers = ir::ModifierFlags::NONE, 399 bool needTypeAnnotation = true); 400 ArenaVector<ir::AstNode *> ParseAnnotationProperties(ir::ModifierFlags memberModifiers = ir::ModifierFlags::NONE); 401 ir::AnnotationUsage *ParseAnnotationUsage(); 402 ir::AstNode *ParseInnerTypeDeclaration(ir::ModifierFlags memberModifiers, lexer::LexerPosition savedPos, 403 bool isStepToken, bool seenStatic); 404 ir::AstNode *ParseInnerConstructorDeclaration(ir::ModifierFlags memberModifiers, 405 const lexer::SourcePosition &startLoc); 406 ir::AstNode *ParseInnerRest(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers, 407 ir::ModifierFlags memberModifiers, const lexer::SourcePosition &startLoc); 408 void CheckAccessorDeclaration(ir::ModifierFlags memberModifiers); 409 410 ir::AstNode *ParseAmbientSignature(); 411 412 ir::ClassDefinition *CreateClassDefinitionForNewExpression(ArenaVector<ir::Expression *> &arguments, 413 ir::TypeNode *typeReference, 414 ir::TypeNode *baseTypeReference); 415 ir::Identifier *CreateInvokeIdentifier(); 416 417 ir::Expression *ParseNewExpression() override; 418 ir::Expression *ParseAsyncExpression(); 419 ir::Expression *ParseAwaitExpression(); 420 ir::Expression *ParseETSImportExpression(); 421 ir::TSTypeParameter *ParseTypeParameter(TypeAnnotationParsingOptions *options) override; 422 423 bool IsStringEnum(); 424 ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, bool isConst, 425 bool isStatic) override; 426 bool ParseNumberEnumEnd(); 427 bool ParseNumberEnumHelper(); 428 void ParseNumberEnum(ArenaVector<ir::AstNode *> &members); 429 void ParseStringEnum(ArenaVector<ir::AstNode *> &members); 430 431 ir::Statement *ParseInterfaceDeclaration(bool isStatic) override; 432 ir::TypeNode *ParseThisType(TypeAnnotationParsingOptions *options); 433 ir::Statement *ParseFunctionStatement(StatementParsingFlags flags) override; 434 ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous, ir::ModifierFlags modifiers); 435 ir::TypeNode *ParseExtensionFunctionsTypeAnnotation(); 436 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseClassImplementsElement() override; 437 ir::TypeNode *ParseInterfaceExtendsElement() override; 438 // NOLINTNEXTLINE(google-default-arguments) 439 ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers, 440 ir::ModifierFlags flags = ir::ModifierFlags::NONE) override; 441 bool CheckInNamespaceContextIsExported(); 442 ir::NamespaceDeclaration *ParseNamespaceDeclaration(ir::ModifierFlags flags); 443 ir::NamespaceDefinition *ParseNamespaceDefinition(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags); 444 using NamespaceBody = std::tuple<ir::MethodDefinition *, ArenaVector<ir::AstNode *>, lexer::SourceRange>; 445 NamespaceBody ParseNamespaceBody(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags); 446 // NOLINTNEXTLINE(google-default-arguments) 447 ir::Statement *ParseEnumDeclaration(bool isConst = false, bool isStatic = false) override; 448 ir::Statement *ParsePotentialConstEnum(VariableParsingFlags flags) override; 449 ir::Expression *ParseLaunchExpression(ExpressionParseFlags flags); 450 void ValidateInstanceOfExpression(ir::Expression *expr); 451 void ValidateRestParameter(ir::Expression *param) override; 452 bool ValidateBreakLabel(util::StringView label) override; 453 bool ValidateContinueLabel(util::StringView label) override; 454 void CheckPredefinedMethods(ir::ScriptFunction const *function, const lexer::SourcePosition &position); 455 456 bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor, 457 ArenaVector<ir::AstNode *> &properties) override; 458 void CreateImplicitConstructor(ir::MethodDefinition *&ctor, ArenaVector<ir::AstNode *> &properties, 459 ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags, 460 const lexer::SourcePosition &startLoc) override; 461 bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression, 462 const lexer::SourcePosition &startLoc, bool ignoreCallExpression) override; 463 bool ParsePotentialNonNullExpression(ir::Expression **expression, lexer::SourcePosition startLoc) override; 464 465 std::pair<ir::ModifierFlags, lexer::SourcePosition> ParseMemberModifiers(); 466 ArkTSConfig()467 std::shared_ptr<ArkTsConfig> ArkTSConfig() const 468 { 469 return GetOptions().arktsConfig; 470 } 471 IsETSModule()472 bool IsETSModule() const 473 { 474 return GetOptions().isEtsModule; 475 } 476 477 bool IsStructKeyword() const; 478 IsExternal()479 bool IsExternal() const override 480 { 481 return util::Helpers::IsStdLib(GetProgram()); 482 } 483 484 // NOLINTNEXTLINE(google-default-arguments) 485 ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 486 487 ir::Expression *ParseExpressionOrTypeAnnotation(lexer::TokenType type, ExpressionParseFlags flags) override; 488 489 ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags) override; 490 491 ir::ModifierFlags ParseTypeVarianceModifier(TypeAnnotationParsingOptions *const options); 492 493 ir::Statement *ParseTopLevelDeclStatement(StatementParsingFlags flags); 494 ir::Statement *ParseTopLevelStatement(); 495 496 void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) override; 497 498 void CheckDeclare(); 499 500 friend class ExternalSourceParser; 501 friend class InnerSourceParser; 502 503 private: 504 std::optional<ir::Expression *> GetPostPrimaryExpression(ir::Expression *returnExpression, 505 lexer::SourcePosition startLoc, bool ignoreCallExpression, 506 [[maybe_unused]] bool *isChainExpression); 507 parser::Program *globalProgram_; 508 std::vector<ir::AstNode *> insertingNodes_ {}; 509 std::unique_ptr<util::ImportPathManager> importPathManager_ {nullptr}; 510 }; 511 512 class ExternalSourceParser { 513 public: 514 explicit ExternalSourceParser(ETSParser *parser, Program *newProgram); 515 NO_COPY_SEMANTIC(ExternalSourceParser); 516 NO_MOVE_SEMANTIC(ExternalSourceParser); 517 518 ~ExternalSourceParser(); 519 520 void *operator new(size_t) = delete; 521 void *operator new[](size_t) = delete; 522 523 private: 524 ETSParser *parser_; 525 Program *savedProgram_; 526 lexer::Lexer *savedLexer_; 527 varbinder::GlobalScope *savedTopScope_; 528 }; 529 530 class InnerSourceParser { 531 public: 532 explicit InnerSourceParser(ETSParser *parser); 533 NO_COPY_SEMANTIC(InnerSourceParser); 534 NO_MOVE_SEMANTIC(InnerSourceParser); 535 536 ~InnerSourceParser(); 537 538 void *operator new(size_t) = delete; 539 void *operator new[](size_t) = delete; 540 541 private: 542 ETSParser *parser_; 543 lexer::Lexer *savedLexer_; 544 util::StringView savedSourceCode_ {}; 545 util::StringView savedSourceFile_ {}; 546 util::StringView savedSourceFilePath_ {}; 547 }; 548 549 class SavedFormattingFileName { 550 public: SavedFormattingFileName(ETSParser * parser,std::string_view fname)551 SavedFormattingFileName(ETSParser *parser, std::string_view fname) 552 : parser_(parser), savedFname_(parser->FormattingFileName()) 553 { 554 parser->SetFormattingFileName(fname); 555 } 556 557 NO_COPY_SEMANTIC(SavedFormattingFileName); 558 NO_MOVE_SEMANTIC(SavedFormattingFileName); 559 ~SavedFormattingFileName()560 ~SavedFormattingFileName() 561 { 562 parser_->SetFormattingFileName(savedFname_); 563 } 564 565 private: 566 ETSParser *parser_; 567 std::string_view savedFname_; 568 }; 569 570 } // namespace ark::es2panda::parser 571 #endif 572