1 /** 2 * Copyright (c) 2021-2025 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 "innerSourceParser.h" 22 #include "TypedParser.h" 23 #include "ir/base/classDefinition.h" 24 #include "ir/module/importDeclaration.h" 25 #include <utility> 26 27 namespace ark::es2panda::ir { 28 class ETSPackageDeclaration; 29 enum class ClassDefinitionModifiers : uint32_t; 30 enum class PrimitiveType; 31 } // namespace ark::es2panda::ir 32 33 namespace ark::es2panda::parser { 34 35 struct SpecifiersInfo { 36 ArenaVector<ir::ImportSpecifier *> result; 37 ArenaVector<ir::ImportDefaultSpecifier *> resultDefault; 38 ArenaVector<ir::ExportSpecifier *> resultExportDefault; 39 }; 40 41 class ETSParser final : public TypedParser { 42 public: 43 ETSParser(Program *program, const util::Options &options, util::DiagnosticEngine &diagnosticEngine, 44 ParserStatus status); 45 ETSParser(Program *program, std::nullptr_t options, util::DiagnosticEngine &diagnosticEngine); 46 47 ETSParser() = delete; 48 NO_COPY_SEMANTIC(ETSParser); 49 NO_MOVE_SEMANTIC(ETSParser); 50 51 ~ETSParser() final = default; 52 GetImportPathManager()53 util::ImportPathManager *GetImportPathManager() 54 { 55 return importPathManager_.get(); 56 } 57 GetGlobalProgramAbsName()58 util::StringView GetGlobalProgramAbsName() 59 { 60 return globalProgram_->AbsoluteName(); 61 } 62 GetGlobalProgram()63 Program *GetGlobalProgram() 64 { 65 return globalProgram_; 66 } 67 68 [[nodiscard]] bool IsETSParser() const noexcept override; 69 70 void AddDirectImportsToDirectExternalSources(const ArenaVector<util::StringView> &directImportsFromMainSource, 71 parser::Program *newProg) const; 72 bool CheckDupAndReplace(Program *&oldProg, Program *newProg); 73 ArenaVector<ir::ETSImportDeclaration *> ParseDefaultSources(std::string_view srcFile, std::string_view importSrc); 74 lexer::LexerPosition HandleJsDocLikeComments(); 75 76 public: 77 //============================================================================================// 78 // Methods to create AST node(s) from the specified string (part of valid ETS-code!) 79 // NOTE: ScopeInitPhase, SetParent should be called on created subtree after calling any of these methods, 80 //============================================================================================// 81 82 template <typename> 83 static constexpr bool STATIC_FALSE = false; 84 FormattingFileName()85 std::string_view FormattingFileName() 86 { 87 return GetContext().FormattingFileName(); 88 } 89 90 ir::TypeNode *CreateFormattedTypeAnnotation(std::string_view const sourceCode); 91 ir::TypeNode *CreateFormattedTypeAnnotation(std::string_view sourceCode, std::vector<ir::AstNode *> &args); 92 93 #include "parser/ETSparserTemplates.h" 94 95 ir::Expression *CreateExpression(std::string_view sourceCode, 96 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 97 ir::Expression *CreateFormattedExpression(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes); 98 99 ir::Expression *CreateFormattedExpression(std::string_view const sourceCode, ArenaVector<ir::Expression *> &args); 100 ir::Statement *CreateFormattedStatement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes); 101 ArenaVector<ir::Statement *> CreateStatements(std::string_view sourceCode); 102 ArenaVector<ir::Statement *> CreateFormattedStatements(std::string_view sourceCode, 103 std::vector<ir::AstNode *> &insertingNodes); 104 ir::Statement *ParseTopLevelAnnotation(ir::ModifierFlags memberModifiers); 105 ArenaVector<ir::AnnotationUsage *> ParseAnnotations(bool isTopLevelSt); 106 ir::Statement *CreateFormattedClassDeclaration(std::string_view sourceCode, 107 std::vector<ir::AstNode *> &insertingNodes, 108 bool allowStatic = false); 109 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes, 110 const ArenaVector<ir::AstNode *> &properties, 111 ir::ClassDefinitionModifiers modifiers); 112 ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view sourceCode, 113 std::vector<ir::AstNode *> &insertingNodes); 114 ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view sourceCode, 115 std::vector<ir::AstNode *> &insertingNodes); 116 ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode, 117 std::vector<ir::AstNode *> &insertingNodes); 118 void ApplyAnnotationsToNode(ir::AstNode *node, ArenaVector<ir::AnnotationUsage *> &&annotations, 119 lexer::SourcePosition pos, 120 TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::NO_OPTS); 121 [[nodiscard]] bool IsInitializerBlockStart() const; 122 GetNamespaceNestedRank()123 uint32_t GetNamespaceNestedRank() 124 { 125 return namespaceNestedRank_; 126 } 127 IncrementNamespaceNestedRank()128 void IncrementNamespaceNestedRank() 129 { 130 namespaceNestedRank_++; 131 } 132 DecrementNamespaceNestedRank()133 void DecrementNamespaceNestedRank() 134 { 135 namespaceNestedRank_--; 136 } 137 138 ir::ETSImportDeclaration *BuildImportDeclaration(ir::ImportKinds importKind, 139 ArenaVector<ir::AstNode *> &&specifiers, 140 ir::StringLiteral *pathToResolve, parser::Program *program, 141 util::ImportFlags importFlag); 142 143 void AddExternalSource(const std::vector<Program *> &programs); 144 std::vector<Program *> ParseSources(bool firstSource = false); 145 static void AddGenExtenralSourceToParseList(public_lib::Context *ctx); 146 147 private: 148 void ParseAndSetStdlib(); 149 NodeFormatType GetFormatPlaceholderType(); 150 ir::Statement *ParseStatementFormatPlaceholder() override; 151 ir::Expression *ParseExpressionFormatPlaceholder(); 152 ir::Identifier *ParseIdentifierFormatPlaceholder(std::optional<NodeFormatType> nodeFormat) override; 153 ir::TypeNode *ParseTypeFormatPlaceholder(std::optional<NodeFormatType> nodeFormat = std::nullopt); 154 ir::AstNode *ParseTypeParametersFormatPlaceholder() override; 155 void ApplyJsDocInfoToSpecificNodeType(ir::AstNode *node, ArenaVector<ir::JsDocInfo> &&jsDocInformation); 156 void ApplyAnnotationsToArrayType(ir::AstNode *node, ArenaVector<ir::AnnotationUsage *> &&annotations, 157 lexer::SourcePosition pos); 158 void ApplyAnnotationsToSpecificNodeType(ir::AstNode *node, ArenaVector<ir::AnnotationUsage *> &&annotations, 159 lexer::SourcePosition pos); 160 ArenaVector<ir::AstNode *> &ParseAstNodesArrayFormatPlaceholder() override; 161 ArenaVector<ir::Statement *> &ParseStatementsArrayFormatPlaceholder() override; 162 ArenaVector<ir::Expression *> &ParseExpressionsArrayFormatPlaceholder() override; 163 ir::Statement *CreateStatement(std::string_view sourceCode); 164 ir::MethodDefinition *CreateConstructorDefinition(ir::ModifierFlags modifiers, std::string_view sourceCode); 165 ir::Statement *CreateClassDeclaration(std::string_view sourceCode, bool allowStatic = false); 166 ir::AstNode *CreateClassElement(std::string_view sourceCode, const ArenaVector<ir::AstNode *> &properties, 167 ir::ClassDefinitionModifiers modifiers); 168 ir::TypeNode *CreateTypeAnnotation(TypeAnnotationParsingOptions *options, std::string_view sourceCode); 169 ir::Statement *CreateTopLevelStatement(std::string_view const sourceCode); 170 171 //============================================================================================// 172 // END: Methods to create AST node(s)... 173 //============================================================================================// 174 175 private: 176 void ParseProgram(ScriptKind kind) override; 177 [[nodiscard]] std::unique_ptr<lexer::Lexer> InitLexer(const SourceFile &sourceFile) override; 178 ir::ETSPackageDeclaration *ParsePackageDeclaration(); 179 void AddPackageSourcesToParseList(); 180 ArenaVector<ir::Statement *> ParseTopLevelStatements(); 181 ir::AstNode *HandleAmbientDeclaration(ir::ModifierFlags &memberModifiers, 182 const std::function<ir::AstNode *(ir::Identifier *)> &parseClassMethod); 183 static bool IsClassMethodModifier(lexer::TokenType type) noexcept; 184 185 #ifdef USE_FTW 186 static int NFTWCallBack(const char *fpath, const struct stat * /*unused*/, int tflag, struct FTW * /*unused*/); 187 #endif 188 ir::ETSImportDeclaration *ParseImportPathBuildImport(ArenaVector<ir::AstNode *> &&specifiers, bool requireFrom, 189 lexer::SourcePosition startLoc, ir::ImportKinds importKind); 190 void ParseNamedExportSpecifiers(ArenaVector<ir::AstNode *> *specifiers, bool defaultExport); 191 void ParseUserSources(std::vector<std::string> userParths); 192 ArenaVector<ir::Statement *> ParseTopLevelDeclaration(); 193 void ParseParseListElement(const util::ImportPathManager::ParseInfo &parseListElem, util::UString *extSrc, 194 const ArenaVector<util::StringView> &directImportsFromMainSource, 195 std::vector<Program *> *programs); 196 bool IsDefaultImport(); 197 void ParseNamedSpecifiesDefaultImport(ArenaVector<ir::ImportDefaultSpecifier *> *resultDefault, 198 const std::string &fileName); 199 bool ParseNamedSpecifiesImport(ArenaVector<ir::ImportSpecifier *> *result, 200 ArenaVector<ir::ExportSpecifier *> *resultExportDefault, 201 const std::string &fileName); 202 SpecifiersInfo ParseNamedSpecifiers(); 203 ir::ExportNamedDeclaration *ParseSingleExport(ir::ModifierFlags modifiers); 204 ir::ExportNamedDeclaration *ParseSingleExportForAnonymousConst(ir::ModifierFlags modifiers); 205 ArenaVector<ir::ETSImportDeclaration *> ParseImportDeclarations(); 206 ir::Statement *ParseImportDeclarationHelper(lexer::SourcePosition startLoc, ArenaVector<ir::AstNode *> &specifiers, 207 ir::ImportKinds importKind); 208 std::vector<Program *> SearchForNotParsed(ArenaVector<util::ImportPathManager::ParseInfo> &parseList, 209 ArenaVector<util::StringView> &directImportsFromMainSource); 210 parser::Program *ParseSource(const SourceFile &sourceFile); 211 ir::ETSModule *ParseETSGlobalScript(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> &statements); 212 void ParseFileHeaderFlag(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> *statements); 213 ir::ETSModule *ParseImportsOnly(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> &statements); 214 ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers) override; 215 void *ApplyAnnotationsToClassElement(ir::AstNode *property, ArenaVector<ir::AnnotationUsage *> &&annotations, 216 lexer::SourcePosition pos); 217 void ApplyJsDocInfoToClassElement(ir::AstNode *property, ArenaVector<ir::JsDocInfo> &&jsDocInformation); 218 ir::MethodDefinition *ParseClassGetterSetterMethod(const ArenaVector<ir::AstNode *> &properties, 219 ir::ClassDefinitionModifiers modifiers, 220 ir::ModifierFlags memberModifiers, bool isDefault); 221 ir::MethodDefinition *ParseInterfaceGetterSetterMethod(const ir::ModifierFlags modifiers); 222 ir::Statement *ParseIdentKeyword(); 223 ir::Statement *ParseTypeDeclaration(bool allowStatic = false); 224 ir::Statement *ParseTypeDeclarationAbstractFinal(bool allowStatic, ir::ClassDefinitionModifiers modifiers); 225 ir::ModifierFlags ParseClassModifiers(); 226 ir::ModifierFlags ParseInterfaceMethodModifiers(); 227 ir::AstNode *ParseInterfaceField(); 228 ir::TypeNode *ParseInterfaceTypeAnnotation(ir::Identifier *name); 229 void ParseInterfaceModifiers(ir::ModifierFlags &fieldModifiers, bool &optionalField); 230 ir::MethodDefinition *ParseInterfaceMethod(ir::ModifierFlags flags, ir::MethodDefinitionKind methodKind); 231 void ReportAccessModifierError(const lexer::Token &token); 232 std::tuple<ir::ModifierFlags, bool, bool> ParseClassMemberAccessModifiers(); 233 ir::ModifierFlags ParseClassFieldModifiers(bool seenStatic); 234 ir::ModifierFlags ParseClassMethodModifierFlag(); 235 ir::ModifierFlags ParseClassMethodModifiers(bool seenStatic); 236 ir::MethodDefinition *ParseClassMethodDefinition(ir::Identifier *methodName, ir::ModifierFlags modifiers, 237 bool isDefault); 238 ir::ScriptFunction *ParseFunction(ParserStatus newStatus); 239 ir::MethodDefinition *ParseClassMethod(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties, 240 ir::Expression *propName, lexer::SourcePosition *propEnd) override; 241 std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParseFunctionBody( 242 const ArenaVector<ir::Expression *> ¶ms, ParserStatus newStatus, ParserStatus contextStatus) override; 243 ir::TypeNode *ParseFunctionReturnType(ParserStatus status) override; 244 ir::ScriptFunctionFlags ParseFunctionThrowMarker(bool isRethrowsAllowed) override; 245 ir::Expression *CreateParameterThis(ir::TypeNode *typeAnnotation) override; 246 ir::TypeNode *ConvertToOptionalUnionType(ir::TypeNode *typeAnno); 247 void ValidateFieldModifiers(ir::ModifierFlags modifiers, bool optionalField, ir::Expression *initializer, 248 lexer::SourcePosition pos); 249 // NOLINTNEXTLINE(google-default-arguments) 250 void ParseClassFieldDefinition(ir::Identifier *fieldName, ir::ModifierFlags modifiers, 251 ArenaVector<ir::AstNode *> *declarations, bool isDefault); 252 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseTypeReferencePart( 253 TypeAnnotationParsingOptions *options); 254 ir::TypeNode *ParseTypeReference(TypeAnnotationParsingOptions *options); 255 ir::TypeNode *ParseBaseTypeReference(TypeAnnotationParsingOptions *options); 256 ir::TypeNode *ParsePrimitiveType(TypeAnnotationParsingOptions *options, ir::PrimitiveType type); 257 ir::TypeNode *ParseUnionType(ir::TypeNode *firstType); 258 ir::TypeNode *GetTypeAnnotationOfPrimitiveType(lexer::TokenType tokenType, TypeAnnotationParsingOptions *options); 259 ir::TypeNode *ParseWildcardType(TypeAnnotationParsingOptions *options); 260 ir::TypeNode *ParseFunctionType(TypeAnnotationParsingOptions *options); 261 ir::TypeNode *ParseETSTupleType(TypeAnnotationParsingOptions *options); 262 ir::TypeNode *ParseTsArrayType(ir::TypeNode *typeNode, TypeAnnotationParsingOptions *options); 263 bool ParseTriplePeriod(bool spreadTypePresent); 264 std::pair<bool, std::size_t> CheckDefaultParameters(const ir::ScriptFunction *function); 265 std::string PrimitiveTypeToName(ir::PrimitiveType type) const; 266 std::string GetNameForTypeNode(const ir::TypeNode *typeAnnotation) const; 267 std::string GetNameForETSUnionType(const ir::TypeNode *typeAnnotation) const; 268 ir::TSInterfaceDeclaration *ParseInterfaceBody(ir::Identifier *name, bool isStatic); 269 bool IsArrowFunctionExpressionStart(); 270 ir::ArrowFunctionExpression *ParseArrowFunctionExpression(); 271 void ReportIfVarDeclaration(VariableParsingFlags flags) override; 272 ir::TypeNode *ParsePotentialFunctionalType(TypeAnnotationParsingOptions *options); 273 std::pair<ir::TypeNode *, bool> GetTypeAnnotationFromToken(TypeAnnotationParsingOptions *options); 274 std::pair<ir::TypeNode *, bool> GetTypeAnnotationFromParentheses(TypeAnnotationParsingOptions *options); 275 ir::TypeNode *ParseLiteralIdent(TypeAnnotationParsingOptions *options); 276 void ParseRightParenthesis(TypeAnnotationParsingOptions *options, ir::TypeNode *&typeAnnotation, 277 lexer::LexerPosition savedPos); 278 ir::TypeNode *ParseTypeAnnotationNoPreferParam(TypeAnnotationParsingOptions *options); 279 ir::TypeNode *ParseTypeAnnotation(TypeAnnotationParsingOptions *options) override; 280 bool ParseReadonlyInTypeAnnotation(); 281 ir::TypeNode *ParseMultilineString(); 282 ir::TSTypeAliasDeclaration *ParseTypeAliasDeclaration() override; 283 bool ValidateForInStatement() override; 284 bool ValidAnnotationValue(ir::Expression *initializer); 285 // NOLINTNEXTLINE(google-default-arguments) 286 ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList( 287 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 288 ir::Statement *ParseTryStatement() override; 289 ir::Statement *ParseDebuggerStatement() override; 290 ir::Statement *ParseExport(lexer::SourcePosition startLoc, ir::ModifierFlags modifiers); 291 ir::Statement *ParseImportDeclaration(StatementParsingFlags flags) override; 292 ir::Statement *ParseExportDeclaration(StatementParsingFlags flags) override; 293 ir::AnnotatedExpression *ParseVariableDeclaratorKey(VariableParsingFlags flags) override; 294 ir::Statement *ParseAnnotationsInStatement(StatementParsingFlags flags) override; 295 ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc, 296 VariableParsingFlags flags) override; 297 ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags, 298 const lexer::SourcePosition &startLoc) override; 299 bool IsFieldStartToken(lexer::TokenType t); 300 ir::AstNode *ParseTypeLiteralOrInterfaceMember() override; 301 ir::AstNode *ParseJsDocInfoInInterfaceBody(); 302 ir::AstNode *ParseAnnotationsInInterfaceBody(); 303 void ParseNameSpaceSpecifier(ArenaVector<ir::AstNode *> *specifiers, bool isReExport = false); 304 bool CheckModuleAsModifier(); 305 bool IsFixedArrayTypeNode(ir::AstNode *node); 306 ir::Expression *ParseFunctionParameterExpression(ir::AnnotatedExpression *paramIdent, bool isOptional); 307 std::pair<ir::Expression *, std::string> TypeAnnotationValue(ir::TypeNode *typeAnnotation); 308 ir::ETSParameterExpression *ParseFunctionParameterTail(ir::AnnotatedExpression *paramIdent, bool defaultUndefined); 309 ir::Expression *ParseFunctionParameterAnnotations(); 310 ir::Expression *ParseFunctionParameter() override; 311 ir::Expression *ParseFunctionReceiver(); 312 ir::AnnotatedExpression *GetAnnotatedExpressionFromParam(); 313 ir::Expression *ResolveArgumentUnaryExpr(ExpressionParseFlags flags); 314 ir::Expression *CreateUnaryExpressionFromArgument(ir::Expression *argument, lexer::TokenType operatorType, 315 char32_t beginningChar); 316 // NOLINTNEXTLINE(google-default-arguments) 317 ir::Expression *ParseUnaryOrPrefixUpdateExpression( 318 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 319 // NOLINTNEXTLINE(google-default-arguments) 320 ir::Expression *ParsePropertyDefinition(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 321 ir::Expression *ParsePropertyKey(ExpressionParseFlags flags) override; 322 // NOLINTNEXTLINE(google-default-arguments) 323 ir::Expression *ParseDefaultPrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 324 // NOLINTNEXTLINE(google-default-arguments) 325 ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 326 ir::Expression *ParsePrimaryExpressionWithLiterals(ExpressionParseFlags flags) override; 327 ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc, 328 bool ignoreCallExpression, bool *isChainExpression) override; 329 ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpr) override; 330 bool ValidateLabeledStatement(lexer::TokenType type) override; 331 ir::Expression *ParseCatchParam() override; 332 void ParseCatchParamTypeAnnotation([[maybe_unused]] ir::AnnotatedExpression *param) override; 333 ir::Expression *ParseSuperClassReference() override; 334 ir::Identifier *ParseClassIdent(ir::ClassDefinitionModifiers modifiers) override; 335 // NOLINTNEXTLINE(google-default-arguments) 336 ir::Statement *ParseClassStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers, 337 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override; 338 // NOLINTNEXTLINE(google-default-arguments) 339 ir::Statement *ParseStructStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers, 340 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override; 341 ir::AstNode *ParseClassElementHelper( 342 const ArenaVector<ir::AstNode *> &properties, 343 std::tuple<ir::ClassDefinitionModifiers, ir::ModifierFlags, ir::ModifierFlags> modifierInfo, 344 std::tuple<bool, bool, bool> elementFlag, std::tuple<lexer::SourcePosition, lexer::LexerPosition> posInfo); 345 // NOLINTNEXTLINE(google-default-arguments) 346 ir::Statement *ParseInterfaceStatement(StatementParsingFlags flags) override; 347 ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers, 348 ir::ModifierFlags flags) override; 349 std::tuple<bool, bool, bool> HandleClassElementModifiers(ir::ModifierFlags &memberModifiers); 350 void UpdateMemberModifiers(ir::ModifierFlags &memberModifiers, bool &seenStatic); 351 ir::ModifierFlags ParseMemberAccessModifiers(); 352 template <bool IS_USAGE> 353 ir::Expression *ParseAnnotationName(); 354 ir::AnnotationDeclaration *ParseAnnotationDeclaration( 355 [[maybe_unused]] ir::ModifierFlags flags = ir::ModifierFlags::NONE); 356 ir::AstNode *ParseAnnotationProperty(ir::Identifier *fieldName, 357 ir::ModifierFlags memberModifiers = ir::ModifierFlags::NONE, 358 bool needTypeAnnotation = true); 359 ArenaVector<ir::AstNode *> ParseAnnotationProperties(ir::ModifierFlags memberModifiers = ir::ModifierFlags::NONE); 360 ir::AnnotationUsage *ParseAnnotationUsage(); 361 bool TryParseAnnotations(); 362 void TryParseAnnotationsParams(); 363 bool IsAnnotationUsageStart(lexer::SourcePosition lastTokenEndIndex); 364 ir::AstNode *ParseInnerTypeDeclaration(ir::ModifierFlags memberModifiers, lexer::LexerPosition savedPos, 365 bool isStepToken, bool seenStatic); 366 ir::AstNode *ParseInnerConstructorDeclaration(ir::ModifierFlags memberModifiers, 367 const lexer::SourcePosition &startLoc, bool isDefault); 368 ir::AstNode *ParseInnerRest(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers, 369 ir::ModifierFlags memberModifiers, const lexer::SourcePosition &startLoc, 370 bool isDefault); 371 bool CheckAccessorDeclaration(ir::ModifierFlags memberModifiers); 372 ir::AstNode *ParseAmbientSignature(const lexer::SourcePosition &startPosAmbient); 373 void ParseArgumentsNewExpression(ArenaVector<ir::Expression *> &arguments, ir::TypeNode *typeReference); 374 ir::Identifier *CreateInvokeIdentifier(); 375 ir::Expression *ParseNewExpression() override; 376 ir::Expression *ParseAsyncExpression(); 377 ir::Expression *ParseAwaitExpression(); 378 ir::ArrayExpression *ParseArrayExpression(ExpressionParseFlags flags) override; 379 ir::TSTypeParameter *ParseTypeParameter(TypeAnnotationParsingOptions *options) override; 380 bool IsStringEnum(); 381 ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, bool isConst, 382 bool isStatic) override; 383 ir::Expression *ParseEnumExpression(); 384 bool ParseNumberEnumHelper(); 385 lexer::SourcePosition ParseEnumMember(ArenaVector<ir::AstNode *> &members); 386 ir::Statement *ParseInterfaceDeclaration(bool isStatic) override; 387 ir::TypeNode *ParseThisType(TypeAnnotationParsingOptions *options); 388 ir::Statement *ParseFunctionStatement(StatementParsingFlags flags) override; 389 ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous, ir::ModifierFlags modifiers); 390 ir::FunctionDeclaration *ParseAccessorWithReceiver(ir::ModifierFlags modifiers); 391 ir::TypeNode *ParseExtensionFunctionsTypeAnnotation(); 392 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseClassImplementsElement() override; 393 ir::TypeNode *ParseInterfaceExtendsElement() override; 394 // NOLINTNEXTLINE(google-default-arguments) 395 ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers, 396 ir::ModifierFlags flags = ir::ModifierFlags::NONE) override; 397 bool CheckInNamespaceContextIsExported(); 398 ir::ETSModule *ParseNamespaceStatement(ir::ModifierFlags memberModifiers); 399 ir::Statement *ParseNamespace(ir::ModifierFlags flags) override; 400 ir::ETSModule *ParseNamespaceImp(ir::ModifierFlags flags); 401 using NamespaceBody = std::tuple<ir::MethodDefinition *, ArenaVector<ir::AstNode *>, lexer::SourceRange>; 402 NamespaceBody ParseNamespaceBody(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags); 403 // NOLINTNEXTLINE(google-default-arguments) 404 ir::Statement *ParseEnumDeclaration(bool isConst = false, bool isStatic = false) override; 405 ir::Statement *ParsePotentialConstEnum(VariableParsingFlags flags) override; 406 void ValidateInstanceOfExpression(ir::Expression *expr); 407 void ValidateRestParameter(ir::Expression *param) override; 408 bool ValidateBreakLabel(util::StringView label) override; 409 bool ValidateContinueLabel(util::StringView label) override; 410 void CheckPredefinedMethods(ir::ScriptFunction const *function, const lexer::SourcePosition &position); 411 bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor, 412 ArenaVector<ir::AstNode *> &properties) override; 413 void CreateImplicitConstructor(ir::MethodDefinition *&ctor, ArenaVector<ir::AstNode *> &properties, 414 ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags, 415 const lexer::SourcePosition &startLoc) override; 416 bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression, 417 const lexer::SourcePosition &startLoc, bool ignoreCallExpression) override; 418 bool ParsePotentialNonNullExpression(ir::Expression **expression, lexer::SourcePosition startLoc) override; 419 std::pair<ir::ModifierFlags, lexer::SourcePosition> ParseMemberModifiers(); 420 void SkipInvalidType() const; 421 bool IsStructKeyword() const; 422 IsExternal()423 bool IsExternal() const override 424 { 425 return util::Helpers::IsStdLib(GetProgram()); 426 } 427 428 // NOLINTNEXTLINE(google-default-arguments) 429 ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 430 ir::Expression *ParseExpressionOrTypeAnnotation(lexer::TokenType type, ExpressionParseFlags flags) override; 431 ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags) override; 432 ir::ModifierFlags ParseTypeVarianceModifier(TypeAnnotationParsingOptions *const options); 433 bool IsExportedDeclaration(ir::ModifierFlags memberModifiers); 434 ir::Statement *ParseTopLevelDeclStatement(StatementParsingFlags flags); 435 ir::Statement *ParseTopLevelStatement(); 436 void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) override; 437 void CheckDeclare(); 438 439 void ExcludeInvalidStart(); 440 std::tuple<util::StringView, util::StringView> ParseJsDocInfoItemValue(); 441 std::string ParseJsDocInfoItemParam(); 442 ir::JsDocInfo ParseJsDocInfo(); 443 ArenaVector<ir::JsDocInfo> ParseJsDocInfos(); 444 445 friend class ExternalSourceParser; 446 friend class InnerSourceParser; 447 448 private: 449 uint32_t namespaceNestedRank_; 450 std::optional<ir::Expression *> GetPostPrimaryExpression(ir::Expression *returnExpression, 451 lexer::SourcePosition startLoc, bool ignoreCallExpression, 452 [[maybe_unused]] bool *isChainExpression); 453 parser::Program *globalProgram_; 454 std::vector<ir::AstNode *> insertingNodes_ {}; 455 std::unique_ptr<util::ImportPathManager> importPathManager_ {nullptr}; 456 }; 457 458 class ExternalSourceParser { 459 public: 460 explicit ExternalSourceParser(ETSParser *parser, Program *newProgram); 461 NO_COPY_SEMANTIC(ExternalSourceParser); 462 NO_MOVE_SEMANTIC(ExternalSourceParser); 463 464 ~ExternalSourceParser(); 465 466 void *operator new(size_t) = delete; 467 void *operator new[](size_t) = delete; 468 469 private: 470 ETSParser *parser_; 471 Program *savedProgram_; 472 lexer::Lexer *savedLexer_; 473 varbinder::GlobalScope *savedTopScope_; 474 }; 475 476 class SavedFormattingFileName { 477 public: SavedFormattingFileName(ETSParser * parser,std::string_view fname)478 SavedFormattingFileName(ETSParser *parser, std::string_view fname) 479 : parser_(parser), savedFname_(parser->FormattingFileName()) 480 { 481 parser->SetFormattingFileName(fname); 482 } 483 484 NO_COPY_SEMANTIC(SavedFormattingFileName); 485 NO_MOVE_SEMANTIC(SavedFormattingFileName); 486 ~SavedFormattingFileName()487 ~SavedFormattingFileName() 488 { 489 parser_->SetFormattingFileName(savedFname_); 490 } 491 492 private: 493 ETSParser *parser_; 494 std::string_view savedFname_; 495 }; 496 } // namespace ark::es2panda::parser 497 #endif 498