Warning, /include/clang/AST/AbstractBasicReader.inc is written in an unsupported language. File is not indexed.
0001 /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
0002 |* *|
0003 |* Helper classes for BasicReaders *|
0004 |* *|
0005 |* Automatically generated file, do not edit! *|
0006 |* From: PropertiesBase.td *|
0007 |* *|
0008 \*===----------------------------------------------------------------------===*/
0009
0010 template <class ValueType>
0011 struct ReadDispatcher;
0012 template <>
0013 struct ReadDispatcher<llvm::APInt> {
0014 template <class BasicReader, class... Args>
0015 static llvm::APInt read(BasicReader &R, Args &&... args) {
0016 return R.readAPInt(std::forward<Args>(args)...);
0017 }
0018 };
0019 template <>
0020 struct ReadDispatcher<llvm::APSInt> {
0021 template <class BasicReader, class... Args>
0022 static llvm::APSInt read(BasicReader &R, Args &&... args) {
0023 return R.readAPSInt(std::forward<Args>(args)...);
0024 }
0025 };
0026 template <>
0027 struct ReadDispatcher<APValue> {
0028 template <class BasicReader, class... Args>
0029 static APValue read(BasicReader &R, Args &&... args) {
0030 return R.readAPValue(std::forward<Args>(args)...);
0031 }
0032 };
0033 template <>
0034 struct ReadDispatcher<APValue::ValueKind> {
0035 template <class BasicReader, class... Args>
0036 static APValue::ValueKind read(BasicReader &R, Args &&... args) {
0037 return R.readAPValueKind(std::forward<Args>(args)...);
0038 }
0039 };
0040 template <>
0041 struct ReadDispatcher<ArraySizeModifier> {
0042 template <class BasicReader, class... Args>
0043 static ArraySizeModifier read(BasicReader &R, Args &&... args) {
0044 return R.readArraySizeModifier(std::forward<Args>(args)...);
0045 }
0046 };
0047 template <>
0048 struct ReadDispatcher<const Attr *> {
0049 template <class BasicReader, class... Args>
0050 static const Attr * read(BasicReader &R, Args &&... args) {
0051 return R.readAttr(std::forward<Args>(args)...);
0052 }
0053 };
0054 template <>
0055 struct ReadDispatcher<attr::Kind> {
0056 template <class BasicReader, class... Args>
0057 static attr::Kind read(BasicReader &R, Args &&... args) {
0058 return R.readAttrKind(std::forward<Args>(args)...);
0059 }
0060 };
0061 template <>
0062 struct ReadDispatcher<AutoTypeKeyword> {
0063 template <class BasicReader, class... Args>
0064 static AutoTypeKeyword read(BasicReader &R, Args &&... args) {
0065 return R.readAutoTypeKeyword(std::forward<Args>(args)...);
0066 }
0067 };
0068 template <>
0069 struct ReadDispatcher<const BTFTypeTagAttr *> {
0070 template <class BasicReader, class... Args>
0071 static const BTFTypeTagAttr * read(BasicReader &R, Args &&... args) {
0072 return R.readBTFTypeTagAttr(std::forward<Args>(args)...);
0073 }
0074 };
0075 template <>
0076 struct ReadDispatcher<bool> {
0077 template <class BasicReader, class... Args>
0078 static bool read(BasicReader &R, Args &&... args) {
0079 return R.readBool(std::forward<Args>(args)...);
0080 }
0081 };
0082 template <>
0083 struct ReadDispatcher<BuiltinType::Kind> {
0084 template <class BasicReader, class... Args>
0085 static BuiltinType::Kind read(BasicReader &R, Args &&... args) {
0086 return R.readBuiltinTypeKind(std::forward<Args>(args)...);
0087 }
0088 };
0089 template <>
0090 struct ReadDispatcher<CXXRecordDecl*> {
0091 template <class BasicReader, class... Args>
0092 static CXXRecordDecl* read(BasicReader &R, Args &&... args) {
0093 return R.readCXXRecordDeclRef(std::forward<Args>(args)...);
0094 }
0095 };
0096 template <>
0097 struct ReadDispatcher<CallingConv> {
0098 template <class BasicReader, class... Args>
0099 static CallingConv read(BasicReader &R, Args &&... args) {
0100 return R.readCallingConv(std::forward<Args>(args)...);
0101 }
0102 };
0103 template <>
0104 struct ReadDispatcher<ConceptDecl*> {
0105 template <class BasicReader, class... Args>
0106 static ConceptDecl* read(BasicReader &R, Args &&... args) {
0107 return R.readConceptDeclRef(std::forward<Args>(args)...);
0108 }
0109 };
0110 template <>
0111 struct ReadDispatcher<Decl*> {
0112 template <class BasicReader, class... Args>
0113 static Decl* read(BasicReader &R, Args &&... args) {
0114 return R.readDeclRef(std::forward<Args>(args)...);
0115 }
0116 };
0117 template <>
0118 struct ReadDispatcher<DeclarationName> {
0119 template <class BasicReader, class... Args>
0120 static DeclarationName read(BasicReader &R, Args &&... args) {
0121 return R.readDeclarationName(std::forward<Args>(args)...);
0122 }
0123 };
0124 template <>
0125 struct ReadDispatcher<DeclarationName::NameKind> {
0126 template <class BasicReader, class... Args>
0127 static DeclarationName::NameKind read(BasicReader &R, Args &&... args) {
0128 return R.readDeclarationNameKind(std::forward<Args>(args)...);
0129 }
0130 };
0131 template <>
0132 struct ReadDispatcher<EffectConditionExpr> {
0133 template <class BasicReader, class... Args>
0134 static EffectConditionExpr read(BasicReader &R, Args &&... args) {
0135 return R.readEffectConditionExpr(std::forward<Args>(args)...);
0136 }
0137 };
0138 template <>
0139 struct ReadDispatcher<ElaboratedTypeKeyword> {
0140 template <class BasicReader, class... Args>
0141 static ElaboratedTypeKeyword read(BasicReader &R, Args &&... args) {
0142 return R.readElaboratedTypeKeyword(std::forward<Args>(args)...);
0143 }
0144 };
0145 template <>
0146 struct ReadDispatcher<FunctionProtoType::ExceptionSpecInfo> {
0147 template <class BasicReader, class... Args>
0148 static FunctionProtoType::ExceptionSpecInfo read(BasicReader &R, Args &&... args) {
0149 return R.readExceptionSpecInfo(std::forward<Args>(args)...);
0150 }
0151 };
0152 template <>
0153 struct ReadDispatcher<Expr*> {
0154 template <class BasicReader, class... Args>
0155 static Expr* read(BasicReader &R, Args &&... args) {
0156 return R.readExprRef(std::forward<Args>(args)...);
0157 }
0158 };
0159 template <>
0160 struct ReadDispatcher<FunctionProtoType::ExtParameterInfo> {
0161 template <class BasicReader, class... Args>
0162 static FunctionProtoType::ExtParameterInfo read(BasicReader &R, Args &&... args) {
0163 return R.readExtParameterInfo(std::forward<Args>(args)...);
0164 }
0165 };
0166 template <>
0167 struct ReadDispatcher<llvm::FixedPointSemantics> {
0168 template <class BasicReader, class... Args>
0169 static llvm::FixedPointSemantics read(BasicReader &R, Args &&... args) {
0170 return R.readFixedPointSemantics(std::forward<Args>(args)...);
0171 }
0172 };
0173 template <>
0174 struct ReadDispatcher<FunctionDecl*> {
0175 template <class BasicReader, class... Args>
0176 static FunctionDecl* read(BasicReader &R, Args &&... args) {
0177 return R.readFunctionDeclRef(std::forward<Args>(args)...);
0178 }
0179 };
0180 template <>
0181 struct ReadDispatcher<FunctionEffect> {
0182 template <class BasicReader, class... Args>
0183 static FunctionEffect read(BasicReader &R, Args &&... args) {
0184 return R.readFunctionEffect(std::forward<Args>(args)...);
0185 }
0186 };
0187 template <>
0188 struct ReadDispatcher<IdentifierInfo*> {
0189 template <class BasicReader, class... Args>
0190 static IdentifierInfo* read(BasicReader &R, Args &&... args) {
0191 return R.readIdentifier(std::forward<Args>(args)...);
0192 }
0193 };
0194 template <>
0195 struct ReadDispatcher<APValue::LValuePathEntry> {
0196 template <class BasicReader, class... Args>
0197 static APValue::LValuePathEntry read(BasicReader &R, Args &&... args) {
0198 return R.readLValuePathEntry(std::forward<Args>(args)...);
0199 }
0200 };
0201 template <>
0202 struct ReadDispatcher<APValue::LValuePathSerializationHelper> {
0203 template <class BasicReader, class... Args>
0204 static APValue::LValuePathSerializationHelper read(BasicReader &R, Args &&... args) {
0205 return R.readLValuePathSerializationHelper(std::forward<Args>(args)...);
0206 }
0207 };
0208 template <>
0209 struct ReadDispatcher<NamedDecl*> {
0210 template <class BasicReader, class... Args>
0211 static NamedDecl* read(BasicReader &R, Args &&... args) {
0212 return R.readNamedDeclRef(std::forward<Args>(args)...);
0213 }
0214 };
0215 template <>
0216 struct ReadDispatcher<NamespaceAliasDecl*> {
0217 template <class BasicReader, class... Args>
0218 static NamespaceAliasDecl* read(BasicReader &R, Args &&... args) {
0219 return R.readNamespaceAliasDeclRef(std::forward<Args>(args)...);
0220 }
0221 };
0222 template <>
0223 struct ReadDispatcher<NamespaceDecl*> {
0224 template <class BasicReader, class... Args>
0225 static NamespaceDecl* read(BasicReader &R, Args &&... args) {
0226 return R.readNamespaceDeclRef(std::forward<Args>(args)...);
0227 }
0228 };
0229 template <>
0230 struct ReadDispatcher<NestedNameSpecifier *> {
0231 template <class BasicReader, class... Args>
0232 static NestedNameSpecifier * read(BasicReader &R, Args &&... args) {
0233 return R.readNestedNameSpecifier(std::forward<Args>(args)...);
0234 }
0235 };
0236 template <>
0237 struct ReadDispatcher<NestedNameSpecifier::SpecifierKind> {
0238 template <class BasicReader, class... Args>
0239 static NestedNameSpecifier::SpecifierKind read(BasicReader &R, Args &&... args) {
0240 return R.readNestedNameSpecifierKind(std::forward<Args>(args)...);
0241 }
0242 };
0243 template <>
0244 struct ReadDispatcher<ObjCProtocolDecl*> {
0245 template <class BasicReader, class... Args>
0246 static ObjCProtocolDecl* read(BasicReader &R, Args &&... args) {
0247 return R.readObjCProtocolDeclRef(std::forward<Args>(args)...);
0248 }
0249 };
0250 template <>
0251 struct ReadDispatcher<ObjCTypeParamDecl*> {
0252 template <class BasicReader, class... Args>
0253 static ObjCTypeParamDecl* read(BasicReader &R, Args &&... args) {
0254 return R.readObjCTypeParamDeclRef(std::forward<Args>(args)...);
0255 }
0256 };
0257 template <>
0258 struct ReadDispatcher<OverloadedOperatorKind> {
0259 template <class BasicReader, class... Args>
0260 static OverloadedOperatorKind read(BasicReader &R, Args &&... args) {
0261 return R.readOverloadedOperatorKind(std::forward<Args>(args)...);
0262 }
0263 };
0264 template <>
0265 struct ReadDispatcher<QualType> {
0266 template <class BasicReader, class... Args>
0267 static QualType read(BasicReader &R, Args &&... args) {
0268 return R.readQualType(std::forward<Args>(args)...);
0269 }
0270 };
0271 template <>
0272 struct ReadDispatcher<Qualifiers> {
0273 template <class BasicReader, class... Args>
0274 static Qualifiers read(BasicReader &R, Args &&... args) {
0275 return R.readQualifiers(std::forward<Args>(args)...);
0276 }
0277 };
0278 template <>
0279 struct ReadDispatcher<RefQualifierKind> {
0280 template <class BasicReader, class... Args>
0281 static RefQualifierKind read(BasicReader &R, Args &&... args) {
0282 return R.readRefQualifierKind(std::forward<Args>(args)...);
0283 }
0284 };
0285 template <>
0286 struct ReadDispatcher<Selector> {
0287 template <class BasicReader, class... Args>
0288 static Selector read(BasicReader &R, Args &&... args) {
0289 return R.readSelector(std::forward<Args>(args)...);
0290 }
0291 };
0292 template <>
0293 struct ReadDispatcher<SourceLocation> {
0294 template <class BasicReader, class... Args>
0295 static SourceLocation read(BasicReader &R, Args &&... args) {
0296 return R.readSourceLocation(std::forward<Args>(args)...);
0297 }
0298 };
0299 template <>
0300 struct ReadDispatcher<Stmt*> {
0301 template <class BasicReader, class... Args>
0302 static Stmt* read(BasicReader &R, Args &&... args) {
0303 return R.readStmtRef(std::forward<Args>(args)...);
0304 }
0305 };
0306 template <>
0307 struct ReadDispatcher<SubstTemplateTypeParmTypeFlag> {
0308 template <class BasicReader, class... Args>
0309 static SubstTemplateTypeParmTypeFlag read(BasicReader &R, Args &&... args) {
0310 return R.readSubstTemplateTypeParmTypeFlag(std::forward<Args>(args)...);
0311 }
0312 };
0313 template <>
0314 struct ReadDispatcher<TagDecl*> {
0315 template <class BasicReader, class... Args>
0316 static TagDecl* read(BasicReader &R, Args &&... args) {
0317 return R.readTagDeclRef(std::forward<Args>(args)...);
0318 }
0319 };
0320 template <>
0321 struct ReadDispatcher<TemplateArgument> {
0322 template <class BasicReader, class... Args>
0323 static TemplateArgument read(BasicReader &R, Args &&... args) {
0324 return R.readTemplateArgument(std::forward<Args>(args)...);
0325 }
0326 };
0327 template <>
0328 struct ReadDispatcher<TemplateArgument::ArgKind> {
0329 template <class BasicReader, class... Args>
0330 static TemplateArgument::ArgKind read(BasicReader &R, Args &&... args) {
0331 return R.readTemplateArgumentKind(std::forward<Args>(args)...);
0332 }
0333 };
0334 template <>
0335 struct ReadDispatcher<TemplateDecl*> {
0336 template <class BasicReader, class... Args>
0337 static TemplateDecl* read(BasicReader &R, Args &&... args) {
0338 return R.readTemplateDeclRef(std::forward<Args>(args)...);
0339 }
0340 };
0341 template <>
0342 struct ReadDispatcher<TemplateName> {
0343 template <class BasicReader, class... Args>
0344 static TemplateName read(BasicReader &R, Args &&... args) {
0345 return R.readTemplateName(std::forward<Args>(args)...);
0346 }
0347 };
0348 template <>
0349 struct ReadDispatcher<TemplateName::NameKind> {
0350 template <class BasicReader, class... Args>
0351 static TemplateName::NameKind read(BasicReader &R, Args &&... args) {
0352 return R.readTemplateNameKind(std::forward<Args>(args)...);
0353 }
0354 };
0355 template <>
0356 struct ReadDispatcher<TemplateTemplateParmDecl*> {
0357 template <class BasicReader, class... Args>
0358 static TemplateTemplateParmDecl* read(BasicReader &R, Args &&... args) {
0359 return R.readTemplateTemplateParmDeclRef(std::forward<Args>(args)...);
0360 }
0361 };
0362 template <>
0363 struct ReadDispatcher<TemplateTypeParmDecl*> {
0364 template <class BasicReader, class... Args>
0365 static TemplateTypeParmDecl* read(BasicReader &R, Args &&... args) {
0366 return R.readTemplateTypeParmDeclRef(std::forward<Args>(args)...);
0367 }
0368 };
0369 template <>
0370 struct ReadDispatcher<TypeCoupledDeclRefInfo> {
0371 template <class BasicReader, class... Args>
0372 static TypeCoupledDeclRefInfo read(BasicReader &R, Args &&... args) {
0373 return R.readTypeCoupledDeclRefInfo(std::forward<Args>(args)...);
0374 }
0375 };
0376 template <>
0377 struct ReadDispatcher<TypeOfKind> {
0378 template <class BasicReader, class... Args>
0379 static TypeOfKind read(BasicReader &R, Args &&... args) {
0380 return R.readTypeOfKind(std::forward<Args>(args)...);
0381 }
0382 };
0383 template <>
0384 struct ReadDispatcher<uint32_t> {
0385 template <class BasicReader, class... Args>
0386 static uint32_t read(BasicReader &R, Args &&... args) {
0387 return R.readUInt32(std::forward<Args>(args)...);
0388 }
0389 };
0390 template <>
0391 struct ReadDispatcher<uint64_t> {
0392 template <class BasicReader, class... Args>
0393 static uint64_t read(BasicReader &R, Args &&... args) {
0394 return R.readUInt64(std::forward<Args>(args)...);
0395 }
0396 };
0397 template <>
0398 struct ReadDispatcher<UnaryTransformType::UTTKind> {
0399 template <class BasicReader, class... Args>
0400 static UnaryTransformType::UTTKind read(BasicReader &R, Args &&... args) {
0401 return R.readUnaryTypeTransformKind(std::forward<Args>(args)...);
0402 }
0403 };
0404 template <>
0405 struct ReadDispatcher<UsingShadowDecl*> {
0406 template <class BasicReader, class... Args>
0407 static UsingShadowDecl* read(BasicReader &R, Args &&... args) {
0408 return R.readUsingShadowDeclRef(std::forward<Args>(args)...);
0409 }
0410 };
0411 template <>
0412 struct ReadDispatcher<ValueDecl*> {
0413 template <class BasicReader, class... Args>
0414 static ValueDecl* read(BasicReader &R, Args &&... args) {
0415 return R.readValueDeclRef(std::forward<Args>(args)...);
0416 }
0417 };
0418 template <>
0419 struct ReadDispatcher<VectorKind> {
0420 template <class BasicReader, class... Args>
0421 static VectorKind read(BasicReader &R, Args &&... args) {
0422 return R.readVectorKind(std::forward<Args>(args)...);
0423 }
0424 };
0425 template <class T>
0426 struct ReadDispatcher<llvm::ArrayRef<T>> {
0427 template <class BasicReader, class... Args>
0428 static llvm::ArrayRef<T> read(BasicReader &R, Args &&... args) {
0429 return R.readArray(std::forward<Args>(args)...);
0430 }
0431 };
0432 template <class T>
0433 struct ReadDispatcher<std::optional<T>> {
0434 template <class BasicReader, class... Args>
0435 static std::optional<T> read(BasicReader &R, Args &&... args) {
0436 return R.readOptional(std::forward<Args>(args)...);
0437 }
0438 };
0439
0440 template <class ValueType>
0441 struct UnpackOptionalValue;
0442 template <>
0443 struct UnpackOptionalValue<CXXRecordDecl*> {
0444 static std::optional<CXXRecordDecl*> unpack(CXXRecordDecl* value) {
0445 return value ? std::optional<CXXRecordDecl*>(value) : std::nullopt;
0446 }
0447 };
0448 template <>
0449 struct UnpackOptionalValue<ConceptDecl*> {
0450 static std::optional<ConceptDecl*> unpack(ConceptDecl* value) {
0451 return value ? std::optional<ConceptDecl*>(value) : std::nullopt;
0452 }
0453 };
0454 template <>
0455 struct UnpackOptionalValue<Decl*> {
0456 static std::optional<Decl*> unpack(Decl* value) {
0457 return value ? std::optional<Decl*>(value) : std::nullopt;
0458 }
0459 };
0460 template <>
0461 struct UnpackOptionalValue<Expr*> {
0462 static std::optional<Expr*> unpack(Expr* value) {
0463 return value ? std::optional<Expr*>(value) : std::nullopt;
0464 }
0465 };
0466 template <>
0467 struct UnpackOptionalValue<FunctionDecl*> {
0468 static std::optional<FunctionDecl*> unpack(FunctionDecl* value) {
0469 return value ? std::optional<FunctionDecl*>(value) : std::nullopt;
0470 }
0471 };
0472 template <>
0473 struct UnpackOptionalValue<IdentifierInfo*> {
0474 static std::optional<IdentifierInfo*> unpack(IdentifierInfo* value) {
0475 return value ? std::optional<IdentifierInfo*>(value) : std::nullopt;
0476 }
0477 };
0478 template <>
0479 struct UnpackOptionalValue<NamedDecl*> {
0480 static std::optional<NamedDecl*> unpack(NamedDecl* value) {
0481 return value ? std::optional<NamedDecl*>(value) : std::nullopt;
0482 }
0483 };
0484 template <>
0485 struct UnpackOptionalValue<NamespaceAliasDecl*> {
0486 static std::optional<NamespaceAliasDecl*> unpack(NamespaceAliasDecl* value) {
0487 return value ? std::optional<NamespaceAliasDecl*>(value) : std::nullopt;
0488 }
0489 };
0490 template <>
0491 struct UnpackOptionalValue<NamespaceDecl*> {
0492 static std::optional<NamespaceDecl*> unpack(NamespaceDecl* value) {
0493 return value ? std::optional<NamespaceDecl*>(value) : std::nullopt;
0494 }
0495 };
0496 template <>
0497 struct UnpackOptionalValue<ObjCProtocolDecl*> {
0498 static std::optional<ObjCProtocolDecl*> unpack(ObjCProtocolDecl* value) {
0499 return value ? std::optional<ObjCProtocolDecl*>(value) : std::nullopt;
0500 }
0501 };
0502 template <>
0503 struct UnpackOptionalValue<ObjCTypeParamDecl*> {
0504 static std::optional<ObjCTypeParamDecl*> unpack(ObjCTypeParamDecl* value) {
0505 return value ? std::optional<ObjCTypeParamDecl*>(value) : std::nullopt;
0506 }
0507 };
0508 template <>
0509 struct UnpackOptionalValue<QualType> {
0510 static std::optional<QualType> unpack(QualType value) {
0511 return value.isNull() ? std::nullopt : std::optional<QualType>(value);
0512 }
0513 };
0514 template <>
0515 struct UnpackOptionalValue<Stmt*> {
0516 static std::optional<Stmt*> unpack(Stmt* value) {
0517 return value ? std::optional<Stmt*>(value) : std::nullopt;
0518 }
0519 };
0520 template <>
0521 struct UnpackOptionalValue<TagDecl*> {
0522 static std::optional<TagDecl*> unpack(TagDecl* value) {
0523 return value ? std::optional<TagDecl*>(value) : std::nullopt;
0524 }
0525 };
0526 template <>
0527 struct UnpackOptionalValue<TemplateDecl*> {
0528 static std::optional<TemplateDecl*> unpack(TemplateDecl* value) {
0529 return value ? std::optional<TemplateDecl*>(value) : std::nullopt;
0530 }
0531 };
0532 template <>
0533 struct UnpackOptionalValue<TemplateName> {
0534 static std::optional<TemplateName> unpack(TemplateName value) {
0535 return value.isNull() ? std::nullopt : std::optional<TemplateName>(value);
0536 }
0537 };
0538 template <>
0539 struct UnpackOptionalValue<TemplateTemplateParmDecl*> {
0540 static std::optional<TemplateTemplateParmDecl*> unpack(TemplateTemplateParmDecl* value) {
0541 return value ? std::optional<TemplateTemplateParmDecl*>(value) : std::nullopt;
0542 }
0543 };
0544 template <>
0545 struct UnpackOptionalValue<TemplateTypeParmDecl*> {
0546 static std::optional<TemplateTypeParmDecl*> unpack(TemplateTypeParmDecl* value) {
0547 return value ? std::optional<TemplateTypeParmDecl*>(value) : std::nullopt;
0548 }
0549 };
0550 template <>
0551 struct UnpackOptionalValue<uint32_t> {
0552 static std::optional<uint32_t> unpack(uint32_t value) {
0553 return value ? std::optional<uint32_t>(value - 1) : std::nullopt;
0554 }
0555 };
0556 template <>
0557 struct UnpackOptionalValue<uint64_t> {
0558 static std::optional<uint64_t> unpack(uint64_t value) {
0559 return value ? std::optional<uint64_t>(value - 1) : std::nullopt;
0560 }
0561 };
0562 template <>
0563 struct UnpackOptionalValue<UsingShadowDecl*> {
0564 static std::optional<UsingShadowDecl*> unpack(UsingShadowDecl* value) {
0565 return value ? std::optional<UsingShadowDecl*>(value) : std::nullopt;
0566 }
0567 };
0568 template <>
0569 struct UnpackOptionalValue<ValueDecl*> {
0570 static std::optional<ValueDecl*> unpack(ValueDecl* value) {
0571 return value ? std::optional<ValueDecl*>(value) : std::nullopt;
0572 }
0573 };
0574
0575 template <class Impl>
0576 class BasicReaderBase {
0577 ASTContext &C;
0578 protected:
0579 BasicReaderBase(ASTContext &ctx) : C(ctx) {}
0580 public:
0581 ASTContext &getASTContext() { return C; }
0582 Impl &asImpl() { return static_cast<Impl&>(*this); }
0583 APValue readAPValue() {
0584 auto &ctx = asImpl().getASTContext();
0585 auto &&subR = asImpl().readObject();
0586 APValue::ValueKind kind = subR.find("kind").readAPValueKind();
0587 switch (kind) {
0588 case APValue::None: {
0589 return APValue();
0590 }
0591
0592 case APValue::Indeterminate: {
0593 return APValue::IndeterminateValue();
0594 }
0595
0596 case APValue::Int: {
0597 llvm::APSInt value = subR.find("value").readAPSInt();
0598 return APValue(value);
0599 }
0600
0601 case APValue::Float: {
0602 uint32_t semantics = subR.find("semantics").readUInt32();
0603 llvm::APInt value = subR.find("value").readAPInt();
0604
0605 const llvm::fltSemantics &floatSema = llvm::APFloatBase::EnumToSemantics(
0606 static_cast<llvm::APFloatBase::Semantics>(semantics));
0607 return APValue(llvm::APFloat(floatSema, value));
0608
0609 }
0610
0611 case APValue::FixedPoint: {
0612 llvm::FixedPointSemantics semantics = subR.find("semantics").readFixedPointSemantics();
0613 llvm::APSInt value = subR.find("value").readAPSInt();
0614
0615 return APValue(llvm::APFixedPoint(std::move(value), semantics));
0616
0617 }
0618
0619 case APValue::ComplexInt: {
0620 llvm::APSInt real = subR.find("real").readAPSInt();
0621 llvm::APSInt imag = subR.find("imag").readAPSInt();
0622 return APValue(real, imag);
0623 }
0624
0625 case APValue::ComplexFloat: {
0626 uint32_t semantics = subR.find("semantics").readUInt32();
0627 llvm::APInt real = subR.find("real").readAPInt();
0628 llvm::APInt imag = subR.find("imag").readAPInt();
0629
0630 const llvm::fltSemantics &sema = llvm::APFloatBase::EnumToSemantics(
0631 static_cast<llvm::APFloatBase::Semantics>(semantics));
0632 return APValue(llvm::APFloat(sema, real),
0633 llvm::APFloat(sema, imag));
0634
0635 }
0636
0637 case APValue::Vector: {
0638 llvm::SmallVector<APValue, 8> elements_buffer_0;
0639 llvm::ArrayRef<APValue> elements = subR.find("elements").template readArray<APValue>(elements_buffer_0);
0640
0641 APValue result;
0642 result.MakeVector();
0643 unsigned length = elements.size();
0644 (void)result.setVectorUninit(length);
0645 for (unsigned i = 0; i < length; i++)
0646 result.getVectorElt(i) = elements[i];
0647 return result;
0648
0649 }
0650
0651 case APValue::Array: {
0652 uint32_t totalLength = subR.find("totalLength").readUInt32();
0653 bool hasFiller = subR.find("hasFiller").readBool();
0654 llvm::SmallVector<APValue, 8> elements_buffer_0;
0655 llvm::ArrayRef<APValue> elements = subR.find("elements").template readArray<APValue>(elements_buffer_0);
0656
0657 APValue result;
0658 unsigned initLength = elements.size() - (hasFiller ? 1 : 0);
0659 result.MakeArray(initLength, totalLength);
0660 for (unsigned i = 0; i < initLength; ++i)
0661 result.getArrayInitializedElt(i) = elements[i];
0662 if (hasFiller)
0663 result.getArrayFiller() = elements.back();
0664 return result;
0665
0666 }
0667
0668 case APValue::Struct: {
0669 llvm::SmallVector<APValue, 8> bases_buffer_0;
0670 llvm::ArrayRef<APValue> bases = subR.find("bases").template readArray<APValue>(bases_buffer_0);
0671 llvm::SmallVector<APValue, 8> fields_buffer_0;
0672 llvm::ArrayRef<APValue> fields = subR.find("fields").template readArray<APValue>(fields_buffer_0);
0673
0674 APValue result;
0675 result.MakeStruct(bases.size(), fields.size());
0676 for (unsigned i = 0; i < bases.size(); ++i)
0677 result.getStructBase(i) = bases[i];
0678 for (unsigned i = 0; i < fields.size(); ++i)
0679 result.getStructField(i) = fields[i];
0680 return result;
0681
0682 }
0683
0684 case APValue::Union: {
0685 Decl* fieldDecl = subR.find("fieldDecl").readDeclRef();
0686 APValue value = subR.find("value").readAPValue();
0687
0688 return APValue(cast<clang::FieldDecl>(fieldDecl), std::move(value));
0689
0690 }
0691
0692 case APValue::AddrLabelDiff: {
0693 Stmt* lhs = subR.find("lhs").readStmtRef();
0694 Stmt* rhs = subR.find("rhs").readStmtRef();
0695
0696 return APValue(cast<AddrLabelExpr>(lhs), cast<AddrLabelExpr>(rhs));
0697
0698 }
0699
0700 case APValue::MemberPointer: {
0701 bool isDerived = subR.find("isDerived").readBool();
0702 ValueDecl* member = subR.find("member").readValueDeclRef();
0703 llvm::SmallVector<CXXRecordDecl*, 8> memberPath_buffer_0;
0704 llvm::ArrayRef<CXXRecordDecl*> memberPath = subR.find("memberPath").template readArray<CXXRecordDecl*>(memberPath_buffer_0);
0705
0706 APValue result;
0707 unsigned pathSize = memberPath.size();
0708 const CXXRecordDecl **pathArray =
0709 result.setMemberPointerUninit(member, isDerived, pathSize).data();
0710 for (unsigned i = 0; i < pathSize; ++i)
0711 pathArray[i] = memberPath[i]->getCanonicalDecl();
0712 return result;
0713
0714 }
0715
0716 case APValue::LValue: {
0717 bool hasLValuePath = subR.find("hasLValuePath").readBool();
0718 bool isLValueOnePastTheEnd = subR.find("isLValueOnePastTheEnd").readBool();
0719 bool isExpr = subR.find("isExpr").readBool();
0720 bool isTypeInfo = subR.find("isTypeInfo").readBool();
0721 bool isDynamicAlloc = subR.find("isDynamicAlloc").readBool();
0722 bool hasBase = subR.find("hasBase").readBool();
0723 bool isNullPtr = subR.find("isNullPtr").readBool();
0724 std::optional<QualType> typeInfo;
0725 if ( hasBase && isTypeInfo ) {
0726 typeInfo.emplace(subR.find("typeInfo").readQualType());
0727 }
0728 std::optional<uint32_t> dynamicAlloc;
0729 if ( hasBase && isDynamicAlloc ) {
0730 dynamicAlloc.emplace(subR.find("dynamicAlloc").readUInt32());
0731 }
0732 std::optional<QualType> type;
0733 if ( hasBase && (isTypeInfo || isDynamicAlloc) ) {
0734 type.emplace(subR.find("type").readQualType());
0735 }
0736 std::optional<uint32_t> callIndex;
0737 if ( hasBase && !isTypeInfo ) {
0738 callIndex.emplace(subR.find("callIndex").readUInt32());
0739 }
0740 std::optional<uint32_t> version;
0741 if ( hasBase && !isTypeInfo ) {
0742 version.emplace(subR.find("version").readUInt32());
0743 }
0744 std::optional<Stmt*> stmt;
0745 if ( hasBase && !isTypeInfo && isExpr ) {
0746 stmt.emplace(subR.find("stmt").readStmtRef());
0747 }
0748 std::optional<Decl*> decl;
0749 if ( hasBase && !isTypeInfo && !isDynamicAlloc && !isExpr ) {
0750 decl.emplace(subR.find("decl").readDeclRef());
0751 }
0752 uint32_t offsetQuantity = subR.find("offsetQuantity").readUInt32();
0753 llvm::SmallVector<APValue::LValuePathEntry, 8> lvaluePath_buffer_0;
0754 std::optional<APValue::LValuePathSerializationHelper> lvaluePath;
0755 if ( hasLValuePath ) {
0756 lvaluePath.emplace(subR.find("lvaluePath").readLValuePathSerializationHelper(lvaluePath_buffer_0));
0757 }
0758
0759 (void)ctx;
0760 APValue::LValueBase base;
0761 if (hasBase) {
0762 if (isTypeInfo) {
0763 base = APValue::LValueBase::getTypeInfo(
0764 TypeInfoLValue(typeInfo->getTypePtr()), *type);
0765 } else if (isDynamicAlloc) {
0766 base = APValue::LValueBase::getDynamicAlloc(
0767 DynamicAllocLValue(*dynamicAlloc), *type);
0768 } else if (isExpr) {
0769 base = APValue::LValueBase(cast<Expr>(*stmt),
0770 *callIndex, *version);
0771 } else {
0772 base = APValue::LValueBase(cast<ValueDecl>(*decl),
0773 *callIndex, *version);
0774 }
0775 }
0776 CharUnits offset = CharUnits::fromQuantity(offsetQuantity);
0777 APValue result;
0778 result.MakeLValue();
0779 if (!hasLValuePath) {
0780 result.setLValue(base, offset, APValue::NoLValuePath{}, isNullPtr);
0781 return result;
0782 }
0783 auto pathLength = lvaluePath->Path.size();
0784 APValue::LValuePathEntry *path = result.setLValueUninit(
0785 base, offset, pathLength, isLValueOnePastTheEnd, isNullPtr).data();
0786 llvm::copy(lvaluePath->Path, path);
0787 return result;
0788
0789 }
0790
0791 }
0792 llvm_unreachable("bad APValue::ValueKind");
0793 }
0794 APValue::ValueKind readAPValueKind() {
0795 return asImpl().template readEnum<APValue::ValueKind>();
0796 }
0797 ArraySizeModifier readArraySizeModifier() {
0798 return asImpl().template readEnum<ArraySizeModifier>();
0799 }
0800 attr::Kind readAttrKind() {
0801 return asImpl().template readEnum<attr::Kind>();
0802 }
0803 AutoTypeKeyword readAutoTypeKeyword() {
0804 return asImpl().template readEnum<AutoTypeKeyword>();
0805 }
0806 BuiltinType::Kind readBuiltinTypeKind() {
0807 return asImpl().template readEnum<BuiltinType::Kind>();
0808 }
0809 CXXRecordDecl* readCXXRecordDeclRef() {
0810 return cast_or_null<CXXRecordDecl>(asImpl().readDeclRef());
0811 }
0812 CallingConv readCallingConv() {
0813 return asImpl().template readEnum<CallingConv>();
0814 }
0815 ConceptDecl* readConceptDeclRef() {
0816 return cast_or_null<ConceptDecl>(asImpl().readDeclRef());
0817 }
0818 DeclarationName readDeclarationName() {
0819 auto &ctx = asImpl().getASTContext();
0820 auto &&subR = asImpl().readObject();
0821 DeclarationName::NameKind kind = subR.find("kind").readDeclarationNameKind();
0822 switch (kind) {
0823 case DeclarationName::Identifier: {
0824 IdentifierInfo* identifier = subR.find("identifier").readIdentifier();
0825
0826 return DeclarationName(identifier);
0827
0828 }
0829
0830 case DeclarationName::ObjCZeroArgSelector: {
0831 Selector selector = subR.find("selector").readSelector();
0832
0833 return DeclarationName(selector);
0834
0835 }
0836
0837 case DeclarationName::ObjCOneArgSelector: {
0838 Selector selector = subR.find("selector").readSelector();
0839
0840 return DeclarationName(selector);
0841
0842 }
0843
0844 case DeclarationName::ObjCMultiArgSelector: {
0845 Selector selector = subR.find("selector").readSelector();
0846
0847 return DeclarationName(selector);
0848
0849 }
0850
0851 case DeclarationName::CXXConstructorName: {
0852 QualType type = subR.find("type").readQualType();
0853
0854 return ctx.DeclarationNames.getCXXConstructorName(
0855 ctx.getCanonicalType(type));
0856
0857 }
0858
0859 case DeclarationName::CXXDestructorName: {
0860 QualType type = subR.find("type").readQualType();
0861
0862 return ctx.DeclarationNames.getCXXDestructorName(
0863 ctx.getCanonicalType(type));
0864
0865 }
0866
0867 case DeclarationName::CXXConversionFunctionName: {
0868 QualType type = subR.find("type").readQualType();
0869
0870 return ctx.DeclarationNames.getCXXConversionFunctionName(
0871 ctx.getCanonicalType(type));
0872
0873 }
0874
0875 case DeclarationName::CXXDeductionGuideName: {
0876 TemplateDecl* declaration = subR.find("declaration").readTemplateDeclRef();
0877
0878 return ctx.DeclarationNames.getCXXDeductionGuideName(declaration);
0879
0880 }
0881
0882 case DeclarationName::CXXOperatorName: {
0883 OverloadedOperatorKind operatorKind = subR.find("operatorKind").readOverloadedOperatorKind();
0884
0885 return ctx.DeclarationNames.getCXXOperatorName(operatorKind);
0886
0887 }
0888
0889 case DeclarationName::CXXLiteralOperatorName: {
0890 IdentifierInfo* identifier = subR.find("identifier").readIdentifier();
0891
0892 return ctx.DeclarationNames.getCXXLiteralOperatorName(identifier);
0893
0894 }
0895
0896 case DeclarationName::CXXUsingDirective: {
0897
0898 return DeclarationName::getUsingDirectiveName();
0899
0900 }
0901
0902 }
0903 llvm_unreachable("bad DeclarationName::NameKind");
0904 }
0905 DeclarationName::NameKind readDeclarationNameKind() {
0906 return asImpl().template readEnum<DeclarationName::NameKind>();
0907 }
0908 ElaboratedTypeKeyword readElaboratedTypeKeyword() {
0909 return asImpl().template readEnum<ElaboratedTypeKeyword>();
0910 }
0911 Expr* readExprRef() {
0912 return cast_or_null<Expr>(asImpl().readStmtRef());
0913 }
0914 FunctionDecl* readFunctionDeclRef() {
0915 return cast_or_null<FunctionDecl>(asImpl().readDeclRef());
0916 }
0917 NamedDecl* readNamedDeclRef() {
0918 return cast_or_null<NamedDecl>(asImpl().readDeclRef());
0919 }
0920 NamespaceAliasDecl* readNamespaceAliasDeclRef() {
0921 return cast_or_null<NamespaceAliasDecl>(asImpl().readDeclRef());
0922 }
0923 NamespaceDecl* readNamespaceDeclRef() {
0924 return cast_or_null<NamespaceDecl>(asImpl().readDeclRef());
0925 }
0926 NestedNameSpecifier::SpecifierKind readNestedNameSpecifierKind() {
0927 return asImpl().template readEnum<NestedNameSpecifier::SpecifierKind>();
0928 }
0929 ObjCProtocolDecl* readObjCProtocolDeclRef() {
0930 return cast_or_null<ObjCProtocolDecl>(asImpl().readDeclRef());
0931 }
0932 ObjCTypeParamDecl* readObjCTypeParamDeclRef() {
0933 return cast_or_null<ObjCTypeParamDecl>(asImpl().readDeclRef());
0934 }
0935 OverloadedOperatorKind readOverloadedOperatorKind() {
0936 return asImpl().template readEnum<OverloadedOperatorKind>();
0937 }
0938 RefQualifierKind readRefQualifierKind() {
0939 return asImpl().template readEnum<RefQualifierKind>();
0940 }
0941 SubstTemplateTypeParmTypeFlag readSubstTemplateTypeParmTypeFlag() {
0942 return asImpl().template readEnum<SubstTemplateTypeParmTypeFlag>();
0943 }
0944 TagDecl* readTagDeclRef() {
0945 return cast_or_null<TagDecl>(asImpl().readDeclRef());
0946 }
0947 TemplateArgument readTemplateArgument() {
0948 auto &ctx = asImpl().getASTContext();
0949 auto &&subR = asImpl().readObject();
0950 TemplateArgument::ArgKind kind = subR.find("kind").readTemplateArgumentKind();
0951 switch (kind) {
0952 case TemplateArgument::Null: {
0953
0954 return TemplateArgument();
0955
0956 }
0957
0958 case TemplateArgument::Type: {
0959 QualType type = subR.find("type").readQualType();
0960 bool isDefaulted = subR.find("isDefaulted").readBool();
0961
0962 return TemplateArgument(type, /* isNullPtr */ false, isDefaulted);
0963
0964 }
0965
0966 case TemplateArgument::Declaration: {
0967 ValueDecl* declaration = subR.find("declaration").readValueDeclRef();
0968 QualType parameterType = subR.find("parameterType").readQualType();
0969 bool isDefaulted = subR.find("isDefaulted").readBool();
0970
0971 return TemplateArgument(declaration, parameterType, isDefaulted);
0972
0973 }
0974
0975 case TemplateArgument::NullPtr: {
0976 QualType type = subR.find("type").readQualType();
0977 bool isDefaulted = subR.find("isDefaulted").readBool();
0978
0979 return TemplateArgument(type, /*nullptr*/ true, isDefaulted);
0980
0981 }
0982
0983 case TemplateArgument::Integral: {
0984 llvm::APSInt value = subR.find("value").readAPSInt();
0985 QualType type = subR.find("type").readQualType();
0986 bool isDefaulted = subR.find("isDefaulted").readBool();
0987
0988 return TemplateArgument(ctx, value, type, isDefaulted);
0989
0990 }
0991
0992 case TemplateArgument::StructuralValue: {
0993 APValue value = subR.find("value").readAPValue();
0994 QualType type = subR.find("type").readQualType();
0995 bool isDefaulted = subR.find("isDefaulted").readBool();
0996
0997 return TemplateArgument(ctx, type, value, isDefaulted);
0998
0999 }
1000
1001 case TemplateArgument::Template: {
1002 TemplateName name = subR.find("name").readTemplateName();
1003 bool isDefaulted = subR.find("isDefaulted").readBool();
1004
1005 return TemplateArgument(name, isDefaulted);
1006
1007 }
1008
1009 case TemplateArgument::TemplateExpansion: {
1010 TemplateName name = subR.find("name").readTemplateName();
1011 std::optional<uint32_t> numExpansions = subR.find("numExpansions").template readOptional<uint32_t>();
1012 bool isDefaulted = subR.find("isDefaulted").readBool();
1013
1014 auto numExpansionsUnsigned = llvm::transformOptional(
1015 numExpansions, [](uint32_t i) { return unsigned(i); });
1016
1017 return TemplateArgument(name, numExpansionsUnsigned, isDefaulted);
1018
1019 }
1020
1021 case TemplateArgument::Expression: {
1022 Expr* expression = subR.find("expression").readExprRef();
1023 bool isDefaulted = subR.find("isDefaulted").readBool();
1024
1025 return TemplateArgument(expression, isDefaulted);
1026
1027 }
1028
1029 case TemplateArgument::Pack: {
1030 llvm::SmallVector<TemplateArgument, 8> elements_buffer_0;
1031 llvm::ArrayRef<TemplateArgument> elements = subR.find("elements").template readArray<TemplateArgument>(elements_buffer_0);
1032
1033 // Copy the pack into the ASTContext.
1034 TemplateArgument *ctxElements = new (ctx) TemplateArgument[elements.size()];
1035 for (size_t i = 0, e = elements.size(); i != e; ++i)
1036 ctxElements[i] = elements[i];
1037 return TemplateArgument(llvm::ArrayRef(ctxElements, elements.size()));
1038
1039 }
1040
1041 }
1042 llvm_unreachable("bad TemplateArgument::ArgKind");
1043 }
1044 TemplateArgument::ArgKind readTemplateArgumentKind() {
1045 return asImpl().template readEnum<TemplateArgument::ArgKind>();
1046 }
1047 TemplateDecl* readTemplateDeclRef() {
1048 return cast_or_null<TemplateDecl>(asImpl().readDeclRef());
1049 }
1050 TemplateName readTemplateName() {
1051 auto &ctx = asImpl().getASTContext();
1052 auto &&subR = asImpl().readObject();
1053 TemplateName::NameKind kind = subR.find("kind").readTemplateNameKind();
1054 switch (kind) {
1055 case TemplateName::Template: {
1056 TemplateDecl* declaration = subR.find("declaration").readTemplateDeclRef();
1057
1058 return TemplateName(declaration);
1059
1060 }
1061
1062 case TemplateName::UsingTemplate: {
1063 UsingShadowDecl* foundDecl = subR.find("foundDecl").readUsingShadowDeclRef();
1064
1065 return TemplateName(foundDecl);
1066
1067 }
1068
1069 case TemplateName::OverloadedTemplate: {
1070 llvm::SmallVector<NamedDecl*, 8> overloads_buffer_0;
1071 llvm::ArrayRef<NamedDecl*> overloads = subR.find("overloads").template readArray<NamedDecl*>(overloads_buffer_0);
1072
1073 // Copy into an UnresolvedSet to satisfy the interface.
1074 UnresolvedSet<8> overloadSet;
1075 for (auto overload : overloads) {
1076 overloadSet.addDecl(overload);
1077 }
1078
1079 return ctx.getOverloadedTemplateName(overloadSet.begin(),
1080 overloadSet.end());
1081
1082 }
1083
1084 case TemplateName::AssumedTemplate: {
1085 DeclarationName name = subR.find("name").readDeclarationName();
1086
1087 return ctx.getAssumedTemplateName(name);
1088
1089 }
1090
1091 case TemplateName::QualifiedTemplate: {
1092 NestedNameSpecifier * qualifier = subR.find("qualifier").readNestedNameSpecifier();
1093 bool hasTemplateKeyword = subR.find("hasTemplateKeyword").readBool();
1094 TemplateName underlyingTemplateName = subR.find("underlyingTemplateName").readTemplateName();
1095
1096 return ctx.getQualifiedTemplateName(qualifier, hasTemplateKeyword,
1097 underlyingTemplateName);
1098
1099 }
1100
1101 case TemplateName::DependentTemplate: {
1102 NestedNameSpecifier * qualifier = subR.find("qualifier").readNestedNameSpecifier();
1103 std::optional<IdentifierInfo*> identifier = subR.find("identifier").template readOptional<IdentifierInfo*>();
1104 std::optional<OverloadedOperatorKind> operatorKind;
1105 if ( !identifier ) {
1106 operatorKind.emplace(subR.find("operatorKind").readOverloadedOperatorKind());
1107 }
1108
1109 if (identifier) {
1110 return ctx.getDependentTemplateName(qualifier, *identifier);
1111 } else {
1112 return ctx.getDependentTemplateName(qualifier, *operatorKind);
1113 }
1114
1115 }
1116
1117 case TemplateName::SubstTemplateTemplateParm: {
1118 TemplateName replacement = subR.find("replacement").readTemplateName();
1119 Decl* associatedDecl = subR.find("associatedDecl").readDeclRef();
1120 uint32_t index = subR.find("index").readUInt32();
1121 std::optional<uint32_t> packIndex = subR.find("packIndex").template readOptional<uint32_t>();
1122
1123 return ctx.getSubstTemplateTemplateParm(replacement, associatedDecl, index, packIndex);
1124
1125 }
1126
1127 case TemplateName::SubstTemplateTemplateParmPack: {
1128 TemplateArgument argumentPack = subR.find("argumentPack").readTemplateArgument();
1129 Decl* associatedDecl = subR.find("associatedDecl").readDeclRef();
1130 uint32_t index = subR.find("index").readUInt32();
1131 bool final = subR.find("final").readBool();
1132
1133 return ctx.getSubstTemplateTemplateParmPack(argumentPack, associatedDecl, index, final);
1134
1135 }
1136
1137 case TemplateName::DeducedTemplate: {
1138 TemplateName underlying = subR.find("underlying").readTemplateName();
1139 uint32_t startPos = subR.find("startPos").readUInt32();
1140 llvm::SmallVector<TemplateArgument, 8> defaultArgs_buffer_0;
1141 llvm::ArrayRef<TemplateArgument> defaultArgs = subR.find("defaultArgs").template readArray<TemplateArgument>(defaultArgs_buffer_0);
1142
1143 return ctx.getDeducedTemplateName(underlying, {startPos, defaultArgs});
1144
1145 }
1146
1147 }
1148 llvm_unreachable("bad TemplateName::NameKind");
1149 }
1150 TemplateName::NameKind readTemplateNameKind() {
1151 return asImpl().template readEnum<TemplateName::NameKind>();
1152 }
1153 TemplateTemplateParmDecl* readTemplateTemplateParmDeclRef() {
1154 return cast_or_null<TemplateTemplateParmDecl>(asImpl().readDeclRef());
1155 }
1156 TemplateTypeParmDecl* readTemplateTypeParmDeclRef() {
1157 return cast_or_null<TemplateTypeParmDecl>(asImpl().readDeclRef());
1158 }
1159 TypeOfKind readTypeOfKind() {
1160 return asImpl().template readEnum<TypeOfKind>();
1161 }
1162 UnaryTransformType::UTTKind readUnaryTypeTransformKind() {
1163 return asImpl().template readEnum<UnaryTransformType::UTTKind>();
1164 }
1165 UsingShadowDecl* readUsingShadowDeclRef() {
1166 return cast_or_null<UsingShadowDecl>(asImpl().readDeclRef());
1167 }
1168 ValueDecl* readValueDeclRef() {
1169 return cast_or_null<ValueDecl>(asImpl().readDeclRef());
1170 }
1171 VectorKind readVectorKind() {
1172 return asImpl().template readEnum<VectorKind>();
1173 }
1174 };
1175
