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 ECMASCRIPT_TS_TYPES_TS_TYPE_H 17 #define ECMASCRIPT_TS_TYPES_TS_TYPE_H 18 19 #include "ecmascript/ecma_macros.h" 20 #include "ecmascript/ts_types/ts_manager.h" 21 #include "ecmascript/ts_types/ts_obj_layout_info.h" 22 23 namespace panda::ecmascript { 24 enum class TSObjectTypeKind: uint8_t { 25 INSTANCE = 0, 26 PROTOTYPE, 27 }; 28 29 #define ACCESSORS_ATTACHED_TYPEREF(name, offset, endOffset) \ 30 ACCESSORS_PRIMITIVE_FIELD(name##RawData, uint32_t, offset, endOffset) \ 31 inline void Set##name(GlobalTSTypeRef type) \ 32 { \ 33 Set##name##RawData(type.GetType()); \ 34 } \ 35 inline GlobalTSTypeRef Get##name() const \ 36 { \ 37 return GlobalTSTypeRef(Get##name##RawData()); \ 38 } 39 40 class TSType : public TaggedObject { 41 public: 42 static constexpr size_t GT_OFFSET = TaggedObjectSize(); 43 Cast(const TaggedObject * object)44 inline static TSType *Cast(const TaggedObject *object) 45 { 46 return static_cast<TSType *>(const_cast<TaggedObject *>(object)); 47 } 48 49 ACCESSORS_ATTACHED_TYPEREF(GT, GT_OFFSET, LAST_OFFSET); 50 DEFINE_ALIGN_SIZE(LAST_OFFSET); 51 }; 52 53 class TSObjectType : public TSType { 54 public: 55 CAST_CHECK(TSObjectType, IsTSObjectType); 56 57 static constexpr size_t PROPERTIES_OFFSET = TSType::SIZE; 58 59 static JSHClass *GetOrCreateHClass(JSThread *thread, JSHandle<TSObjectType> objectType, TSObjectTypeKind kind); 60 61 static GlobalTSTypeRef GetPropTypeGT(JSHandle<TSObjectType> objectType, JSHandle<EcmaString> propName); 62 63 ACCESSORS(ObjLayoutInfo, PROPERTIES_OFFSET, HCLASS_OFFSET); 64 ACCESSORS(HClass, HCLASS_OFFSET, SIZE); 65 66 DECL_VISIT_OBJECT(PROPERTIES_OFFSET, SIZE) 67 DECL_DUMP() 68 69 private: 70 JSHClass *CreateHClassByProps(JSThread *thread, JSHandle<TSObjLayoutInfo> propType) const; 71 72 JSHClass *CreatePrototypeHClassByProps(JSThread *thread, JSHandle<TSObjLayoutInfo> propType) const; 73 }; 74 75 class TSClassType : public TSType { 76 public: 77 CAST_CHECK(TSClassType, IsTSClassType); 78 79 static constexpr size_t FIELD_LENGTH = 4; // every field record name, typeIndex, accessFlag, readonly 80 static constexpr size_t INSTANCE_TYPE_OFFSET = TSType::SIZE; 81 82 static GlobalTSTypeRef GetPropTypeGT(JSThread *thread, JSHandle<TSClassType> classType, 83 JSHandle<EcmaString> propName); 84 85 static GlobalTSTypeRef GetSuperPropTypeGT(JSThread *thread, JSHandle<TSClassType> classType, 86 JSHandle<EcmaString> propName, PropertyType propType); 87 88 static GlobalTSTypeRef GetNonStaticPropTypeGT(JSThread *thread, JSHandle<TSClassType> classType, 89 JSHandle<EcmaString> propName); 90 91 ACCESSORS(InstanceType, INSTANCE_TYPE_OFFSET, CONSTRUCTOR_TYPE_OFFSET); 92 ACCESSORS(ConstructorType, CONSTRUCTOR_TYPE_OFFSET, PROTOTYPE_TYPE_OFFSET); 93 ACCESSORS(PrototypeType, PROTOTYPE_TYPE_OFFSET, NAME_OFFSET); 94 ACCESSORS(Name, NAME_OFFSET, EXTENSION_GT_OFFSET); 95 ACCESSORS_ATTACHED_TYPEREF(ExtensionGT, EXTENSION_GT_OFFSET, BIT_FIELD_OFFSET); 96 ACCESSORS_BIT_FIELD(BitField, BIT_FIELD_OFFSET, LAST_OFFSET); 97 DEFINE_ALIGN_SIZE(LAST_OFFSET); 98 99 // define BitField 100 static constexpr size_t HAS_LINKED_BITS = 1; 101 FIRST_BIT_FIELD(BitField, HasLinked, bool, HAS_LINKED_BITS); 102 DECL_VISIT_OBJECT(INSTANCE_TYPE_OFFSET,EXTENSION_GT_OFFSET)103 DECL_VISIT_OBJECT(INSTANCE_TYPE_OFFSET, EXTENSION_GT_OFFSET) 104 DECL_DUMP() 105 106 // Judgment base classType by extends typeId, ts2abc write 0 in base class type extends domain 107 inline static bool IsBaseClassType(int extendsTypeId) 108 { 109 const int baseClassTypeExtendsTypeId = 0; 110 return extendsTypeId == baseClassTypeExtendsTypeId; 111 } 112 }; 113 114 class TSClassInstanceType : public TSType { 115 public: 116 CAST_CHECK(TSClassInstanceType, IsTSClassInstanceType); 117 118 static GlobalTSTypeRef GetPropTypeGT(JSThread *thread, JSHandle<TSClassInstanceType> classInstanceType, 119 JSHandle<EcmaString> propName); 120 121 static constexpr size_t CLASS_GT_OFFSET = TSType::SIZE; 122 static constexpr size_t CREATE_CLASS_OFFSET = 1; 123 ACCESSORS_ATTACHED_TYPEREF(ClassGT, CLASS_GT_OFFSET, LAST_OFFSET); 124 DEFINE_ALIGN_SIZE(LAST_OFFSET); 125 126 DECL_DUMP() 127 }; 128 129 class TSUnionType : public TSType { 130 public: 131 CAST_CHECK(TSUnionType, IsTSUnionType); 132 133 bool IsEqual(JSHandle<TSUnionType> unionB); 134 135 static constexpr size_t COMPONENTS_OFFSET = TSType::SIZE; 136 ACCESSORS(Components, COMPONENTS_OFFSET, SIZE); // the gt collection of union type components 137 138 DECL_VISIT_OBJECT(COMPONENTS_OFFSET, SIZE) 139 DECL_DUMP() 140 }; 141 142 class TSInterfaceType : public TSType { 143 public: 144 CAST_CHECK(TSInterfaceType, IsTSInterfaceType); 145 146 // every field record name, typeIndex, accessFlag, readonly 147 static constexpr size_t FIELD_LENGTH = 4; 148 149 static GlobalTSTypeRef GetPropTypeGT(JSThread *thread, JSHandle<TSInterfaceType> classInstanceType, 150 JSHandle<EcmaString> propName); 151 152 static constexpr size_t EXTENDS_TYPE_ID_OFFSET = TSType::SIZE; 153 ACCESSORS(Extends, EXTENDS_TYPE_ID_OFFSET, KEYS_OFFSET); 154 ACCESSORS(Fields, KEYS_OFFSET, SIZE); 155 156 DECL_VISIT_OBJECT(EXTENDS_TYPE_ID_OFFSET, SIZE) 157 DECL_DUMP() 158 }; 159 160 class TSFunctionType : public TSType { 161 public: 162 CAST_CHECK(TSFunctionType, IsTSFunctionType); 163 GetLength()164 uint32_t GetLength() const 165 { 166 TaggedArray* parameterTypes = TaggedArray::Cast(GetParameterTypes().GetTaggedObject()); 167 return parameterTypes->GetLength(); 168 } 169 170 GlobalTSTypeRef GetParameterTypeGT(int index) const; 171 172 static constexpr size_t NAME_OFFSET = TSType::SIZE; 173 ACCESSORS(Name, NAME_OFFSET, PARAMETER_TYPES_OFFSET); 174 ACCESSORS(ParameterTypes, PARAMETER_TYPES_OFFSET, RETURN_GT_OFFSET); 175 ACCESSORS_ATTACHED_TYPEREF(ReturnGT, RETURN_GT_OFFSET, THIS_GT_OFFSET); 176 ACCESSORS_ATTACHED_TYPEREF(ThisGT, THIS_GT_OFFSET, BIT_FIELD_OFFSET); 177 ACCESSORS_BIT_FIELD(BitField, BIT_FIELD_OFFSET, METHOD_OFFSET_OFFSET) 178 ACCESSORS_PRIMITIVE_FIELD(MethodOffset, uint32_t, METHOD_OFFSET_OFFSET, LAST_OFFSET) 179 DEFINE_ALIGN_SIZE(LAST_OFFSET); 180 181 enum class Visibility : uint8_t { PUBLIC = 0, PRIVATE, PROTECTED }; 182 183 // define BitField 184 static constexpr size_t ONE_BIT = 1; 185 static constexpr size_t TWO_BITS = 2; 186 FIRST_BIT_FIELD(BitField, Visibility, Visibility, TWO_BITS); 187 NEXT_BIT_FIELD(BitField, Static, bool, ONE_BIT, Visibility); 188 NEXT_BIT_FIELD(BitField, Async, bool, ONE_BIT, Static); 189 NEXT_BIT_FIELD(BitField, Generator, bool, ONE_BIT, Async); 190 NEXT_BIT_FIELD(BitField, IsGetterSetter, bool, ONE_BIT, Generator); 191 NEXT_BIT_FIELD(BitField, IsAbstract, bool, ONE_BIT, IsGetterSetter); 192 NEXT_BIT_FIELD(BitField, IsSignature, bool, ONE_BIT, IsAbstract); 193 194 DECL_VISIT_OBJECT(NAME_OFFSET, RETURN_GT_OFFSET) 195 DECL_DUMP() 196 }; 197 198 class TSArrayType : public TSType { 199 public: 200 CAST_CHECK(TSArrayType, IsTSArrayType); 201 static constexpr size_t ELEMENT_GT_OFFSET = TSType::SIZE; 202 203 ACCESSORS_ATTACHED_TYPEREF(ElementGT, ELEMENT_GT_OFFSET, LAST_OFFSET); 204 DEFINE_ALIGN_SIZE(LAST_OFFSET); 205 206 DECL_DUMP() 207 }; 208 209 class TSIteratorInstanceType : public TSType { 210 public: 211 CAST_CHECK(TSIteratorInstanceType, IsTSIteratorInstanceType); 212 static constexpr size_t KIND_GT_OFFSET = TSType::SIZE; 213 214 static GlobalTSTypeRef GetPropTypeGT(JSThread *thread, JSHandle<TSIteratorInstanceType> instanceType, 215 JSHandle<EcmaString> propName); 216 217 ACCESSORS_ATTACHED_TYPEREF(KindGT, KIND_GT_OFFSET, ELEMENT_GT_OFFSET); 218 ACCESSORS_ATTACHED_TYPEREF(ElementGT, ELEMENT_GT_OFFSET, LAST_OFFSET); 219 DEFINE_ALIGN_SIZE(LAST_OFFSET); 220 221 DECL_DUMP() 222 }; 223 } // namespace panda::ecmascript 224 225 #endif // ECMASCRIPT_TS_TYPES_TS_TYPE_H 226