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_TYPED_PARSER_H 17 #define ES2PANDA_PARSER_CORE_TYPED_PARSER_H 18 19 #include "parserImpl.h" 20 21 namespace ark::es2panda::ir { 22 class TSClassImplements; 23 } // namespace ark::es2panda::ir 24 25 namespace ark::es2panda::parser { 26 class TypedParser : public ParserImpl { 27 public: 28 TypedParser(Program *program, const CompilerOptions &options, ParserStatus status = ParserStatus::NO_OPTS) ParserImpl(program,options,status)29 : ParserImpl(program, options, status) 30 { 31 } 32 33 protected: 34 void ParseDecorators(ArenaVector<ir::Decorator *> &decorators); 35 void CheckDeclare(); 36 ir::TSModuleDeclaration *ParseAmbientExternalModuleDeclaration(const lexer::SourcePosition &startLoc); 37 ir::TSModuleBlock *ParseTsModuleBlock(); 38 ir::TSModuleDeclaration *ParseModuleOrNamespaceDeclaration(const lexer::SourcePosition &startLoc); 39 ArenaVector<ir::AstNode *> ParseTypeLiteralOrInterface(); 40 ArenaVector<ir::AstNode *> ParseTypeLiteralOrInterfaceBody(); 41 void CheckObjectTypeForDuplicatedProperties(ir::Expression *key, ArenaVector<ir::AstNode *> &members); 42 43 ir::ArrowFunctionExpression *ParseGenericArrowFunction(); 44 ir::TSTypeAssertion *ParseTypeAssertion(); 45 46 ir::TSTypeParameterInstantiation *ParseTypeParameterInstantiation(TypeAnnotationParsingOptions *options); 47 ir::AstNode *ParseTypeParameterInstantiationImpl(TypeAnnotationParsingOptions *options); 48 49 ir::TSTypeParameterDeclaration *ParseTypeParameterDeclaration(TypeAnnotationParsingOptions *options); 50 ir::AstNode *ParseTypeParameterDeclarationImpl(TypeAnnotationParsingOptions *options); 51 52 ir::Expression *ParseQualifiedName(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 53 ir::Expression *ParseQualifiedReference(ir::Expression *typeName, 54 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 55 void ParsePotentialOptionalFunctionParameter(ir::AnnotatedExpression *returnNode); 56 // NOLINTNEXTLINE(google-default-arguments) 57 ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 58 ir::Statement *ParseInterfaceDeclaration(bool isStatic) override; 59 // NOLINTNEXTLINE(google-default-arguments) 60 ir::Statement *ParseEnumDeclaration(bool isConst = false, bool isStatic = false) override; 61 ir::Statement *ParsePotentialExpressionStatement(StatementParsingFlags flags) override; 62 void ConvertThisKeywordToIdentIfNecessary() override; 63 ir::TypeNode *ParseFunctionReturnType(ParserStatus status) override; 64 ir::TSTypeParameterDeclaration *ParseFunctionTypeParameters() override; 65 // NOLINTNEXTLINE(google-default-arguments) 66 ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers, 67 ir::ModifierFlags flags = ir::ModifierFlags::NONE) override; 68 ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers, 69 ir::ModifierFlags flags) override; 70 71 static bool CheckClassElementInterfaceBody(ir::AstNode *property, ArenaVector<ir::AstNode *> &properties); 72 bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor, 73 ArenaVector<ir::AstNode *> &properties) override; 74 75 ir::ModifierFlags ParseModifiers() override; 76 ParserStatus ValidateArrowParameter(ir::Expression *expr, bool *seenOptional) override; 77 ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpression) override; 78 79 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseSuperClass() override; 80 ir::Expression *ParseSuperClassReference() override; 81 virtual ArenaVector<ir::TSClassImplements *> ParseClassImplementClause(); 82 83 // NOLINTNEXTLINE(google-default-arguments) 84 ir::Statement *ParseModuleDeclaration(StatementParsingFlags flags = StatementParsingFlags::NONE) override; CheckIfTypeParameterNameIsReserved()85 virtual void CheckIfTypeParameterNameIsReserved() {}; 86 virtual ArenaVector<ir::TSInterfaceHeritage *> ParseInterfaceExtendsClause(); 87 virtual ir::Statement *ParseDeclareAndDecorators(StatementParsingFlags flags); 88 virtual void ParseOptionalClassElement(ClassElementDescriptor *desc); 89 virtual ir::TSTypeParameter *ParseTypeParameter(TypeAnnotationParsingOptions *options); 90 virtual ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, 91 bool isConst, bool isStatic); 92 virtual std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseClassImplementsElement(); 93 virtual ir::TypeNode *ParseInterfaceExtendsElement(); 94 95 virtual void ValidateIndexSignatureTypeAnnotation(ir::TypeNode *typeAnnotation); ParseDecorator()96 virtual ir::Decorator *ParseDecorator() 97 { 98 return nullptr; 99 } CurrentIsBasicType()100 virtual bool CurrentIsBasicType() 101 { 102 return false; 103 } ParseTypeAliasDeclaration()104 virtual ir::TSTypeAliasDeclaration *ParseTypeAliasDeclaration() 105 { 106 return nullptr; 107 } ParseTypeLiteralOrInterfaceMember()108 virtual ir::AstNode *ParseTypeLiteralOrInterfaceMember() 109 { 110 return nullptr; 111 } 112 // NOLINTNEXTLINE(google-default-arguments) 113 virtual ir::TSIndexSignature *ParseIndexSignature([[maybe_unused]] const lexer::SourcePosition &startLoc, 114 [[maybe_unused]] bool isReadonly = false) 115 { 116 return nullptr; 117 } ParsePropertyOrMethodSignature(const lexer::SourcePosition & startLoc,bool isReadonly)118 virtual ir::AstNode *ParsePropertyOrMethodSignature([[maybe_unused]] const lexer::SourcePosition &startLoc, 119 [[maybe_unused]] bool isReadonly) 120 { 121 return nullptr; 122 } ParseInterfacePropertyKey()123 virtual std::tuple<ir::Expression *, bool> ParseInterfacePropertyKey() 124 { 125 return {nullptr, false}; 126 } ParseClassKeyAnnotation()127 virtual ir::TypeNode *ParseClassKeyAnnotation() 128 { 129 return nullptr; 130 } ParseTypeAnnotation(TypeAnnotationParsingOptions * options)131 virtual ir::TypeNode *ParseTypeAnnotation([[maybe_unused]] TypeAnnotationParsingOptions *options) 132 { 133 return nullptr; 134 } AddDecorators(ir::AstNode * node,ArenaVector<ir::Decorator * > & decorators)135 virtual void AddDecorators([[maybe_unused]] ir::AstNode *node, 136 [[maybe_unused]] ArenaVector<ir::Decorator *> &decorators) 137 { 138 } 139 140 ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc, 141 VariableParsingFlags flags) override; 142 143 using InterfaceId = std::tuple<ir::Identifier *, varbinder::InterfaceDecl *, bool>; 144 InterfaceId ParseInterfaceDeclarationId(); 145 AllowInterfaceRedeclaration()146 virtual bool AllowInterfaceRedeclaration() 147 { 148 return false; 149 } 150 151 private: 152 ParserStatus ValidateArrowParameterAssignment(ir::AssignmentExpression *assignmentExpr); 153 ParserStatus ValidateArrowParameterArray(ir::ArrayExpression *arrayPattern); 154 ParserStatus ValidateArrowParameterObject(ir::ObjectExpression *objectPattern); 155 156 ir::Expression *ParseLiteralIndent(ir::Expression *typeName, ExpressionParseFlags flags, 157 const lexer::SourcePosition &startLoc); 158 159 ir::AstNode *ParseProperty(const ArenaVector<ir::AstNode *> &properties, ClassElementDescriptor &desc, 160 ir::Expression *propName); 161 }; 162 } // namespace ark::es2panda::parser 163 164 #endif 165