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 140 ir::ClassDeclaration *CreateFormattedClassDeclaration(std::string_view sourceCode, 141 std::vector<ir::AstNode *> &insertingNodes, 142 bool allowStatic = false); 143 144 template <typename... Args> CreateFormattedClassDeclaration(std::string_view sourceCode, bool allowStatic, Args &&...args)145 ir::ClassDeclaration *CreateFormattedClassDeclaration(std::string_view sourceCode, bool allowStatic, Args &&...args) 146 { 147 std::vector<ir::AstNode *> insertingNodes {}; 148 insertingNodes.reserve(sizeof...(Args)); 149 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 150 return CreateFormattedClassDeclaration(sourceCode, insertingNodes, allowStatic); 151 } 152 153 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, std::vector<ir::AstNode *> &insertingNodes, 154 const ArenaVector<ir::AstNode *> &properties, 155 ir::ClassDefinitionModifiers modifiers); 156 157 template <typename... Args> CreateFormattedClassElement(std::string_view sourceCode, const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers, Args &&...args)158 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, const ArenaVector<ir::AstNode *> &properties, 159 ir::ClassDefinitionModifiers modifiers, Args &&...args) 160 { 161 std::vector<ir::AstNode *> insertingNodes {}; 162 insertingNodes.reserve(sizeof...(Args)); 163 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 164 return CreateFormattedClassElement(sourceCode, insertingNodes, properties, modifiers); 165 } 166 167 template <typename... Args> CreateFormattedClassElement(std::string_view sourceCode, ir::ClassDefinition *classDefinition, Args &&...args)168 ir::AstNode *CreateFormattedClassElement(std::string_view sourceCode, ir::ClassDefinition *classDefinition, 169 Args &&...args) 170 { 171 return CreateFormattedClassElement(sourceCode, classDefinition->Body(), classDefinition->Modifiers(), 172 std::forward<Args...>(args...)); 173 } 174 175 ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view sourceCode, 176 std::vector<ir::AstNode *> &insertingNodes); 177 178 template <typename... Args> CreateFormattedClassFieldDefinition(std::string_view const sourceCode, Args &&...args)179 ir::AstNode *CreateFormattedClassFieldDefinition(std::string_view const sourceCode, Args &&...args) 180 { 181 std::vector<ir::AstNode *> insertingNodes {}; 182 insertingNodes.reserve(sizeof...(Args)); 183 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 184 return CreateFormattedClassFieldDefinition(sourceCode, insertingNodes); 185 } 186 187 ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view sourceCode, 188 std::vector<ir::AstNode *> &insertingNodes); 189 190 template <typename... Args> CreateFormattedClassMethodDefinition(std::string_view const sourceCode, Args &&...args)191 ir::AstNode *CreateFormattedClassMethodDefinition(std::string_view const sourceCode, Args &&...args) 192 { 193 std::vector<ir::AstNode *> insertingNodes {}; 194 insertingNodes.reserve(sizeof...(Args)); 195 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 196 return CreateFormattedClassMethodDefinition(sourceCode, insertingNodes); 197 } 198 199 ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode, 200 std::vector<ir::AstNode *> &insertingNodes); 201 202 template <typename... Args> CreateFormattedTopLevelStatement(std::string_view sourceCode, Args &&...args)203 ir::Statement *CreateFormattedTopLevelStatement(std::string_view sourceCode, Args &&...args) 204 { 205 std::vector<ir::AstNode *> insertingNodes {}; 206 insertingNodes.reserve(sizeof...(Args)); 207 (ProcessFormattedArg(insertingNodes, std::forward<Args>(args)), ...); 208 return CreateFormattedTopLevelStatement(sourceCode, insertingNodes); 209 } 210 211 private: 212 NodeFormatType GetFormatPlaceholderType() const; 213 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; 219 220 ArenaVector<ir::AstNode *> &ParseAstNodesArrayFormatPlaceholder() const override; 221 ArenaVector<ir::Statement *> &ParseStatementsArrayFormatPlaceholder() const override; 222 ArenaVector<ir::Expression *> &ParseExpressionsArrayFormatPlaceholder() const override; 223 224 ir::Statement *CreateStatement(std::string_view sourceCode); 225 226 ir::MethodDefinition *CreateConstructorDefinition(ir::ModifierFlags modifiers, std::string_view sourceCode); 227 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); 231 232 ir::TypeNode *CreateTypeAnnotation(TypeAnnotationParsingOptions *options, std::string_view sourceCode); 233 ir::Statement *CreateTopLevelStatement(std::string_view const sourceCode); 234 235 //============================================================================================// 236 // END: Methods to create AST node(s)... 237 //============================================================================================// 238 239 private: 240 void ParseProgram(ScriptKind kind) override; 241 [[nodiscard]] std::unique_ptr<lexer::Lexer> InitLexer(const SourceFile &sourceFile) override; 242 ir::ETSPackageDeclaration *ParsePackageDeclaration(); 243 void AddPackageSourcesToParseList(); 244 ArenaVector<ir::Statement *> ParseTopLevelStatements(); 245 246 static bool IsClassMethodModifier(lexer::TokenType type) noexcept; 247 248 #ifdef USE_FTW 249 static int NFTWCallBack(const char *fpath, const struct stat * /*unused*/, int tflag, struct FTW * /*unused*/); 250 #endif 251 ir::ImportSource *ParseSourceFromClause(bool requireFrom); 252 void ParseNamedExportSpecifiers(ArenaVector<ir::AstNode *> *specifiers, bool defaultExport); 253 void ParseUserSources(std::vector<std::string> userParths); 254 ArenaVector<ir::Statement *> ParseTopLevelDeclaration(); 255 void TryParseSource(const util::ImportPathManager::ParseInfo &parseListIdx, util::UString *extSrc, 256 const ArenaVector<util::StringView> &directImportsFromMainSource, 257 std::vector<Program *> &programs); 258 std::vector<Program *> ParseSources(bool firstSource = false); 259 std::tuple<ir::ImportSource *, std::vector<std::string>> ParseFromClause(bool requireFrom); 260 bool IsDefaultImport(); 261 std::pair<ArenaVector<ir::ImportSpecifier *>, ArenaVector<ir::ImportDefaultSpecifier *>> ParseNamedSpecifiers(); 262 ir::ExportNamedDeclaration *ParseSingleExport(ir::ModifierFlags modifiers); 263 ArenaVector<ir::ETSImportDeclaration *> ParseImportDeclarations(); 264 parser::Program *ParseSource(const SourceFile &sourceFile); 265 void AddExternalSource(const std::vector<Program *> &programs); 266 ir::ETSScript *ParseETSGlobalScript(lexer::SourcePosition startLoc, ArenaVector<ir::Statement *> &statements); 267 ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers) override; 268 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); 296 // NOLINTNEXTLINE(google-default-arguments) 297 void ParseClassFieldDefinition(ir::Identifier *fieldName, ir::ModifierFlags modifiers, 298 ArenaVector<ir::AstNode *> *declarations); 299 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseTypeReferencePart( 300 TypeAnnotationParsingOptions *options); 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); 309 bool ParseTriplePeriod(bool spreadTypePresent); 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); 315 bool IsArrowFunctionExpressionStart(); 316 ir::ArrowFunctionExpression *ParseArrowFunctionExpression(); 317 318 void ThrowIfVarDeclaration(VariableParsingFlags flags) override; 319 std::optional<lexer::SourcePosition> GetDefaultParamPosition(ArenaVector<ir::Expression *> params); 320 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, 326 lexer::LexerPosition savedPos); 327 ir::TypeNode *ParseTypeAnnotation(TypeAnnotationParsingOptions *options) override; 328 ir::TSTypeAliasDeclaration *ParseTypeAliasDeclaration() override; 329 330 void ValidateForInStatement() override; 331 332 // NOLINTNEXTLINE(google-default-arguments) 333 ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList( 334 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 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, 342 VariableParsingFlags flags) override; 343 ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags, 344 const lexer::SourcePosition &startLoc) override; 345 ir::AstNode *ParseTypeLiteralOrInterfaceMember() override; 346 void ParseNameSpaceSpecifier(ArenaVector<ir::AstNode *> *specifiers, bool isReExport = false); 347 bool CheckModuleAsModifier(); 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); 356 // NOLINTNEXTLINE(google-default-arguments) 357 ir::Expression *ParseUnaryOrPrefixUpdateExpression( 358 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 359 // NOLINTNEXTLINE(google-default-arguments) 360 ir::Expression *ParseDefaultPrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 361 // NOLINTNEXTLINE(google-default-arguments) 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, 365 bool ignoreCallExpression, bool *isChainExpression) override; 366 ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpr) override; 367 ir::Statement *ParseAssertStatement() override; 368 void ValidateLabeledStatement(lexer::TokenType type) 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; 373 // NOLINTNEXTLINE(google-default-arguments) 374 ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers, 375 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE) override; 376 // NOLINTNEXTLINE(google-default-arguments) 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, 382 bool isStepToken, bool seenStatic); 383 ir::AstNode *ParseInnerConstructorDeclaration(ir::ModifierFlags memberModifiers, 384 const lexer::SourcePosition &startLoc); 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); 388 389 ir::AstNode *ParseAmbientSignature(); 390 391 ir::ClassDefinition *CreateClassDefinitionForNewExpression(ArenaVector<ir::Expression *> &arguments, 392 ir::TypeNode *typeReference, 393 ir::TypeNode *baseTypeReference); 394 ir::Identifier *CreateInvokeIdentifier(); 395 396 ir::Expression *ParseNewExpression() override; 397 ir::Expression *ParseAsyncExpression(); 398 ir::Expression *ParseAwaitExpression(); 399 ir::TSTypeParameter *ParseTypeParameter(TypeAnnotationParsingOptions *options) override; 400 401 bool IsStringEnum(); 402 ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, bool isConst, 403 bool isStatic) override; 404 void ParseNumberEnum(ArenaVector<ir::AstNode *> &members); 405 void ParseStringEnum(ArenaVector<ir::AstNode *> &members); 406 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; 414 // NOLINTNEXTLINE(google-default-arguments) 415 ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers, 416 ir::ModifierFlags flags = ir::ModifierFlags::NONE) override; 417 bool CheckInNamespaceContextIsExported(); 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); 422 // NOLINTNEXTLINE(google-default-arguments) 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; 428 bool ValidateBreakLabel(util::StringView label) override; 429 bool ValidateContinueLabel(util::StringView label) override; 430 void CheckPredefinedMethods(ir::ScriptFunction const *function, const lexer::SourcePosition &position) const; 431 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, 436 const lexer::SourcePosition &startLoc) override; 437 bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression, 438 const lexer::SourcePosition &startLoc, bool ignoreCallExpression) override; 439 bool ParsePotentialNonNullExpression(ir::Expression **expression, lexer::SourcePosition startLoc) override; 440 441 std::pair<ir::ModifierFlags, lexer::SourcePosition> ParseMemberModifiers(); 442 ArkTSConfig() const443 std::shared_ptr<ArkTsConfig> ArkTSConfig() const 444 { 445 return GetOptions().arktsConfig; 446 } 447 IsETSModule() const448 bool IsETSModule() const 449 { 450 return GetOptions().isEtsModule; 451 } 452 453 bool IsStructKeyword() const; 454 455 bool IsExternal() const override 456 { 457 return util::Helpers::IsStdLib(GetProgram()); 458 } 459 460 // NOLINTNEXTLINE(google-default-arguments) 461 ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 462 463 ir::Expression *ParseExpressionOrTypeAnnotation(lexer::TokenType type, ExpressionParseFlags flags) override; 464 465 ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags) override; 466 467 ir::ModifierFlags ParseTypeVarianceModifier(TypeAnnotationParsingOptions *const options); 468 469 ir::Statement *ParseTopLevelDeclStatement(StatementParsingFlags flags); 470 ir::Statement *ParseTopLevelStatement(); 471 472 void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) override; 473 474 void CheckDeclare(); 475 476 friend class ExternalSourceParser; 477 friend class InnerSourceParser; 478 479 private: 480 std::optional<ir::Expression *> GetPostPrimaryExpression(ir::Expression *returnExpression, 481 lexer::SourcePosition startLoc, bool ignoreCallExpression, 482 [[maybe_unused]] bool *isChainExpression); 483 parser::Program *globalProgram_; 484 std::vector<ir::AstNode *> insertingNodes_ {}; 485 std::unique_ptr<util::ImportPathManager> importPathManager_ {nullptr}; 486 }; 487 488 class ExternalSourceParser { 489 public: 490 explicit ExternalSourceParser(ETSParser *parser, Program *newProgram); 491 NO_COPY_SEMANTIC(ExternalSourceParser); 492 NO_MOVE_SEMANTIC(ExternalSourceParser); 493 494 ~ExternalSourceParser(); 495 496 void *operator new(size_t) = delete; 497 void *operator new[](size_t) = delete; 498 499 private: 500 ETSParser *parser_; 501 Program *savedProgram_; 502 lexer::Lexer *savedLexer_; 503 varbinder::GlobalScope *savedTopScope_; 504 }; 505 506 class InnerSourceParser { 507 public: 508 explicit InnerSourceParser(ETSParser *parser); 509 NO_COPY_SEMANTIC(InnerSourceParser); 510 NO_MOVE_SEMANTIC(InnerSourceParser); 511 512 ~InnerSourceParser(); 513 514 void *operator new(size_t) = delete; 515 void *operator new[](size_t) = delete; 516 517 private: 518 ETSParser *parser_; 519 lexer::Lexer *savedLexer_; 520 util::StringView savedSourceCode_ {}; 521 util::StringView savedSourceFile_ {}; 522 util::StringView savedSourceFilePath_ {}; 523 }; 524 525 class SavedFormattingFileName { 526 public: SavedFormattingFileName(ETSParser *parser, std::string_view fname)527 SavedFormattingFileName(ETSParser *parser, std::string_view fname) 528 : parser_(parser), savedFname_(parser->FormattingFileName()) 529 { 530 parser->SetFormattingFileName(fname); 531 } 532 533 NO_COPY_SEMANTIC(SavedFormattingFileName); 534 NO_MOVE_SEMANTIC(SavedFormattingFileName); 535 ~SavedFormattingFileName()536 ~SavedFormattingFileName() 537 { 538 parser_->SetFormattingFileName(savedFname_); 539 } 540 541 private: 542 ETSParser *parser_; 543 std::string_view savedFname_; 544 }; 545 546 } // namespace ark::es2panda::parser 547 #endif 548