1 /** 2 * Copyright (c) 2021 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 panda::es2panda::ir { 22 class TSClassImplements; 23 } // namespace panda::es2panda::ir 24 25 namespace panda::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 void CheckObjectTypeForDuplicatedProperties(ir::Expression *key, ArenaVector<ir::AstNode *> &members); 41 42 ir::ArrowFunctionExpression *ParseGenericArrowFunction(); 43 ir::TSTypeAssertion *ParseTypeAssertion(); 44 ir::TSTypeParameterInstantiation *ParseTypeParameterInstantiation(TypeAnnotationParsingOptions *options); 45 46 ir::TSTypeParameterDeclaration *ParseTypeParameterDeclaration(TypeAnnotationParsingOptions *options); 47 ir::Expression *ParseQualifiedName(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 48 ir::Expression *ParseQualifiedReference(ir::Expression *typeName, 49 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS); 50 void ParsePotentialOptionalFunctionParameter(ir::AnnotatedExpression *returnNode); 51 // NOLINTNEXTLINE(google-default-arguments) 52 ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS) override; 53 ir::Statement *ParseInterfaceDeclaration(bool isStatic) override; 54 // NOLINTNEXTLINE(google-default-arguments) 55 ir::Statement *ParseEnumDeclaration(bool isConst = false, bool isStatic = false) override; 56 ir::Statement *ParsePotentialExpressionStatement(StatementParsingFlags flags) override; 57 void ConvertThisKeywordToIdentIfNecessary() override; 58 ir::TypeNode *ParseFunctionReturnType(ParserStatus status) override; 59 ir::TSTypeParameterDeclaration *ParseFunctionTypeParameters() override; 60 // NOLINTNEXTLINE(google-default-arguments) 61 ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers, 62 ir::ModifierFlags flags = ir::ModifierFlags::NONE) override; 63 // NOLINTNEXTLINE(google-default-arguments) 64 ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties, ir::ClassDefinitionModifiers modifiers, 65 ir::ModifierFlags flags = ir::ModifierFlags::NONE, 66 ir::Identifier *identNode = nullptr) override; 67 68 static bool CheckClassElementInterfaceBody(ir::AstNode *property, ArenaVector<ir::AstNode *> &properties); 69 bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor, 70 ArenaVector<ir::AstNode *> &properties) override; 71 72 ir::ModifierFlags ParseModifiers() override; 73 ParserStatus ValidateArrowParameter(ir::Expression *expr, bool *seenOptional) override; 74 ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpr) override; 75 76 std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseSuperClass() override; 77 ir::Expression *ParseSuperClassReference() override; 78 virtual ArenaVector<ir::TSClassImplements *> ParseClassImplementClause(); 79 80 // NOLINTNEXTLINE(google-default-arguments) 81 ir::Statement *ParseModuleDeclaration(StatementParsingFlags flags = StatementParsingFlags::NONE) override; CheckIfTypeParameterNameIsReserved()82 virtual void CheckIfTypeParameterNameIsReserved() {}; 83 virtual ArenaVector<ir::TSInterfaceHeritage *> ParseInterfaceExtendsClause(); 84 virtual ir::Statement *ParseDeclareAndDecorators(StatementParsingFlags flags); 85 virtual void ParseOptionalClassElement(ClassElementDescriptor *desc); 86 virtual ir::TSTypeParameter *ParseTypeParameter(TypeAnnotationParsingOptions *options); 87 virtual ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, 88 bool isConst, bool isStatic); 89 virtual std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseClassImplementsElement(); 90 virtual ir::TypeNode *ParseInterfaceExtendsElement(); 91 ValidateIndexSignatureTypeAnnotation(ir::TypeNode * typeAnnotation)92 virtual void ValidateIndexSignatureTypeAnnotation([[maybe_unused]] ir::TypeNode *typeAnnotation) {} ParseDecorator()93 virtual ir::Decorator *ParseDecorator() 94 { 95 return nullptr; 96 } CurrentIsBasicType()97 virtual bool CurrentIsBasicType() 98 { 99 return false; 100 } ParseTypeAliasDeclaration()101 virtual ir::TSTypeAliasDeclaration *ParseTypeAliasDeclaration() 102 { 103 return nullptr; 104 } ParseTypeLiteralOrInterfaceMember()105 virtual ir::AstNode *ParseTypeLiteralOrInterfaceMember() 106 { 107 return nullptr; 108 } 109 // NOLINTNEXTLINE(google-default-arguments) 110 virtual ir::TSIndexSignature *ParseIndexSignature([[maybe_unused]] const lexer::SourcePosition &startLoc, 111 [[maybe_unused]] bool isReadonly = false) 112 { 113 return nullptr; 114 } ParsePropertyOrMethodSignature(const lexer::SourcePosition & startLoc,bool isReadonly)115 virtual ir::AstNode *ParsePropertyOrMethodSignature([[maybe_unused]] const lexer::SourcePosition &startLoc, 116 [[maybe_unused]] bool isReadonly) 117 { 118 return nullptr; 119 } ParseInterfacePropertyKey()120 virtual std::tuple<ir::Expression *, bool> ParseInterfacePropertyKey() 121 { 122 return {nullptr, false}; 123 } ParseClassKeyAnnotation()124 virtual ir::TypeNode *ParseClassKeyAnnotation() 125 { 126 return nullptr; 127 } ParseTypeAnnotation(TypeAnnotationParsingOptions * options)128 virtual ir::TypeNode *ParseTypeAnnotation([[maybe_unused]] TypeAnnotationParsingOptions *options) 129 { 130 return nullptr; 131 } AddDecorators(ir::AstNode * node,ArenaVector<ir::Decorator * > & decorators)132 virtual void AddDecorators([[maybe_unused]] ir::AstNode *node, 133 [[maybe_unused]] ArenaVector<ir::Decorator *> &decorators) 134 { 135 } 136 137 ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc, 138 VariableParsingFlags flags) override; 139 140 using InterfaceId = std::tuple<ir::Identifier *, varbinder::InterfaceDecl *, bool>; 141 InterfaceId ParseInterfaceDeclarationId(); 142 AllowInterfaceRedeclaration()143 virtual bool AllowInterfaceRedeclaration() 144 { 145 return false; 146 } 147 148 // NOLINTNEXTLINE(google-default-arguments) 149 virtual void CreateCCtor([[maybe_unused]] ArenaVector<ir::AstNode *> &properties, 150 [[maybe_unused]] const lexer::SourcePosition &loc, 151 [[maybe_unused]] bool inGlobalClass = false) 152 { 153 } 154 }; 155 } // namespace panda::es2panda::parser 156 157 #endif 158