[AST] [NFC] Add a convenient getter from QualType to RecordDecl

[rjmccall]

LGTM. but would you mind running through the code and looking for places that would use this?

[george.karpenkov]

I need to use it a few times in the analyzer. I can try to search for other uses.

[rjmccall]

Thanks, I appreciate it.

clang/include/clang/AST/Type.h

   const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
   const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
 
   /// Retrieves the CXXRecordDecl that this type refers to, either
   /// because the type is a RecordType or because it is the injected-class-name
   /// type of a class template or class template partial specialization.
   CXXRecordDecl *getAsCXXRecordDecl() const;
 
+  /// Retrieves the RecordDecl this type refers to.
+  RecordDecl *getAsRecordDecl() const;
+
   /// Retrieves the TagDecl that this type refers to, either
   /// because the type is a TagType or because it is the injected-class-name
   /// type of a class template or class template partial specialization.
   TagDecl *getAsTagDecl() const;
 
   /// If this is a pointer or reference to a RecordType, return the
   /// CXXRecordDecl that the type refers to.
   ///

clang/lib/AST/Decl.cpp

   if (!FTL)
     return SourceRange();
 
   return FTL.getExceptionSpecRange();
 }
 
 const Attr *FunctionDecl::getUnusedResultAttr() const {
   QualType RetType = getReturnType();
-  if (RetType->isRecordType()) {
-    if (const auto *Ret =
-            dyn_cast_or_null<RecordDecl>(RetType->getAsTagDecl())) {
-      if (const auto *R = Ret->getAttr<WarnUnusedResultAttr>())
-        return R;
-    }
+  if (const auto *Ret = RetType->getAsRecordDecl()) {
+    if (const auto *R = Ret->getAttr<WarnUnusedResultAttr>())
+      return R;
   } else if (const auto *ET = RetType->getAs<EnumType>()) {
     if (const EnumDecl *ED = ET->getDecl()) {
       if (const auto *R = ED->getAttr<WarnUnusedResultAttr>())
         return R;
     }
   }
   return getAttr<WarnUnusedResultAttr>();
 }

clang/lib/AST/Type.cpp

 
   return nullptr;
 }
 
 CXXRecordDecl *Type::getAsCXXRecordDecl() const {
   return dyn_cast_or_null<CXXRecordDecl>(getAsTagDecl());
 }
 
+RecordDecl *Type::getAsRecordDecl() const {
+  return dyn_cast_or_null<RecordDecl>(getAsTagDecl());
+}
+
 TagDecl *Type::getAsTagDecl() const {
   if (const auto *TT = getAs<TagType>())
     return TT->getDecl();
   if (const auto *Injected = getAs<InjectedClassNameType>())
     return Injected->getDecl();
 
   return nullptr;
 }

clang/lib/Analysis/BodyFarm.cpp

if (!Flag->getType()->isReferenceType()) {
     return nullptr;
   }
 
   QualType CallbackType = Callback->getType().getNonReferenceType();
 
   // Nullable pointer, non-null iff function is a CXXRecordDecl.
   CXXRecordDecl *CallbackRecordDecl = CallbackType->getAsCXXRecordDecl();
   QualType FlagType = Flag->getType().getNonReferenceType();
-  auto *FlagRecordDecl = dyn_cast_or_null<RecordDecl>(FlagType->getAsTagDecl());
+  auto *FlagRecordDecl = FlagType->getAsRecordDecl();
 
   if (!FlagRecordDecl) {
     LLVM_DEBUG(llvm::dbgs() << "Flag field is not a record: "
                             << "unknown std::call_once implementation, "
                             << "ignoring the call.\n");
     return nullptr;
   }
 

clang/lib/CodeGen/CGExprConstant.cpp

       unsigned fieldIndex = layout.getLLVMFieldNo(Field);
       elements[fieldIndex] = CGM.EmitNullConstant(Field->getType());
     }
 
     // For unions, stop after the first named field.
     if (record->isUnion()) {
       if (Field->getIdentifier())
         break;
-      if (const auto *FieldRD =
-              dyn_cast_or_null<RecordDecl>(Field->getType()->getAsTagDecl()))
+      if (const auto *FieldRD = Field->getType()->getAsRecordDecl())
         if (FieldRD->findFirstNamedDataMember())
           break;
     }
   }
 
   // Fill in the virtual bases, if we're working with the complete object.
   if (CXXR && asCompleteObject) {
     for (const auto &I : CXXR->vbases()) {

clang/lib/CodeGen/CGRecordLayoutBuilder.cpp

for (const auto *Field : D->fields()) {
     // This union might not be zero initialized: it may contain a pointer to
     // data member which might have some exotic initialization sequence.
     // If this is the case, then we aught not to try and come up with a "better"
     // type, it might not be very easy to come up with a Constant which
     // correctly initializes it.
     if (!SeenNamedMember) {
       SeenNamedMember = Field->getIdentifier();
       if (!SeenNamedMember)
-        if (const auto *FieldRD =
-                dyn_cast_or_null<RecordDecl>(Field->getType()->getAsTagDecl()))
+        if (const auto *FieldRD = Field->getType()->getAsRecordDecl())
           SeenNamedMember = FieldRD->findFirstNamedDataMember();
       if (SeenNamedMember && !isZeroInitializable(Field)) {
         IsZeroInitializable = IsZeroInitializableAsBase = false;
         StorageType = FieldType;
       }
     }
     // Because our union isn't zero initializable, we won't be getting a better
     // storage type.
     if (!IsZeroInitializable)