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