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