[clang-doc] Serialize inherited attributes and methods

[DiegoAstiazaran]

Summary

clang-doc now serializes the inherited attributes and methods, not only the name of the base class.
All inherited are tracked, if B:A and C:B, info of A is included in C.
This data is stored in attribute Bases in a RecordInfo.
Previously tracked inheritance data, stored in Parents and VParents, hasn't been removed to reduce review load.

[juliehockett]

clang-tools-extra/clang-doc/BitcodeWriter.h

33

I definitely haven't been particularly good about bumping this, but can you bump it? This is a decently large change.

clang-tools-extra/clang-doc/Serialize.cpp

233–275

s/documentInfo/shouldSerializeInfo

277

s/false//*IsInAnonymousNamespace=*/false

436

Will getDecl() always return a non-null pointer? In the normal case I'd assume so, but the cast_or_null will only catch a null coming out of getDefinition() or the cast, not getDecl, so just want to check.

437–439

Is there a reason this isn't bool IsVirtual = B.IsVirtual()?

440–446

Do this in an if/else -- getNameAsString() is a decently expensive operation, so only do it when you need it.

447–450

It would be better to create the BaseRecordInfo and then move it into the vector, since the constructor will copy all those strings.

454

s/inherit/serialize

460

s/populateParentNamespaces/populateFunctionInfo ?

clang-tools-extra/unittests/clang-doc/YAMLGeneratorTest.cpp

91

For clarity, call this something else? Since it already has an X private member.

[DiegoAstiazaran]

Increase version number of clang-doc bitcode.
Rename documentInfo function to shouldSerializeInfo.
In new parseBases a BaseRecordInfo object is created and then added to Bases of main RecordInfo.
Fix comments.

[DiegoAstiazaran]

clang-tools-extra/clang-doc/Serialize.cpp

436

I got this logic from https://clang.llvm.org/doxygen/CXXInheritance_8cpp_source.html#l00150 so it should probably work as you said, getDecl() always returns a non-null pointer.

[DiegoAstiazaran]

Rebase to master

clang-tools-extra/clang-doc/BitcodeReader.cpp

case RECORD_IS_TYPE_DEF:
     return decodeRecord(R, I->IsTypeDef, Blob);
   default:
     return llvm::make_error<llvm::StringError>(
         "Invalid field for RecordInfo.\n", llvm::inconvertibleErrorCode());
   }
 }
 
 llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
+                        BaseRecordInfo *I) {
+  switch (ID) {
+  case BASE_RECORD_USR:
+    return decodeRecord(R, I->USR, Blob);
+  case BASE_RECORD_NAME:
+    return decodeRecord(R, I->Name, Blob);
+  case BASE_RECORD_PATH:
+    return decodeRecord(R, I->Path, Blob);
+  case BASE_RECORD_TAG_TYPE:
+    return decodeRecord(R, I->TagType, Blob);
+  case BASE_RECORD_IS_VIRTUAL:
+    return decodeRecord(R, I->IsVirtual, Blob);
+  case BASE_RECORD_ACCESS:
+    return decodeRecord(R, I->Access, Blob);
+  case BASE_RECORD_IS_PARENT:
+    return decodeRecord(R, I->IsParent, Blob);
+  default:
+    return llvm::make_error<llvm::StringError>(
+        "Invalid field for BaseRecordInfo.\n", llvm::inconvertibleErrorCode());
+  }
+}
+
+llvm::Error parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
                         EnumInfo *I) {
   switch (ID) {
   case ENUM_USR:
     return decodeRecord(R, I->USR, Blob);
   case ENUM_NAME:
     return decodeRecord(R, I->Name, Blob);
   case ENUM_DEFLOCATION:
     return decodeRecord(R, I->DefLoc, Blob);
return llvm::make_error<llvm::StringError>(
       llvm::inconvertibleErrorCode());
 }
 
 template <> llvm::Error addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
   I->Members.emplace_back(std::move(T));
   return llvm::Error::success();
 }
 
+template <> llvm::Error addTypeInfo(BaseRecordInfo *I, MemberTypeInfo &&T) {
+  I->Members.emplace_back(std::move(T));
+  return llvm::Error::success();
+}
+
 template <> llvm::Error addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
   I->ReturnType = std::move(T);
   return llvm::Error::success();
 }
 
 template <> llvm::Error addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
   I->Params.emplace_back(std::move(T));
   return llvm::Error::success();

 template <> void addChild(RecordInfo *I, FunctionInfo &&R) {
   I->ChildFunctions.emplace_back(std::move(R));
 }
 
 template <> void addChild(RecordInfo *I, EnumInfo &&R) {
   I->ChildEnums.emplace_back(std::move(R));
 }
 
+template <> void addChild(RecordInfo *I, BaseRecordInfo &&R) {
+  I->Bases.emplace_back(std::move(R));
+}
+
+template <> void addChild(BaseRecordInfo *I, FunctionInfo &&R) {
+  I->ChildFunctions.emplace_back(std::move(R));
+}
+
 // Read records from bitcode into a given info.
 template <typename T>
 llvm::Error ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
   Record R;
   llvm::StringRef Blob;
   llvm::Expected<unsigned> MaybeRecID = Stream.readRecord(ID, R, &Blob);
   if (!MaybeRecID)
     return MaybeRecID.takeError();
llvm::Error ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
   }
   case BI_FUNCTION_BLOCK_ID: {
     FunctionInfo F;
     if (auto Err = readBlock(ID, &F))
       return Err;
     addChild(I, std::move(F));
     return llvm::Error::success();
   }
+  case BI_BASE_RECORD_BLOCK_ID: {
+    BaseRecordInfo BR;
+    if (auto Err = readBlock(ID, &BR))
+      return Err;
+    addChild(I, std::move(BR));
+    return llvm::Error::success();
+  }
   case BI_ENUM_BLOCK_ID: {
     EnumInfo E;
     if (auto Err = readBlock(ID, &E))
       return Err;
     addChild(I, std::move(E));
     return llvm::Error::success();
   }
   default:

clang-tools-extra/clang-doc/BitcodeWriter.h

 #include <vector>
 
 namespace clang {
 namespace doc {
 
 // Current version number of clang-doc bitcode.
 // Should be bumped when removing or changing BlockIds, RecordIds, or
 // BitCodeConstants, though they can be added without breaking it.
-static const unsigned VersionNumber = 2;
+static const unsigned VersionNumber = 3;
 
 struct BitCodeConstants {
   static constexpr unsigned RecordSize = 32U;
   static constexpr unsigned SignatureBitSize = 8U;
   static constexpr unsigned SubblockIDSize = 4U;
   static constexpr unsigned BoolSize = 1U;
   static constexpr unsigned IntSize = 16U;
   static constexpr unsigned StringLengthSize = 16U;

 enum BlockId {
   BI_VERSION_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID,
   BI_NAMESPACE_BLOCK_ID,
   BI_ENUM_BLOCK_ID,
   BI_TYPE_BLOCK_ID,
   BI_FIELD_TYPE_BLOCK_ID,
   BI_MEMBER_TYPE_BLOCK_ID,
   BI_RECORD_BLOCK_ID,
+  BI_BASE_RECORD_BLOCK_ID,
   BI_FUNCTION_BLOCK_ID,
   BI_COMMENT_BLOCK_ID,
   BI_REFERENCE_BLOCK_ID,
   BI_LAST,
   BI_FIRST = BI_VERSION_BLOCK_ID
 };
 
 // New Ids need to be added to the enum here, and to the relevant IdNameMap and
enum RecordId {
   ENUM_SCOPED,
   RECORD_USR,
   RECORD_NAME,
   RECORD_PATH,
   RECORD_DEFLOCATION,
   RECORD_LOCATION,
   RECORD_TAG_TYPE,
   RECORD_IS_TYPE_DEF,
+  BASE_RECORD_USR,
+  BASE_RECORD_NAME,
+  BASE_RECORD_PATH,
+  BASE_RECORD_TAG_TYPE,
+  BASE_RECORD_IS_VIRTUAL,
+  BASE_RECORD_ACCESS,
+  BASE_RECORD_IS_PARENT,
   REFERENCE_USR,
   REFERENCE_NAME,
   REFERENCE_TYPE,
   REFERENCE_PATH,
   REFERENCE_IS_IN_GLOBAL_NAMESPACE,
   REFERENCE_FIELD,
   RI_LAST,
   RI_FIRST = VERSION
public:
   }
 
   // Write a specific info to a bitcode stream.
   bool dispatchInfoForWrite(Info *I);
 
   // Block emission of different info types.
   void emitBlock(const NamespaceInfo &I);
   void emitBlock(const RecordInfo &I);
+  void emitBlock(const BaseRecordInfo &I);
   void emitBlock(const FunctionInfo &I);
   void emitBlock(const EnumInfo &I);
   void emitBlock(const TypeInfo &B);
   void emitBlock(const FieldTypeInfo &B);
   void emitBlock(const MemberTypeInfo &B);
   void emitBlock(const CommentInfo &B);
   void emitBlock(const Reference &B, FieldId F);
 

clang-tools-extra/clang-doc/BitcodeWriter.cpp

BlockIdNameMap = []() {
       static const std::vector<std::pair<BlockId, const char *const>> Inits = {
           {BI_VERSION_BLOCK_ID, "VersionBlock"},
           {BI_NAMESPACE_BLOCK_ID, "NamespaceBlock"},
           {BI_ENUM_BLOCK_ID, "EnumBlock"},
           {BI_TYPE_BLOCK_ID, "TypeBlock"},
           {BI_FIELD_TYPE_BLOCK_ID, "FieldTypeBlock"},
           {BI_MEMBER_TYPE_BLOCK_ID, "MemberTypeBlock"},
           {BI_RECORD_BLOCK_ID, "RecordBlock"},
+          {BI_BASE_RECORD_BLOCK_ID, "BaseRecordBlock"},
           {BI_FUNCTION_BLOCK_ID, "FunctionBlock"},
           {BI_COMMENT_BLOCK_ID, "CommentBlock"},
           {BI_REFERENCE_BLOCK_ID, "ReferenceBlock"}};
       assert(Inits.size() == BlockIdCount);
       for (const auto &Init : Inits)
         BlockIdNameMap[Init.first] = Init.second;
       assert(BlockIdNameMap.size() == BlockIdCount);
       return BlockIdNameMap;
RecordIdNameMap = []() {
           {ENUM_SCOPED, {"Scoped", &BoolAbbrev}},
           {RECORD_USR, {"USR", &SymbolIDAbbrev}},
           {RECORD_NAME, {"Name", &StringAbbrev}},
           {RECORD_PATH, {"Path", &StringAbbrev}},
           {RECORD_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
           {RECORD_LOCATION, {"Location", &LocationAbbrev}},
           {RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
           {RECORD_IS_TYPE_DEF, {"IsTypeDef", &BoolAbbrev}},
+          {BASE_RECORD_USR, {"USR", &SymbolIDAbbrev}},
+          {BASE_RECORD_NAME, {"Name", &StringAbbrev}},
+          {BASE_RECORD_PATH, {"Path", &StringAbbrev}},
+          {BASE_RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
+          {BASE_RECORD_IS_VIRTUAL, {"IsVirtual", &BoolAbbrev}},
+          {BASE_RECORD_ACCESS, {"Access", &IntAbbrev}},
+          {BASE_RECORD_IS_PARENT, {"IsParent", &BoolAbbrev}},
           {FUNCTION_USR, {"USR", &SymbolIDAbbrev}},
           {FUNCTION_NAME, {"Name", &StringAbbrev}},
           {FUNCTION_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
           {FUNCTION_LOCATION, {"Location", &LocationAbbrev}},
           {FUNCTION_ACCESS, {"Access", &IntAbbrev}},
           {FUNCTION_IS_METHOD, {"IsMethod", &BoolAbbrev}},
           {REFERENCE_USR, {"USR", &SymbolIDAbbrev}},
           {REFERENCE_NAME, {"Name", &StringAbbrev}},
RecordsByBlock{
           ENUM_SCOPED}},
         // Namespace Block
         {BI_NAMESPACE_BLOCK_ID,
          {NAMESPACE_USR, NAMESPACE_NAME, NAMESPACE_PATH}},
         // Record Block
         {BI_RECORD_BLOCK_ID,
          {RECORD_USR, RECORD_NAME, RECORD_PATH, RECORD_DEFLOCATION,
           RECORD_LOCATION, RECORD_TAG_TYPE, RECORD_IS_TYPE_DEF}},
+        // BaseRecord Block
+        {BI_BASE_RECORD_BLOCK_ID,
+         {BASE_RECORD_USR, BASE_RECORD_NAME, BASE_RECORD_PATH,
+          BASE_RECORD_TAG_TYPE, BASE_RECORD_IS_VIRTUAL, BASE_RECORD_ACCESS,
+          BASE_RECORD_IS_PARENT}},
         // Function Block
         {BI_FUNCTION_BLOCK_ID,
          {FUNCTION_USR, FUNCTION_NAME, FUNCTION_DEFLOCATION, FUNCTION_LOCATION,
           FUNCTION_ACCESS, FUNCTION_IS_METHOD}},
         // Reference Block
         {BI_REFERENCE_BLOCK_ID,
          {REFERENCE_USR, REFERENCE_NAME, REFERENCE_TYPE, REFERENCE_PATH,
           REFERENCE_IS_IN_GLOBAL_NAMESPACE, REFERENCE_FIELD}}};
void ClangDocBitcodeWriter::emitBlock(const RecordInfo &I) {
   emitRecord(I.TagType, RECORD_TAG_TYPE);
   emitRecord(I.IsTypeDef, RECORD_IS_TYPE_DEF);
   for (const auto &N : I.Members)
     emitBlock(N);
   for (const auto &P : I.Parents)
     emitBlock(P, FieldId::F_parent);
   for (const auto &P : I.VirtualParents)
     emitBlock(P, FieldId::F_vparent);
+  for (const auto &PB : I.Bases)
+    emitBlock(PB);
   for (const auto &C : I.ChildRecords)
     emitBlock(C, FieldId::F_child_record);
   for (const auto &C : I.ChildFunctions)
     emitBlock(C);
   for (const auto &C : I.ChildEnums)
     emitBlock(C);
 }
 
+void ClangDocBitcodeWriter::emitBlock(const BaseRecordInfo &I) {
+  StreamSubBlockGuard Block(Stream, BI_BASE_RECORD_BLOCK_ID);
+  emitRecord(I.USR, BASE_RECORD_USR);
+  emitRecord(I.Name, BASE_RECORD_NAME);
+  emitRecord(I.Path, BASE_RECORD_PATH);
+  emitRecord(I.TagType, BASE_RECORD_TAG_TYPE);
+  emitRecord(I.IsVirtual, BASE_RECORD_IS_VIRTUAL);
+  emitRecord(I.Access, BASE_RECORD_ACCESS);
+  emitRecord(I.IsParent, BASE_RECORD_IS_PARENT);
+  for (const auto &M : I.Members)
+    emitBlock(M);
+  for (const auto &C : I.ChildFunctions)
+    emitBlock(C);
+}
+
 void ClangDocBitcodeWriter::emitBlock(const FunctionInfo &I) {
   StreamSubBlockGuard Block(Stream, BI_FUNCTION_BLOCK_ID);
   emitRecord(I.USR, FUNCTION_USR);
   emitRecord(I.Name, FUNCTION_NAME);
   for (const auto &N : I.Namespace)
     emitBlock(N, FieldId::F_namespace);
   for (const auto &CI : I.Description)
     emitBlock(CI);

clang-tools-extra/clang-doc/Representation.h

 namespace doc {
 
 // SHA1'd hash of a USR.
 using SymbolID = std::array<uint8_t, 20>;
 
 struct Info;
 struct FunctionInfo;
 struct EnumInfo;
+struct BaseRecordInfo;
 
 enum class InfoType {
   IT_default,
   IT_namespace,
   IT_record,
   IT_function,
   IT_enum
 };
struct NamespaceInfo : public Info {
   std::vector<EnumInfo> ChildEnums;
 };
 
 // Info for symbols.
 struct SymbolInfo : public Info {
   SymbolInfo(InfoType IT) : Info(IT) {}
   SymbolInfo(InfoType IT, SymbolID USR) : Info(IT, USR) {}
   SymbolInfo(InfoType IT, SymbolID USR, StringRef Name) : Info(IT, USR, Name) {}
-  SymbolInfo(InfoType IT, SymbolID USR, StringRef Name, StringRef Path) : Info(IT, USR, Name, Path) {}
+  SymbolInfo(InfoType IT, SymbolID USR, StringRef Name, StringRef Path)
+      : Info(IT, USR, Name, Path) {}
 
   void merge(SymbolInfo &&I);
 
   llvm::Optional<Location> DefLoc;    // Location where this decl is defined.
   llvm::SmallVector<Location, 2> Loc; // Locations where this decl is declared.
 };
 
 // TODO: Expand to allow for documenting templating and default args.
struct RecordInfo : public SymbolInfo {
   llvm::SmallVector<MemberTypeInfo, 4>
       Members;                             // List of info about record members.
   llvm::SmallVector<Reference, 4> Parents; // List of base/parent records
                                            // (does not include virtual
                                            // parents).
   llvm::SmallVector<Reference, 4>
       VirtualParents; // List of virtual base/parent records.
 
-  // Records are references because they will be properly
-  // documented in their own info, while the entirety of Functions and Enums are
-  // included here because they should not have separate documentation from
-  // their scope.
+  std::vector<BaseRecordInfo>
+      Bases; // List of base/parent records; this includes inherited methods and
+             // attributes
+
+  // Records are references because they will be properly documented in their
+  // own info, while the entirety of Functions and Enums are included here
+  // because they should not have separate documentation from their scope.
   std::vector<Reference> ChildRecords;
   std::vector<FunctionInfo> ChildFunctions;
   std::vector<EnumInfo> ChildEnums;
 };
 
+struct BaseRecordInfo : public RecordInfo {
+  BaseRecordInfo() : RecordInfo() {}
+  BaseRecordInfo(SymbolID USR, StringRef Name, StringRef Path, bool IsVirtual,
+                 AccessSpecifier Access, bool IsParent)
+      : RecordInfo(USR, Name, Path), IsVirtual(IsVirtual), Access(Access),
+        IsParent(IsParent) {}
+
+  // Indicates if base corresponds to a virtual inheritance
+  bool IsVirtual = false;
+  // Access level associated with this inherited info (public, protected,
+  // private).
+  AccessSpecifier Access = AccessSpecifier::AS_public;
+  bool IsParent = false; // Indicates if this base is a direct parent
+};
+
 // TODO: Expand to allow for documenting templating.
 // Info for types.
 struct EnumInfo : public SymbolInfo {
   EnumInfo() : SymbolInfo(InfoType::IT_enum) {}
   EnumInfo(SymbolID USR) : SymbolInfo(InfoType::IT_enum, USR) {}
 
   void merge(EnumInfo &&I);
 

clang-tools-extra/clang-doc/Representation.cpp

 }
 
 void RecordInfo::merge(RecordInfo &&Other) {
   assert(mergeable(Other));
   if (!TagType)
     TagType = Other.TagType;
   if (Members.empty())
     Members = std::move(Other.Members);
+  if (Bases.empty())
+    Bases = std::move(Other.Bases);
   if (Parents.empty())
     Parents = std::move(Other.Parents);
   if (VirtualParents.empty())
     VirtualParents = std::move(Other.VirtualParents);
   // Reduce children if necessary.
   reduceChildren(ChildRecords, std::move(Other.ChildRecords));
   reduceChildren(ChildFunctions, std::move(Other.ChildFunctions));
   reduceChildren(ChildEnums, std::move(Other.ChildEnums));

clang-tools-extra/clang-doc/Serialize.cpp

static bool isPublic(const clang::AccessSpecifier AS,
   if (AS == clang::AccessSpecifier::AS_private)
     return false;
   else if ((Link == clang::Linkage::ModuleLinkage) ||
            (Link == clang::Linkage::ExternalLinkage))
     return true;
   return false; // otherwise, linkage is some form of internal linkage
 }
 
-static void parseFields(RecordInfo &I, const RecordDecl *D, bool PublicOnly) {
+static bool shouldSerializeInfo(bool PublicOnly, bool IsInAnonymousNamespace,
+                                const NamedDecl *D) {
+  bool IsAnonymousNamespace = false;
+  if (const auto *N = dyn_cast<NamespaceDecl>(D))
+    IsAnonymousNamespace = N->isAnonymousNamespace();
+  return !PublicOnly ||
+         (!IsInAnonymousNamespace && !IsAnonymousNamespace &&
+          isPublic(D->getAccessUnsafe(), D->getLinkageInternal()));
+}
+
+// There are two uses for this function.
+// 1) Getting the resulting mode of inheritance of a record.
+//    Example: class A {}; class B : private A {}; class C : public B {};
+//    It's explicit that C is publicly inherited from C and B is privately
+//    inherited from A. It's not explicit but C is also privately inherited from
+//    A. This is the AS that this function calculates. FirstAS is the
+//    inheritance mode of `class C : B` and SecondAS is the inheritance mode of
+//    `class B : A`.
+// 2) Getting the inheritance mode of an inherited attribute / method.
+//    Example : class A { public: int M; }; class B : private A {};
+//    Class B is inherited from class A, which has a public attribute. This
+//    attribute is now part of the derived class B but it's not public. This
+//    will be private because the inheritance is private. This is the AS that
+//    this function calculates. FirstAS is the inheritance mode and SecondAS is
+//    the AS of the attribute / method.
+static AccessSpecifier getFinalAccessSpecifier(AccessSpecifier FirstAS,
+                                               AccessSpecifier SecondAS) {
+  if (FirstAS == AccessSpecifier::AS_none ||
+      SecondAS == AccessSpecifier::AS_none)
+    return AccessSpecifier::AS_none;
+  if (FirstAS == AccessSpecifier::AS_private ||
+      SecondAS == AccessSpecifier::AS_private)
+    return AccessSpecifier::AS_private;
+  if (FirstAS == AccessSpecifier::AS_protected ||
+      SecondAS == AccessSpecifier::AS_protected)
+    return AccessSpecifier::AS_protected;
+  return AccessSpecifier::AS_public;
+}
+
+// The Access parameter is only provided when parsing the field of an inherited
+// record, the access specification of the field depends on the inheritance mode
+static void parseFields(RecordInfo &I, const RecordDecl *D, bool PublicOnly,
+                        AccessSpecifier Access = AccessSpecifier::AS_public) {
   for (const FieldDecl *F : D->fields()) {
-    if (PublicOnly && !isPublic(F->getAccessUnsafe(), F->getLinkageInternal()))
+    if (!shouldSerializeInfo(PublicOnly, /*IsInAnonymousNamespace=*/false, F))
       continue;
     if (const auto *T = getDeclForType(F->getTypeSourceInfo()->getType())) {
       // Use getAccessUnsafe so that we just get the default AS_none if it's not
       // valid, as opposed to an assert.
       if (const auto *N = dyn_cast<EnumDecl>(T)) {
-        I.Members.emplace_back(getUSRForDecl(T), N->getNameAsString(),
-                               InfoType::IT_enum, getInfoRelativePath(N),
-                               F->getNameAsString(), N->getAccessUnsafe());
+        I.Members.emplace_back(
+            getUSRForDecl(T), N->getNameAsString(), InfoType::IT_enum,
+            getInfoRelativePath(N), F->getNameAsString(),
+            getFinalAccessSpecifier(Access, N->getAccessUnsafe()));
         continue;
       } else if (const auto *N = dyn_cast<RecordDecl>(T)) {
-        I.Members.emplace_back(getUSRForDecl(T), N->getNameAsString(),
-                               InfoType::IT_record, getInfoRelativePath(N),
-                               F->getNameAsString(), N->getAccessUnsafe());
+        I.Members.emplace_back(
+            getUSRForDecl(T), N->getNameAsString(), InfoType::IT_record,
+            getInfoRelativePath(N), F->getNameAsString(),
+            getFinalAccessSpecifier(Access, N->getAccessUnsafe()));
         continue;
       }
     }
-    I.Members.emplace_back(F->getTypeSourceInfo()->getType().getAsString(),
-                           F->getNameAsString(), F->getAccessUnsafe());
+    I.Members.emplace_back(
+        F->getTypeSourceInfo()->getType().getAsString(), F->getNameAsString(),
+        getFinalAccessSpecifier(Access, F->getAccessUnsafe()));
   }
 }
 
 static void parseEnumerators(EnumInfo &I, const EnumDecl *D) {
   for (const EnumConstantDecl *E : D->enumerators())
     I.Members.emplace_back(E->getNameAsString());
 }
 
if (const auto *T = getDeclForType(P->getOriginalType())) {
         continue;
       }
     }
     I.Params.emplace_back(P->getOriginalType().getAsString(),
                           P->getNameAsString());
   }
 }
 
+// TODO: Remove the serialization of Parents and VirtualParents, this
+// information is also extracted in the other definition of parseBases.
 static void parseBases(RecordInfo &I, const CXXRecordDecl *D) {
   // Don't parse bases if this isn't a definition.
   if (!D->isThisDeclarationADefinition())
     return;
   for (const CXXBaseSpecifier &B : D->bases()) {
     if (B.isVirtual())
       continue;
     if (const auto *Ty = B.getType()->getAs<TemplateSpecializationType>()) {
else if (dyn_cast<RecordDecl>(T))
       I.ReturnType = TypeInfo(getUSRForDecl(T), T->getNameAsString(),
                               InfoType::IT_record, getInfoRelativePath(T));
   } else {
     I.ReturnType = TypeInfo(D->getReturnType().getAsString());
   }
   parseParameters(I, D);
 }
 
+static void
+parseBases(RecordInfo &I, const CXXRecordDecl *D, bool IsFileInRootDir,
+           bool PublicOnly, bool IsParent,
+           AccessSpecifier ParentAccess = AccessSpecifier::AS_public) {
+  // Don't parse bases if this isn't a definition.
+  if (!D->isThisDeclarationADefinition())
+    return;
+  for (const CXXBaseSpecifier &B : D->bases()) {
+    if (const RecordType *Ty = B.getType()->getAs<RecordType>()) {
+      if (const CXXRecordDecl *Base =
+              cast_or_null<CXXRecordDecl>(Ty->getDecl()->getDefinition())) {
+        // Initialized without USR and name, this will be set in the following
+        // if-else stmt.
+        BaseRecordInfo BI(
+            {}, "", getInfoRelativePath(Base), B.isVirtual(),
+            getFinalAccessSpecifier(ParentAccess, B.getAccessSpecifier()),
+            IsParent);
+        if (const auto *Ty = B.getType()->getAs<TemplateSpecializationType>()) {
+          const TemplateDecl *D = Ty->getTemplateName().getAsTemplateDecl();
+          BI.USR = getUSRForDecl(D);
+          BI.Name = B.getType().getAsString();
+        } else {
+          BI.USR = getUSRForDecl(Base);
+          BI.Name = Base->getNameAsString();
+        }
+        parseFields(BI, Base, PublicOnly, BI.Access);
+        for (const auto &Decl : Base->decls())
+          if (const auto *MD = dyn_cast<CXXMethodDecl>(Decl)) {
+            // Don't serialize private methods
+            if (MD->getAccessUnsafe() == AccessSpecifier::AS_private ||
+                !MD->isUserProvided())
+              continue;
+            FunctionInfo FI;
+            FI.IsMethod = true;
+            // The seventh arg in populateFunctionInfo is a boolean passed by
+            // reference, its value is not relevant in here so it's not used
+            // anywhere besides the function call.
+            bool IsInAnonymousNamespace;
+            populateFunctionInfo(FI, MD, /*FullComment=*/{}, /*LineNumber=*/{},
+                                 /*FileName=*/{}, IsFileInRootDir,
+                                 IsInAnonymousNamespace);
+            FI.Access =
+                getFinalAccessSpecifier(BI.Access, MD->getAccessUnsafe());
+            BI.ChildFunctions.emplace_back(std::move(FI));
+          }
+        I.Bases.emplace_back(std::move(BI));
+        // Call this function recursively to get the inherited classes of
+        // this base; these new bases will also get stored in the original
+        // RecordInfo: I.
+        parseBases(I, Base, IsFileInRootDir, PublicOnly, false,
+                   I.Bases.back().Access);
+      }
+    }
+  }
+}
+
 std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
 emitInfo(const NamespaceDecl *D, const FullComment *FC, int LineNumber,
          llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
   auto I = llvm::make_unique<NamespaceInfo>();
   bool IsInAnonymousNamespace = false;
   populateInfo(*I, D, FC, IsInAnonymousNamespace);
-  if (PublicOnly && ((IsInAnonymousNamespace || D->isAnonymousNamespace()) ||
-                     !isPublic(D->getAccess(), D->getLinkageInternal())))
+  if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
     return {};
+
   I->Name = D->isAnonymousNamespace()
                 ? llvm::SmallString<16>("@nonymous_namespace")
                 : I->Name;
   I->Path = getInfoRelativePath(I->Namespace);
   if (I->Namespace.empty() && I->USR == SymbolID())
     return {std::unique_ptr<Info>{std::move(I)}, nullptr};
 
   auto ParentI = llvm::make_unique<NamespaceInfo>();
   ParentI->USR = I->Namespace.empty() ? SymbolID() : I->Namespace[0].USR;
   ParentI->ChildNamespaces.emplace_back(I->USR, I->Name, InfoType::IT_namespace,
                                         getInfoRelativePath(I->Namespace));
   if (I->Namespace.empty())
     ParentI->Path = getInfoRelativePath(ParentI->Namespace);
   return {std::unique_ptr<Info>{std::move(I)},
           std::unique_ptr<Info>{std::move(ParentI)}};
 }
 
 std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
 emitInfo(const RecordDecl *D, const FullComment *FC, int LineNumber,
          llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
   auto I = llvm::make_unique<RecordInfo>();
   bool IsInAnonymousNamespace = false;
   populateSymbolInfo(*I, D, FC, LineNumber, File, IsFileInRootDir,
                      IsInAnonymousNamespace);
-  if (PublicOnly && ((IsInAnonymousNamespace ||
-                      !isPublic(D->getAccess(), D->getLinkageInternal()))))
+  if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
     return {};
 
   I->TagType = D->getTagKind();
   parseFields(*I, D, PublicOnly);
   if (const auto *C = dyn_cast<CXXRecordDecl>(D)) {
     if (const TypedefNameDecl *TD = C->getTypedefNameForAnonDecl()) {
       I->Name = TD->getNameAsString();
       I->IsTypeDef = true;
     }
+    // TODO: remove first call to parseBases, that function should be deleted
     parseBases(*I, C);
+    parseBases(*I, C, IsFileInRootDir, PublicOnly, true);
   }
   I->Path = getInfoRelativePath(I->Namespace);
 
   if (I->Namespace.empty()) {
     auto ParentI = llvm::make_unique<NamespaceInfo>();
     ParentI->USR = SymbolID();
     ParentI->ChildRecords.emplace_back(I->USR, I->Name, InfoType::IT_record,
                                        getInfoRelativePath(I->Namespace));

 std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
 emitInfo(const FunctionDecl *D, const FullComment *FC, int LineNumber,
          llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
   FunctionInfo Func;
   bool IsInAnonymousNamespace = false;
   populateFunctionInfo(Func, D, FC, LineNumber, File, IsFileInRootDir,
                        IsInAnonymousNamespace);
   Func.Access = clang::AccessSpecifier::AS_none;
-  if (PublicOnly && ((IsInAnonymousNamespace ||
-                      !isPublic(D->getAccess(), D->getLinkageInternal()))))
+  if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
     return {};
 
   // Wrap in enclosing scope
   auto ParentI = llvm::make_unique<NamespaceInfo>();
   if (!Func.Namespace.empty())
     ParentI->USR = Func.Namespace[0].USR;
   else
     ParentI->USR = SymbolID();
   if (Func.Namespace.empty())
     ParentI->Path = getInfoRelativePath(ParentI->Namespace);
   ParentI->ChildFunctions.emplace_back(std::move(Func));
   // Info is wrapped in its parent scope so it's returned in the second position
   return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
 }
 
 std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
 emitInfo(const CXXMethodDecl *D, const FullComment *FC, int LineNumber,
          llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
   FunctionInfo Func;
   bool IsInAnonymousNamespace = false;
   populateFunctionInfo(Func, D, FC, LineNumber, File, IsFileInRootDir,
                        IsInAnonymousNamespace);
-  if (PublicOnly && ((IsInAnonymousNamespace ||
-                      !isPublic(D->getAccess(), D->getLinkageInternal()))))
+  if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
     return {};
 
   Func.IsMethod = true;
 
   const NamedDecl *Parent = nullptr;
   if (const auto *SD =
           dyn_cast<ClassTemplateSpecializationDecl>(D->getParent()))
     Parent = SD->getSpecializedTemplate();

 
 std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
 emitInfo(const EnumDecl *D, const FullComment *FC, int LineNumber,
          llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
   EnumInfo Enum;
   bool IsInAnonymousNamespace = false;
   populateSymbolInfo(Enum, D, FC, LineNumber, File, IsFileInRootDir,
                      IsInAnonymousNamespace);
-  if (PublicOnly && ((IsInAnonymousNamespace ||
-                      !isPublic(D->getAccess(), D->getLinkageInternal()))))
+  if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
     return {};
 
   Enum.Scoped = D->isScoped();
   parseEnumerators(Enum, D);
 
   // Put in global namespace
   if (Enum.Namespace.empty()) {
     auto ParentI = llvm::make_unique<NamespaceInfo>();

clang-tools-extra/clang-doc/YAMLGenerator.cpp

 
 LLVM_YAML_IS_SEQUENCE_VECTOR(FieldTypeInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(MemberTypeInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(Reference)
 LLVM_YAML_IS_SEQUENCE_VECTOR(Location)
 LLVM_YAML_IS_SEQUENCE_VECTOR(CommentInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(EnumInfo)
+LLVM_YAML_IS_SEQUENCE_VECTOR(BaseRecordInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<CommentInfo>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::SmallString<16>)
 
 namespace llvm {
 namespace yaml {
 
 // Enumerations to YAML output.
 

 }
 
 static void SymbolInfoMapping(IO &IO, SymbolInfo &I) {
   InfoMapping(IO, I);
   IO.mapOptional("DefLocation", I.DefLoc, Optional<Location>());
   IO.mapOptional("Location", I.Loc, llvm::SmallVector<Location, 2>());
 }
 
+static void RecordInfoMapping(IO &IO, RecordInfo &I) {
+  SymbolInfoMapping(IO, I);
+  IO.mapOptional("TagType", I.TagType, clang::TagTypeKind::TTK_Struct);
+  IO.mapOptional("Members", I.Members);
+  IO.mapOptional("Bases", I.Bases);
+  IO.mapOptional("Parents", I.Parents, llvm::SmallVector<Reference, 4>());
+  IO.mapOptional("VirtualParents", I.VirtualParents,
+                 llvm::SmallVector<Reference, 4>());
+  IO.mapOptional("ChildRecords", I.ChildRecords, std::vector<Reference>());
+  IO.mapOptional("ChildFunctions", I.ChildFunctions);
+  IO.mapOptional("ChildEnums", I.ChildEnums);
+}
+
 static void CommentInfoMapping(IO &IO, CommentInfo &I) {
   IO.mapOptional("Kind", I.Kind, SmallString<16>());
   IO.mapOptional("Text", I.Text, SmallString<64>());
   IO.mapOptional("Name", I.Name, SmallString<16>());
   IO.mapOptional("Direction", I.Direction, SmallString<8>());
   IO.mapOptional("ParamName", I.ParamName, SmallString<16>());
   IO.mapOptional("CloseName", I.CloseName, SmallString<16>());
   IO.mapOptional("SelfClosing", I.SelfClosing, false);
IO.mapOptional("ChildNamespaces", I.ChildNamespaces,
                    std::vector<Reference>());
     IO.mapOptional("ChildRecords", I.ChildRecords, std::vector<Reference>());
     IO.mapOptional("ChildFunctions", I.ChildFunctions);
     IO.mapOptional("ChildEnums", I.ChildEnums);
   }
 };
 
 template <> struct MappingTraits<RecordInfo> {
-  static void mapping(IO &IO, RecordInfo &I) {
-    SymbolInfoMapping(IO, I);
-    IO.mapOptional("TagType", I.TagType, clang::TagTypeKind::TTK_Struct);
-    IO.mapOptional("Members", I.Members);
-    IO.mapOptional("Parents", I.Parents, llvm::SmallVector<Reference, 4>());
-    IO.mapOptional("VirtualParents", I.VirtualParents,
-                   llvm::SmallVector<Reference, 4>());
-    IO.mapOptional("ChildRecords", I.ChildRecords, std::vector<Reference>());
-    IO.mapOptional("ChildFunctions", I.ChildFunctions);
-    IO.mapOptional("ChildEnums", I.ChildEnums);
+  static void mapping(IO &IO, RecordInfo &I) { RecordInfoMapping(IO, I); }
+};
+
+template <> struct MappingTraits<BaseRecordInfo> {
+  static void mapping(IO &IO, BaseRecordInfo &I) {
+    RecordInfoMapping(IO, I);
+    IO.mapOptional("IsVirtual", I.IsVirtual, false);
+    // clang::AccessSpecifier::AS_none is used as the default here because it's
+    // the AS that shouldn't be part of the output. Even though AS_public is the
+    // default in the struct, it should be displayed in the YAML output.
+    IO.mapOptional("Access", I.Access, clang::AccessSpecifier::AS_none);
+    IO.mapOptional("IsParent", I.IsParent, false);
   }
 };
 
 template <> struct MappingTraits<EnumInfo> {
   static void mapping(IO &IO, EnumInfo &I) {
     SymbolInfoMapping(IO, I);
     IO.mapOptional("Scoped", I.Scoped, false);
     IO.mapOptional("Members", I.Members);

clang-tools-extra/unittests/clang-doc/BitcodeTest.cpp

TEST(BitcodeTest, emitRecordInfoBitcode) {
   I.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 
   I.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
   I.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"});
 
   I.Members.emplace_back("int", "X", AccessSpecifier::AS_private);
   I.TagType = TagTypeKind::TTK_Class;
   I.IsTypeDef = true;
+  I.Bases.emplace_back(EmptySID, "F", "path/to/F", true,
+                       AccessSpecifier::AS_public, true);
+  I.Bases.back().ChildFunctions.emplace_back();
+  I.Bases.back().Members.emplace_back("int", "X", AccessSpecifier::AS_private);
   I.Parents.emplace_back(EmptySID, "F", InfoType::IT_record);
   I.VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record);
 
   I.ChildRecords.emplace_back(EmptySID, "ChildStruct", InfoType::IT_record);
   I.ChildFunctions.emplace_back();
   I.ChildEnums.emplace_back();
 
   std::string WriteResult = writeInfo(&I);

clang-tools-extra/unittests/clang-doc/ClangDocTest.h

 // This function explicitly does not check USRs, as that may change and it would
 // be better to not rely on its implementation.
 void CheckBaseInfo(Info *Expected, Info *Actual);
 void CheckSymbolInfo(SymbolInfo *Expected, SymbolInfo *Actual);
 void CheckFunctionInfo(FunctionInfo *Expected, FunctionInfo *Actual);
 void CheckEnumInfo(EnumInfo *Expected, EnumInfo *Actual);
 void CheckNamespaceInfo(NamespaceInfo *Expected, NamespaceInfo *Actual);
 void CheckRecordInfo(RecordInfo *Expected, RecordInfo *Actual);
+void CheckBaseRecordInfo(BaseRecordInfo *Expected, BaseRecordInfo *Actual);
 
 void CheckIndex(Index &Expected, Index &Actual);
 
 } // namespace doc
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_DOC_CLANGDOCTEST_H

clang-tools-extra/unittests/clang-doc/ClangDocTest.cpp

 //===-- clang-doc/ClangDocTest.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "ClangDocTest.h"
 #include "Representation.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace doc {
 
 NamespaceInfo *InfoAsNamespace(Info *I) {
void CheckRecordInfo(RecordInfo *Expected, RecordInfo *Actual) {
   ASSERT_EQ(Expected->Parents.size(), Actual->Parents.size());
   for (size_t Idx = 0; Idx < Actual->Parents.size(); ++Idx)
     CheckReference(Expected->Parents[Idx], Actual->Parents[Idx]);
 
   ASSERT_EQ(Expected->VirtualParents.size(), Actual->VirtualParents.size());
   for (size_t Idx = 0; Idx < Actual->VirtualParents.size(); ++Idx)
     CheckReference(Expected->VirtualParents[Idx], Actual->VirtualParents[Idx]);
 
+  ASSERT_EQ(Expected->Bases.size(), Actual->Bases.size());
+  for (size_t Idx = 0; Idx < Actual->Bases.size(); ++Idx)
+    CheckBaseRecordInfo(&Expected->Bases[Idx], &Actual->Bases[Idx]);
+
   ASSERT_EQ(Expected->ChildRecords.size(), Actual->ChildRecords.size());
   for (size_t Idx = 0; Idx < Actual->ChildRecords.size(); ++Idx)
     CheckReference(Expected->ChildRecords[Idx], Actual->ChildRecords[Idx]);
 
   ASSERT_EQ(Expected->ChildFunctions.size(), Actual->ChildFunctions.size());
   for (size_t Idx = 0; Idx < Actual->ChildFunctions.size(); ++Idx)
     CheckFunctionInfo(&Expected->ChildFunctions[Idx],
                       &Actual->ChildFunctions[Idx]);
 
   ASSERT_EQ(Expected->ChildEnums.size(), Actual->ChildEnums.size());
   for (size_t Idx = 0; Idx < Actual->ChildEnums.size(); ++Idx)
     CheckEnumInfo(&Expected->ChildEnums[Idx], &Actual->ChildEnums[Idx]);
 }
 
+void CheckBaseRecordInfo(BaseRecordInfo *Expected, BaseRecordInfo *Actual) {
+  CheckRecordInfo(Expected, Actual);
+
+  EXPECT_EQ(Expected->IsVirtual, Actual->IsVirtual);
+  EXPECT_EQ(Expected->Access, Actual->Access);
+  EXPECT_EQ(Expected->IsParent, Actual->IsParent);
+}
+
 void CheckIndex(Index &Expected, Index &Actual) {
   CheckReference(Expected, Actual);
   ASSERT_EQ(Expected.Children.size(), Actual.Children.size());
   for (size_t Idx = 0; Idx < Actual.Children.size(); ++Idx)
     CheckIndex(Expected.Children[Idx], Actual.Children[Idx]);
 }
 
 } // namespace doc
 } // namespace clang

clang-tools-extra/unittests/clang-doc/MergeTest.cpp

TEST(MergeTest, mergeRecordInfos) {
 
   One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
 
   One.Members.emplace_back("int", "X", AccessSpecifier::AS_private);
   One.TagType = TagTypeKind::TTK_Class;
   One.Parents.emplace_back(EmptySID, "F", InfoType::IT_record);
   One.VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record);
 
+  One.Bases.emplace_back(EmptySID, "F", "path/to/F", true,
+                         AccessSpecifier::AS_protected, true);
   One.ChildRecords.emplace_back(NonEmptySID, "SharedChildStruct",
                                 InfoType::IT_record);
   One.ChildFunctions.emplace_back();
   One.ChildFunctions.back().Name = "OneFunction";
   One.ChildFunctions.back().USR = NonEmptySID;
   One.ChildEnums.emplace_back();
   One.ChildEnums.back().Name = "OneEnum";
   One.ChildEnums.back().USR = NonEmptySID;
TEST(MergeTest, mergeRecordInfos) {
 
   Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
   Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"});
 
   Expected->Members.emplace_back("int", "X", AccessSpecifier::AS_private);
   Expected->TagType = TagTypeKind::TTK_Class;
   Expected->Parents.emplace_back(EmptySID, "F", InfoType::IT_record);
   Expected->VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record);
+  Expected->Bases.emplace_back(EmptySID, "F", "path/to/F", true,
+                               AccessSpecifier::AS_protected, true);
 
   Expected->ChildRecords.emplace_back(NonEmptySID, "SharedChildStruct",
                                       InfoType::IT_record, "path");
   Expected->ChildFunctions.emplace_back();
   Expected->ChildFunctions.back().Name = "OneFunction";
   Expected->ChildFunctions.back().USR = NonEmptySID;
   Expected->ChildFunctions.emplace_back();
   Expected->ChildFunctions.back().Name = "TwoFunction";

clang-tools-extra/unittests/clang-doc/SerializeTest.cpp

TEST(SerializeTest, emitInlinedFunctionInfo) {
   F.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
   F.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   F.Params.emplace_back("int", "I");
   F.Access = AccessSpecifier::AS_none;
   ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 }
 
-TEST(SerializeTest, ) {
+TEST(SerializeTest, emitInheritedRecordInfo) {
   EmittedInfoList Infos;
-  ExtractInfosFromCode(R"raw(class F {};
-class G {} ;
+  ExtractInfosFromCode(R"raw(class F { protected: void set(int N); };
+class G { public: int get() { return 1; } protected: int I; };
 class E : public F, virtual private G {};
+class H : private E {};
 template <typename T>
-class H {} ;
-class I : public H<int> {} ;)raw",
-                       10, /*Public=*/false, Infos);
+class I {} ;
+class J : public I<int> {} ;)raw",
+                       14, /*Public=*/false, Infos);
 
   RecordInfo *F = InfoAsRecord(Infos[0].get());
   RecordInfo ExpectedF(EmptySID, "F");
   ExpectedF.TagType = TagTypeKind::TTK_Class;
   ExpectedF.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   CheckRecordInfo(&ExpectedF, F);
 
-  RecordInfo *G = InfoAsRecord(Infos[2].get());
+  RecordInfo *G = InfoAsRecord(Infos[3].get());
   RecordInfo ExpectedG(EmptySID, "G");
   ExpectedG.TagType = TagTypeKind::TTK_Class;
   ExpectedG.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
+  ExpectedG.Members.emplace_back("int", "I", AccessSpecifier::AS_protected);
   CheckRecordInfo(&ExpectedG, G);
 
-  RecordInfo *E = InfoAsRecord(Infos[4].get());
+  RecordInfo *E = InfoAsRecord(Infos[6].get());
   RecordInfo ExpectedE(EmptySID, "E");
   ExpectedE.Parents.emplace_back(EmptySID, "F", InfoType::IT_record);
   ExpectedE.VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record);
+  ExpectedE.Bases.emplace_back(EmptySID, "F", "", false,
+                               AccessSpecifier::AS_public, true);
+  FunctionInfo FunctionSet;
+  FunctionSet.Name = "set";
+  FunctionSet.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  FunctionSet.Loc.emplace_back();
+  FunctionSet.Params.emplace_back("int", "N");
+  FunctionSet.Namespace.emplace_back(EmptySID, "F", InfoType::IT_record);
+  FunctionSet.Access = AccessSpecifier::AS_protected;
+  FunctionSet.IsMethod = true;
+  ExpectedE.Bases.back().ChildFunctions.emplace_back(std::move(FunctionSet));
+  ExpectedE.Bases.emplace_back(EmptySID, "G", "", true,
+                               AccessSpecifier::AS_private, true);
+  FunctionInfo FunctionGet;
+  FunctionGet.Name = "get";
+  FunctionGet.ReturnType = TypeInfo(EmptySID, "int", InfoType::IT_default);
+  FunctionGet.DefLoc = Location();
+  FunctionGet.Namespace.emplace_back(EmptySID, "G", InfoType::IT_record);
+  FunctionGet.Access = AccessSpecifier::AS_private;
+  FunctionGet.IsMethod = true;
+  ExpectedE.Bases.back().ChildFunctions.emplace_back(std::move(FunctionGet));
+  ExpectedE.Bases.back().Members.emplace_back("int", "I",
+                                              AccessSpecifier::AS_private);
   ExpectedE.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   ExpectedE.TagType = TagTypeKind::TTK_Class;
   CheckRecordInfo(&ExpectedE, E);
 
-  RecordInfo *H = InfoAsRecord(Infos[6].get());
+  RecordInfo *H = InfoAsRecord(Infos[8].get());
   RecordInfo ExpectedH(EmptySID, "H");
   ExpectedH.TagType = TagTypeKind::TTK_Class;
   ExpectedH.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
+  ExpectedH.Parents.emplace_back(EmptySID, "E", InfoType::IT_record);
+  ExpectedH.VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record);
+  ExpectedH.Bases.emplace_back(EmptySID, "E", "", false,
+                               AccessSpecifier::AS_private, true);
+  ExpectedH.Bases.emplace_back(EmptySID, "F", "", false,
+                               AccessSpecifier::AS_private, false);
+  FunctionInfo FunctionSetNew;
+  FunctionSetNew.Name = "set";
+  FunctionSetNew.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  FunctionSetNew.Loc.emplace_back();
+  FunctionSetNew.Params.emplace_back("int", "N");
+  FunctionSetNew.Namespace.emplace_back(EmptySID, "F", InfoType::IT_record);
+  FunctionSetNew.Access = AccessSpecifier::AS_private;
+  FunctionSetNew.IsMethod = true;
+  ExpectedH.Bases.back().ChildFunctions.emplace_back(std::move(FunctionSetNew));
+  ExpectedH.Bases.emplace_back(EmptySID, "G", "", true,
+                               AccessSpecifier::AS_private, false);
+  FunctionInfo FunctionGetNew;
+  FunctionGetNew.Name = "get";
+  FunctionGetNew.ReturnType = TypeInfo(EmptySID, "int", InfoType::IT_default);
+  FunctionGetNew.DefLoc = Location();
+  FunctionGetNew.Namespace.emplace_back(EmptySID, "G", InfoType::IT_record);
+  FunctionGetNew.Access = AccessSpecifier::AS_private;
+  FunctionGetNew.IsMethod = true;
+  ExpectedH.Bases.back().ChildFunctions.emplace_back(std::move(FunctionGetNew));
+  ExpectedH.Bases.back().Members.emplace_back("int", "I",
+                                              AccessSpecifier::AS_private);
   CheckRecordInfo(&ExpectedH, H);
 
-  RecordInfo *I = InfoAsRecord(Infos[8].get());
+  RecordInfo *I = InfoAsRecord(Infos[10].get());
   RecordInfo ExpectedI(EmptySID, "I");
-  ExpectedI.Parents.emplace_back(EmptySID, "H<int>", InfoType::IT_record);
-  ExpectedI.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   ExpectedI.TagType = TagTypeKind::TTK_Class;
+  ExpectedI.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   CheckRecordInfo(&ExpectedI, I);
+
+  RecordInfo *J = InfoAsRecord(Infos[12].get());
+  RecordInfo ExpectedJ(EmptySID, "J");
+  ExpectedJ.Parents.emplace_back(EmptySID, "I<int>", InfoType::IT_record);
+  ExpectedJ.Bases.emplace_back(EmptySID, "I<int>", "", false,
+                               AccessSpecifier::AS_public, true);
+  ExpectedJ.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
+  ExpectedJ.TagType = TagTypeKind::TTK_Class;
+  CheckRecordInfo(&ExpectedJ, J);
 }
 
 TEST(SerializeTest, emitModulePublicLFunctions) {
   EmittedInfoList Infos;
   std::vector<std::string> Args;
   Args.push_back("-fmodules-ts");
   ExtractInfosFromCodeWithArgs(R"raw(export module M;
 int moduleFunction(int x);

clang-tools-extra/unittests/clang-doc/YAMLGeneratorTest.cpp

TEST(YAMLGeneratorTest, emitRecordYAML) {
   I.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 
   I.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
   I.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"});
 
   I.Members.emplace_back("int", "path/to/int", "X",
                          AccessSpecifier::AS_private);
   I.TagType = TagTypeKind::TTK_Class;
+  I.Bases.emplace_back(EmptySID, "F", "path/to/F", true,
+                       AccessSpecifier::AS_public, true);
+  I.Bases.back().ChildFunctions.emplace_back();
+  I.Bases.back().ChildFunctions.back().Name = "InheritedFunctionOne";
+  I.Bases.back().Members.emplace_back("int", "path/to/int", "N",
+                                      AccessSpecifier::AS_private);
   // F is in the global namespace
   I.Parents.emplace_back(EmptySID, "F", InfoType::IT_record, "");
   I.VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record,
                                 "path/to/G");
 
   I.ChildRecords.emplace_back(EmptySID, "ChildStruct", InfoType::IT_record,
                               "path/to/A/r");
   I.ChildFunctions.emplace_back();
- LineNumber:      12
     Filename:        'test.cpp'
 TagType:         Class
 Members:
   - Type:
       Name:            'int'
       Path:            'path/to/int'
     Name:            'X'
     Access:          Private
+Bases:
+  - USR:             '0000000000000000000000000000000000000000'
+    Name:            'F'
+    Path:            'path/to/F'
+    Members:
+      - Type:
+          Name:            'int'
+          Path:            'path/to/int'
+        Name:            'N'
+        Access:          Private
+    ChildFunctions:
+      - USR:             '0000000000000000000000000000000000000000'
+        Name:            'InheritedFunctionOne'
+        ReturnType:      {}
+        Access:          Public
+    IsVirtual:       true
+    Access:          Public
+    IsParent:        true
 Parents:
   - Type:            Record
     Name:            'F'
     IsInGlobalNamespace: true
 VirtualParents:
   - Type:            Record
     Name:            'G'
     Path:            'path/to/G'