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_PARSER_IMPL_H 17 #define ES2PANDA_PARSER_CORE_PARSER_IMPL_H 18 19 #include "forwardDeclForParserImpl.h" 20 #include "ir/base/scriptFunctionSignature.h" 21 #include "lexer/token/sourceLocation.h" 22 #include "generated/tokenType.h" 23 #include "parser/context/classPrivateContext.h" 24 #include "parser/context/parserContext.h" 25 #include "parser/parserFlags.h" 26 #include "parser/program/program.h" 27 #include "util/diagnosticEngine.h" 28 #include "util/helpers.h" 29 #include "util/recursiveGuard.h" 30 31 namespace ark::es2panda::lexer { 32 class RegExpParser; 33 enum class NextTokenFlags : uint32_t; 34 } // namespace ark::es2panda::lexer 35 36 namespace ark::es2panda::util { 37 class Options; 38 class SourcePositionHelper; 39 } // namespace ark::es2panda::util 40 41 namespace ark::es2panda::public_lib { 42 struct Context; 43 } // namespace ark::es2panda::public_lib 44 45 namespace ark::es2panda::parser { 46 using ENUMBITOPS_OPERATORS; 47 48 enum class TypeAnnotationParsingOptions : uint32_t { 49 NO_OPTS = 0U, 50 IN_UNION = 1U << 0U, 51 ALLOW_CONST = 1U << 1U, 52 IN_INTERSECTION = 1U << 2U, 53 RESTRICT_EXTENDS = 1U << 3U, 54 REPORT_ERROR = 1U << 4U, 55 CAN_BE_TS_TYPE_PREDICATE = 1U << 5U, 56 BREAK_AT_NEW_LINE = 1U << 6U, 57 RETURN_TYPE = 1U << 7U, 58 POTENTIAL_CLASS_LITERAL = 1U << 8U, 59 ALLOW_INTERSECTION = 1U << 9U, 60 ADD_TYPE_PARAMETER_BINDING = 1U << 10U, 61 DISALLOW_PRIMARY_TYPE = 1U << 11U, 62 ALLOW_WILDCARD = 1U << 12U, 63 IGNORE_FUNCTION_TYPE = 1U << 13U, 64 ALLOW_DECLARATION_SITE_VARIANCE = 1U << 14U, 65 DISALLOW_UNION = 1U << 15U, 66 POTENTIAL_NEW_ARRAY = 1U << 16U, 67 ANNOTATION_NOT_ALLOW = 1U << 17U 68 }; 69 70 class ParserImpl { 71 public: 72 explicit ParserImpl(Program *program, const util::Options *options, util::DiagnosticEngine &diagnosticEngine, 73 ParserStatus status = ParserStatus::NO_OPTS); 74 NO_COPY_SEMANTIC(ParserImpl); 75 NO_MOVE_SEMANTIC(ParserImpl); 76 virtual ~ParserImpl() = default; 77 78 void ParseScript(const SourceFile &sourceFile, bool genStdLib); 79 IsETSParser()80 [[nodiscard]] virtual bool IsETSParser() const noexcept 81 { 82 return false; 83 } 84 AsETSParser()85 ETSParser *AsETSParser() 86 { 87 ES2PANDA_ASSERT(IsETSParser()); 88 return reinterpret_cast<ETSParser *>(this); 89 } 90 AsETSParser()91 const ETSParser *AsETSParser() const 92 { 93 ES2PANDA_ASSERT(IsETSParser()); 94 return reinterpret_cast<const ETSParser *>(this); 95 } 96 DiagnosticEngine()97 util::DiagnosticEngine &DiagnosticEngine() const 98 { 99 return diagnosticEngine_; 100 } 101 SetParserStatus(ParserStatus status)102 void SetParserStatus(ParserStatus status) 103 { 104 GetContext().Status() |= status; 105 } 106 107 lexer::SourcePosition GetPositionForDiagnostic() const; 108 SetContext(public_lib::Context * ctx)109 void SetContext(public_lib::Context *ctx) 110 { 111 ctx_ = ctx; 112 } 113 Context()114 public_lib::Context *Context() 115 { 116 return ctx_; 117 } 118 119 protected: 120 virtual void ParseProgram(ScriptKind kind); 121 static ExpressionParseFlags CarryExpressionParserFlag(ExpressionParseFlags origin, ExpressionParseFlags carry); 122 static ExpressionParseFlags CarryPatternFlags(ExpressionParseFlags flags); 123 124 void LogIfPrivateIdent(ClassElementDescriptor *desc, const diagnostic::DiagnosticKind &diagnostic, 125 const util::DiagnosticMessageParams &diagnosticParams = {}); 126 void ValidateClassKey(ClassElementDescriptor *desc); 127 bool ValidatePrivateIdentifier(); 128 129 ir::VariableDeclaratorFlag GetFlag(VariableParsingFlags flags); 130 131 void ValidateAccessor(ExpressionParseFlags flags, lexer::TokenFlags currentTokenFlags); 132 void CheckPropertyKeyAsyncModifier(ParserStatus *methodStatus); 133 ir::Property *ParseShorthandProperty(const lexer::LexerPosition *startPos); 134 void ParseGeneratorPropertyModifier(ExpressionParseFlags flags, ParserStatus *methodStatus); 135 bool ParsePropertyModifiers(ExpressionParseFlags flags, ir::PropertyKind *propertyKind, ParserStatus *methodStatus); 136 ir::Expression *ParsePropertyValue(const ir::PropertyKind *propertyKind, const ParserStatus *methodStatus, 137 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 138 void ParsePropertyEndErrorHendler(); 139 bool ParsePropertyEnd(); 140 141 // ExpressionParser.Cpp 142 143 ir::Expression *ParseKeywordExpression(); 144 ir::Expression *ParseBinaryExpression(ir::Expression *left, const lexer::TokenType operatorType); 145 void ValidateUpdateExpression(ir::Expression *returnExpression, bool isChainExpression); 146 ir::Expression *ParseMemberExpression(bool ignoreCallExpression = false, 147 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 148 ir::Expression *SetupChainExpr(ir::Expression *const top, lexer::SourcePosition startLoc); 149 ir::MetaProperty *ParsePotentialNewTarget(); 150 void ValidateParenthesizedExpression(ir::Expression *lhsExpression); 151 void ValidateGroupedExpression(ir::Expression *lhsExpression); 152 ir::Expression *ParseImportExpression(); 153 ir::Expression *ParseOptionalChain(ir::Expression *leftSideExpr); 154 virtual ir::Expression *ParsePropertyKey(ExpressionParseFlags flags); 155 void ValidateAssignmentTarget(ExpressionParseFlags flags, ir::Expression *node); 156 void ValidateLvalueAssignmentTarget(ir::Expression *node); 157 void ValidateArrowParameterBindings(const ir::Expression *node); 158 ir::Identifier *ParseNamedExport(lexer::Token *exportedToken); ParseTrailingBlock(ir::CallExpression * callExpr)159 virtual void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) {} 160 ir::Expression *CreateBinaryAssignmentExpression(ir::Expression *assignmentExpression, 161 ir::Expression *lhsExpression, lexer::TokenType tokenType); 162 163 // StatementParser.Cpp 164 165 void CheckFunctionDeclaration(StatementParsingFlags flags); 166 void CheckLabelledFunction(const ir::Statement *node); 167 bool ParseDirective(ArenaVector<ir::Statement *> *statements); 168 void ParseDirectivePrologue(ArenaVector<ir::Statement *> *statements); 169 ir::BlockStatement *ParseFunctionBody(); 170 std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseIsForInOf( 171 ir::Expression *leftNode, ExpressionParseFlags exprFlags); 172 std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseForInOf( 173 ir::Expression *leftNode, ExpressionParseFlags exprFlags, bool isAwait); 174 std::tuple<ForStatementKind, ir::Expression *, ir::Expression *> ParseForInOf(ir::AstNode *initNode, 175 ExpressionParseFlags exprFlags, 176 bool isAwait); 177 std::tuple<ir::Expression *, ir::Expression *> ParseForUpdate(bool isAwait); 178 std::tuple<ir::Expression *, ir::Statement *> ParseForLoopInitializer(); 179 ir::SwitchCaseStatement *ParseSwitchCaseStatement(bool *seenDefault); 180 virtual ir::Expression *ParseCatchParam(); 181 ir::CatchClause *ParseCatchClause(); 182 ir::VariableDeclaration *ParseContextualLet(VariableParsingFlags flags, 183 StatementParsingFlags stmFlags = StatementParsingFlags::ALLOW_LEXICAL); 184 ir::Statement *CreateForStatement(struct ForStatementNodes &&nodes, ForStatementKind forKind, 185 const lexer::SourcePosition &startLoc, bool isAwait); 186 187 friend class Lexer; 188 friend class SavedParserContext; 189 friend class SavedClassPrivateContext; 190 friend class ArrowFunctionContext; 191 friend class ETSNolintParser; 192 friend class lexer::RegExpParser; 193 friend class util::SourcePositionHelper; 194 195 void LogExpectedToken(lexer::TokenType tokenType); 196 void LogUnexpectedToken(lexer::TokenType tokenType); 197 void LogUnexpectedToken(lexer::Token const &token); 198 199 public: 200 void LogError(util::DiagnosticType errorType, std::string_view errorMessage, const lexer::SourcePosition &pos); 201 void LogError(const diagnostic::DiagnosticKind &diagnostic, 202 const util::DiagnosticMessageParams &diagnosticParams = {}); 203 void LogError(const diagnostic::DiagnosticKind &diagnostic, const util::DiagnosticMessageParams &diagnosticParams, 204 const lexer::SourcePosition &pos); 205 void LogSyntaxError(std::string_view errorMessage); 206 void LogSyntaxError(const util::DiagnosticMessageParams &list); 207 void LogSyntaxError(std::string_view errorMessage, const lexer::SourcePosition &pos); 208 void LogSyntaxError(const util::DiagnosticMessageParams &list, const lexer::SourcePosition &pos); 209 210 protected: 211 void LogParameterModifierError(ir::ModifierFlags status); 212 // Error handling 213 ir::Statement *AllocEmptyStatement(); 214 ir::Statement *AllocBrokenStatement(const lexer::SourcePosition &pos); 215 ir::Statement *AllocBrokenStatement(const lexer::SourceRange &range); 216 bool IsBrokenStatement(ir::Statement *st); 217 218 template <typename T, typename... Args> AllocNode(Args &&...args)219 T *AllocNode(Args &&...args) 220 { 221 auto *ret = util::NodeAllocator::ForceSetParent<T>( 222 Allocator(), std::forward<Args>(args)...); // Note: replace with AllocNode 223 ES2PANDA_ASSERT(ret != nullptr); 224 return ret; 225 } 226 227 ir::Identifier *AllocBrokenExpression(const lexer::SourcePosition &pos); 228 ir::Identifier *AllocBrokenExpression(const lexer::SourceRange &range); 229 ir::TypeNode *AllocBrokenType(const lexer::SourcePosition &pos); 230 ir::TypeNode *AllocBrokenType(const lexer::SourceRange &range); 231 Allocator()232 ArenaAllocator *Allocator() const 233 { 234 return program_->Allocator(); 235 } 236 237 bool CheckModuleAsModifier(); 238 239 // ETS extension IsExternal()240 virtual bool IsExternal() const 241 { 242 return false; 243 } 244 245 util::StringView ParseSymbolIteratorIdentifier() const noexcept; 246 ir::Identifier *ExpectIdentifier(bool isReference = false, bool isUserDefinedType = false, 247 TypeAnnotationParsingOptions options = TypeAnnotationParsingOptions::REPORT_ERROR); 248 void ExpectToken(lexer::TokenType tokenType, bool consumeToken = true); 249 250 // ExpressionParser.cpp 251 252 ir::SpreadElement *ParseSpreadElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 253 ir::YieldExpression *ParseYieldExpression(); 254 virtual ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags); 255 ir::ArrowFunctionExpression *ParseArrowFunctionExpressionBody(ArrowFunctionContext *arrowFunctionContext, 256 ArrowFunctionDescriptor *desc, 257 ir::TSTypeParameterDeclaration *typeParamDecl, 258 ir::TypeNode *returnTypeAnnotation); 259 ir::Expression *ParseAssignmentExpressionHelper(); 260 ir::Expression *ParseAssignmentExpression(ir::Expression *lhsExpression, 261 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 262 ir::Expression *ParseAssignmentBinaryExpression(lexer::TokenType tokenType, ir::Expression *lhsExpression, 263 ExpressionParseFlags flags); 264 ir::Expression *ParseAssignmentEqualExpression(lexer::TokenType tokenType, ir::Expression *lhsExpression, 265 ExpressionParseFlags flags); 266 ir::SequenceExpression *ParseSequenceExpression(ir::Expression *startExpr, bool acceptRest = false); 267 ir::FunctionExpression *ParseFunctionExpression(ParserStatus newStatus = ParserStatus::NO_OPTS); 268 ir::ArrowFunctionExpression *ParseArrowFunctionExpression(ir::Expression *expr, 269 ir::TSTypeParameterDeclaration *typeParamDecl, 270 ir::TypeNode *returnTypeAnnotation, bool isAsync); 271 ir::CallExpression *ParseCallExpression(ir::Expression *callee, bool isOptionalChain = false, 272 bool handleEval = true); 273 ArenaVector<ir::Expression *> ParseCallExpressionArguments(bool &trailingComma, lexer::SourcePosition &endLoc); 274 275 ir::TemplateLiteral *ParseTemplateLiteral(); 276 ir::Expression *ParseLeftHandSideExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 277 void ParseNameSpaceImport(ArenaVector<ir::AstNode *> *specifiers); 278 void ParseNamedImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers); 279 ir::StringLiteral *ParseFromClause(bool requireFrom = true); 280 281 ir::BooleanLiteral *ParseBooleanLiteral(); 282 ir::NullLiteral *ParseNullLiteral(); 283 ir::Literal *ParseNumberLiteral(); 284 ir::CharLiteral *ParseCharLiteral(); 285 ir::StringLiteral *ParseStringLiteral(); 286 ir::UndefinedLiteral *ParseUndefinedLiteral(); 287 virtual ir::ThisExpression *ParseThisExpression(); 288 ir::RegExpLiteral *ParseRegularExpression(); 289 ir::SuperExpression *ParseSuperExpression(); 290 ir::MemberExpression *ParseElementAccess(ir::Expression *primaryExpr, bool isOptional = false); 291 ir::MemberExpression *ParsePrivatePropertyAccess(ir::Expression *primaryExpr); 292 ir::MemberExpression *ParsePropertyAccess(ir::Expression *primaryExpr, bool isOptional = false); 293 void CreateAmendedBinaryExpression(ir::Expression *left, ir::Expression *right, lexer::TokenType operatorType); 294 295 // StatementParser 296 ArenaVector<ir::Statement *> ParseStatementList(StatementParsingFlags flags = StatementParsingFlags::ALLOW_LEXICAL); 297 virtual bool ValidateLabeledStatement(lexer::TokenType type); 298 ir::BlockStatement *ParseBlockStatement(); 299 ir::EmptyStatement *ParseEmptyStatement(); 300 ir::Statement *ParseForStatement(); 301 ir::Statement *ParseIfStatement(); 302 virtual ir::Statement *ParseFunctionStatement(StatementParsingFlags flags); 303 // NOLINTNEXTLINE(google-default-arguments) 304 virtual ir::Statement *ParseClassStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers, 305 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE); 306 // NOLINTNEXTLINE(google-default-arguments) 307 virtual ir::Statement *ParseStructStatement(StatementParsingFlags flags, ir::ClassDefinitionModifiers modifiers, 308 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE); 309 // NOLINTNEXTLINE(google-default-arguments) 310 virtual ir::Statement *ParseInterfaceStatement(StatementParsingFlags flags); 311 ir::Statement *ParseStatementBasedOnTokenType(StatementParsingFlags flags); 312 ir::Statement *ParseVarStatement(); 313 ir::Statement *ParseLetStatement(StatementParsingFlags flags); 314 ir::Statement *ParseBreakStatement(); 315 ir::Statement *ParseContinueStatement(); 316 ir::Statement *ParseDoWhileStatement(); 317 ir::Statement *ParseWhileStatement(); 318 ir::Statement *ParseSwitchStatement(); 319 ir::Statement *ParseReturnStatement(); 320 ir::Statement *ParseExpressionStatement(StatementParsingFlags flags = StatementParsingFlags::NONE); 321 ir::Statement *ParseLabelledStatement(const lexer::LexerPosition &pos); 322 virtual void ValidateRestParameter(ir::Expression *param); 323 virtual bool ValidateBreakLabel(util::StringView label); 324 virtual bool ValidateContinueLabel(util::StringView label); 325 bool InAmbientContext(); 326 327 ir::MethodDefinition *BuildImplicitConstructor(ir::ClassDefinitionModifiers modifiers, 328 const lexer::SourcePosition &startLoc); 329 330 virtual void CreateImplicitConstructor(ir::MethodDefinition *&ctor, ArenaVector<ir::AstNode *> &properties, 331 ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags, 332 const lexer::SourcePosition &startLoc); 333 void CheckClassGeneratorMethod(ClassElementDescriptor *desc, char32_t *nextCp); 334 void ParseClassAccessor(ClassElementDescriptor *desc, char32_t *nextCp); 335 ir::Expression *ParseClassKey(ClassElementDescriptor *desc); 336 ir::ClassElement *ParseClassProperty(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties, 337 ir::Expression *propName, ir::TypeNode *typeAnnotation); 338 void AddPrivateElement(const ir::ClassElement *elem); 339 ir::ScriptFunction *ParseFunction(ParserStatus newStatus = ParserStatus::NO_OPTS); 340 ir::ModifierFlags GetAccessability(ir::ModifierFlags modifiers); 341 void CheckAccessorPair(const ArenaVector<ir::AstNode *> &properties, const ir::Expression *propName, 342 ir::MethodDefinitionKind methodKind, ir::ModifierFlags access); 343 ir::Identifier *ParseNamedImport(lexer::Token *importedToken); 344 void ConsumeSemicolon(ir::Statement *statement); 345 ir::ExportAllDeclaration *ParseExportAllDeclaration(const lexer::SourcePosition &startLoc); 346 ir::ExportNamedDeclaration *ParseExportNamedSpecifiers(const lexer::SourcePosition &startLoc); 347 ir::Statement *ParseVariableDeclaration(VariableParsingFlags flags = VariableParsingFlags::NO_OPTS); 348 void ValidateDeclaratorId(); 349 void CheckRestrictedBinding(); 350 void CheckRestrictedBinding(lexer::TokenType keywordType); 351 void CheckRestrictedBinding(const util::StringView &ident, const lexer::SourcePosition &pos); 352 353 ir::VariableDeclarator *ParseVariableDeclarator(VariableParsingFlags flags); 354 ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous = false, 355 ParserStatus newStatus = ParserStatus::NO_OPTS); 356 ir::Statement *ParseStructDeclaration(ir::ClassDefinitionModifiers modifiers, 357 ir::ModifierFlags flags = ir::ModifierFlags::NONE); 358 ir::Statement *ParseClassDeclaration(ir::ClassDefinitionModifiers modifiers, 359 ir::ModifierFlags flags = ir::ModifierFlags::NONE); 360 FunctionSignature ParseFunctionSignature(ParserStatus status); 361 362 [[nodiscard]] virtual std::unique_ptr<lexer::Lexer> InitLexer(const SourceFile &sourceFile); 363 // NOLINTNEXTLINE(google-default-arguments) 364 ir::Statement *ParseStatementLiteralIdentHelper(StatementParsingFlags flags = StatementParsingFlags::NONE); 365 // NOLINTNEXTLINE(google-default-arguments) 366 ir::Statement *ParseStatementControlFlowTokenHelper(StatementParsingFlags flags = StatementParsingFlags::NONE); 367 // NOLINTNEXTLINE(google-default-arguments) 368 ir::Statement *ParseStatementPunctuatorsHelper(StatementParsingFlags flags = StatementParsingFlags::NONE); 369 // NOLINTNEXTLINE(google-default-arguments) 370 virtual ir::Statement *ParseStatement(StatementParsingFlags flags = StatementParsingFlags::NONE); 371 // NOLINTNEXTLINE(google-default-arguments) 372 virtual ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 373 // NOLINTNEXTLINE(google-default-arguments) 374 virtual ir::Expression *ParseExpressionOrTypeAnnotation(lexer::TokenType type, ExpressionParseFlags flags); 375 // NOLINTNEXTLINE(google-default-arguments) 376 virtual ir::Expression *ParsePatternElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS, 377 bool allowDefault = true); 378 void ParsePatternElementErrorCheck(ExpressionParseFlags flags, bool allowDefault); 379 virtual bool ParsePotentialNonNullExpression(ir::Expression **returnExpression, lexer::SourcePosition startLoc); 380 virtual ir::AstNode *ParseImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers); 381 virtual ir::Statement *ParseImportDeclaration(StatementParsingFlags flags); 382 // NOLINTNEXTLINE(google-default-arguments) 383 virtual ir::Expression *ParsePropertyDefinition( 384 [[maybe_unused]] ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 385 // NOLINTNEXTLINE(google-default-arguments) 386 virtual ir::ObjectExpression *ParseObjectExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 387 bool ParseArrayExpressionRightBracketHelper(bool containsRest, const lexer::SourcePosition &startLoc); 388 // NOLINTNEXTLINE(google-default-arguments) 389 virtual ir::ArrayExpression *ParseArrayExpression(ExpressionParseFlags flags, bool allowOmitted); 390 virtual ir::ArrayExpression *ParseArrayExpression(ExpressionParseFlags flags); 391 void ParseArrayExpressionErrorCheck(ir::ArrayExpression *arrayExpressionNode, ExpressionParseFlags flags, 392 bool inPattern); 393 virtual ir::ArrowFunctionExpression *ParsePotentialArrowExpression(ir::Expression **returnExpression, 394 const lexer::SourcePosition &startLoc); 395 virtual bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression, 396 const lexer::SourcePosition &startLoc, bool ignoreCallExpression); 397 virtual ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpression); 398 virtual bool IsNamedFunctionExpression(); 399 virtual ir::Identifier *ParsePrimaryExpressionIdent(ExpressionParseFlags flags); 400 virtual bool ValidateArrowFunctionRestParameter(ir::SpreadElement *restElement); 401 virtual ir::Statement *ParsePotentialExpressionStatement(StatementParsingFlags flags); 402 virtual ArenaVector<ir::Expression *> ParseFunctionParams(); 403 virtual ir::Expression *CreateParameterThis(ir::TypeNode *typeAnnotation); 404 virtual ir::Expression *ParseFunctionParameter(); ConvertThisKeywordToIdentIfNecessary()405 virtual void ConvertThisKeywordToIdentIfNecessary() {} 406 virtual void ParseCatchParamTypeAnnotation(ir::AnnotatedExpression *param); 407 // NOLINTNEXTLINE(google-default-arguments) 408 virtual ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers, 409 ir::ModifierFlags flags = ir::ModifierFlags::NONE); 410 virtual ir::Identifier *ParseClassIdent(ir::ClassDefinitionModifiers modifiers); 411 virtual ir::Statement *ParsePotentialConstEnum(VariableParsingFlags flags); 412 virtual ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties, 413 ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags); 414 virtual bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor, 415 ArenaVector<ir::AstNode *> &properties); 416 virtual void ValidateClassMethodStart(ClassElementDescriptor *desc, ir::TypeNode *typeAnnotation); 417 virtual ir::MethodDefinition *ParseClassMethod(ClassElementDescriptor *desc, 418 const ArenaVector<ir::AstNode *> &properties, 419 ir::Expression *propName, lexer::SourcePosition *propEnd); 420 void ValidateGetterSetter(ir::MethodDefinitionKind methodDefinition, size_t number); 421 virtual void ValidateClassSetter(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties, 422 ir::Expression *propName, ir::ScriptFunction *func); 423 virtual void ValidateClassGetter(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties, 424 ir::Expression *propName, ir::ScriptFunction *func); 425 virtual ir::ModifierFlags ParseModifiers(); 426 virtual ir::Statement *ParseConstStatement(StatementParsingFlags flags); 427 428 virtual ir::AnnotatedExpression *ParseVariableDeclaratorKey(VariableParsingFlags flags); 429 virtual ir::Statement *ParseAnnotationsInStatement(StatementParsingFlags flags); 430 virtual ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc, 431 VariableParsingFlags flags); 432 virtual ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags, 433 const lexer::SourcePosition &startLoc); 434 virtual bool IsModifierKind(const lexer::Token &token); 435 virtual void ConsumeClassPrivateIdentifier(ClassElementDescriptor *desc, char32_t *nextCp); 436 virtual void ReportPossibleOutOfBoundaryJumpError(bool allowBreak); 437 virtual void ReportIllegalBreakError(const lexer::SourcePosition &startLoc); 438 virtual void ReportIllegalContinueError(); 439 virtual void ReportIfBodyEmptyError(ir::Statement *consequent); 440 virtual void ReportMultipleDefaultError(); 441 virtual void ReportIllegalNewLineErrorAfterThrow(); 442 virtual void ReportIfVarDeclaration(VariableParsingFlags flags); 443 virtual ir::Expression *ParsePrefixAssertionExpression(); 444 // NOLINTNEXTLINE(google-default-arguments) 445 virtual ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList( 446 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 447 virtual void CheckIfStaticConstructor(ir::ModifierFlags flags); 448 virtual std::tuple<bool, bool, bool> ParseComputedClassFieldOrIndexSignature(ir::Expression **propName); 449 // NOLINTNEXTLINE(google-default-arguments) 450 virtual ir::Expression *ParseUnaryOrPrefixUpdateExpression( 451 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 452 virtual ir::Expression *ParsePrimaryExpressionWithLiterals(ExpressionParseFlags flags); 453 ir::Expression *ParseHashMaskOperator(); 454 ir::Expression *ParseClassExpression(); 455 ir::Expression *ParsePunctuators(ExpressionParseFlags flags); 456 // NOLINTNEXTLINE(google-default-arguments) 457 virtual ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 458 virtual ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc, 459 bool ignoreCallExpression, bool *isChainExpression); 460 ir::Expression *ParsePostPrimaryExpressionBackTick(ir::Expression *returnExpression, 461 lexer::SourcePosition startLoc); 462 ir::Expression *ParsePostPrimaryExpressionDot(ir::Expression *returnExpression, lexer::TokenType tokenType, 463 bool *isChainExpression); 464 virtual ir::ClassElement *ParseClassStaticBlock(); 465 virtual ParserStatus ValidateArrowParameter(ir::Expression *expr, bool *seenOptional); 466 void ValidateArrowParameterAssignment(ir::AssignmentExpression *expr); 467 virtual ArrowFunctionDescriptor ConvertToArrowParameter(ir::Expression *expr, bool isAsync); 468 virtual ir::Expression *ParseNewExpression(); 469 ParseFunctionTypeParameters()470 virtual ir::TSTypeParameterDeclaration *ParseFunctionTypeParameters() 471 { 472 return nullptr; 473 } 474 ParseFunctionReturnType(ParserStatus status)475 virtual ir::TypeNode *ParseFunctionReturnType([[maybe_unused]] ParserStatus status) 476 { 477 return nullptr; 478 } 479 ParseFunctionThrowMarker(const bool isRethrowsAllowed)480 virtual ir::ScriptFunctionFlags ParseFunctionThrowMarker([[maybe_unused]] const bool isRethrowsAllowed) 481 { 482 return ir::ScriptFunctionFlags::NONE; 483 } 484 485 using NodeFormatType = std::tuple<bool, char, std::size_t>; 486 virtual ir::Identifier *ParseIdentifierFormatPlaceholder(std::optional<NodeFormatType> nodeFormat); 487 virtual ir::Statement *ParseStatementFormatPlaceholder(); 488 virtual ir::AstNode *ParseTypeParametersFormatPlaceholder(); 489 virtual ArenaVector<ir::AstNode *> &ParseAstNodesArrayFormatPlaceholder(); 490 virtual ArenaVector<ir::Statement *> &ParseStatementsArrayFormatPlaceholder(); 491 virtual ArenaVector<ir::Expression *> &ParseExpressionsArrayFormatPlaceholder(); 492 493 virtual std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParseFunctionBody( 494 const ArenaVector<ir::Expression *> ¶ms, ParserStatus newStatus, ParserStatus contextStatus); 495 virtual ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers); 496 virtual ir::Statement *ParseExportDeclaration(StatementParsingFlags flags); 497 498 // NOLINTNEXTLINE(google-default-arguments) 499 virtual ir::ExportDefaultDeclaration *ParseExportDefaultDeclaration(const lexer::SourcePosition &startLoc, 500 bool isExportEquals = false); 501 virtual ir::Statement *ParseNamedExportDeclaration(const lexer::SourcePosition &startLoc); ValidateForInStatement()502 virtual bool ValidateForInStatement() 503 { 504 return true; 505 } 506 507 virtual ir::Statement *ParseTryStatement(); 508 virtual ir::Statement *ParseThrowStatement(); 509 virtual ir::Statement *ParseDebuggerStatement(); 510 // NOLINTNEXTLINE(google-default-arguments) 511 virtual ir::Statement *ParseModuleDeclaration(StatementParsingFlags flags = StatementParsingFlags::NONE) 512 { 513 return ParsePotentialExpressionStatement(flags); 514 } 515 ParseInterfaceDeclaration(bool isStatic)516 virtual ir::Statement *ParseInterfaceDeclaration([[maybe_unused]] bool isStatic) 517 { 518 LogUnexpectedToken(lexer::TokenType::KEYW_INTERFACE); 519 return nullptr; 520 } 521 522 // NOLINTNEXTLINE(google-default-arguments) 523 virtual ir::Statement *ParseEnumDeclaration([[maybe_unused]] bool isConst = false, 524 [[maybe_unused]] bool isStatic = false) 525 { 526 LogUnexpectedToken(lexer::TokenType::KEYW_ENUM); 527 return nullptr; 528 } 529 530 virtual std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseSuperClass(); 531 virtual ir::Expression *ParseSuperClassReference(); 532 533 using ClassBody = std::tuple<ir::MethodDefinition *, ArenaVector<ir::AstNode *>, lexer::SourceRange>; 534 ClassBody ParseClassBody(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags = ir::ModifierFlags::NONE); 535 GetProgram()536 Program *GetProgram() const 537 { 538 return program_; 539 } 540 SetProgram(Program * program)541 void SetProgram(Program *program) 542 { 543 program_ = program; 544 } 545 Lexer()546 lexer::Lexer *Lexer() const 547 { 548 return lexer_; 549 } 550 SetLexer(lexer::Lexer * lexer)551 void SetLexer(lexer::Lexer *lexer) 552 { 553 lexer_ = lexer; 554 } 555 GetContext()556 ParserContext &GetContext() 557 { 558 return context_; 559 } 560 GetContext()561 const ParserContext &GetContext() const 562 { 563 return context_; 564 } 565 GetOptions()566 const auto &GetOptions() const 567 { 568 return *options_; 569 } 570 ClassId()571 uint32_t &ClassId() 572 { 573 return classId_; 574 } 575 576 bool ParseList(std::optional<lexer::TokenType> termToken, lexer::NextTokenFlags flags, 577 const std::function<bool()> &parseElement, lexer::SourcePosition *sourceEnd = nullptr, 578 bool allowTrailingSep = false); 579 RecursiveCtx()580 RecursiveContext &RecursiveCtx() 581 { 582 return recursiveCtx_; 583 } 584 585 private: 586 bool GetCanBeForInOf(ir::Expression *leftNode, ir::AstNode *initNode); 587 Program *program_; 588 ParserContext context_; 589 ClassPrivateContext classPrivateContext_; 590 uint32_t classId_ {}; 591 lexer::Lexer *lexer_ {}; 592 const util::Options *options_; 593 util::DiagnosticEngine &diagnosticEngine_; 594 public_lib::Context *ctx_ {nullptr}; 595 RecursiveContext recursiveCtx_; 596 }; 597 } // namespace ark::es2panda::parser 598 599 template <> 600 struct enumbitops::IsAllowedType<ark::es2panda::parser::TypeAnnotationParsingOptions> : std::true_type { 601 }; 602 603 #endif 604