[clang-doc] Attaching a name to reference data

[juliehockett]

Summary

This adds the name of the referenced decl, in addition to its USR, to the saved data, so that the backend can look at an info in isolation and still be able to construct a human-readable name for it.

[lebedev.ri]

clang-doc/BitcodeWriter.cpp

278

1. I'm not seeing where this is being changed?
2. This looks like some abstraction is missing. Maybe at least put it as private member of ClangDocBitcodeWriter?

clang-doc/BitcodeWriter.h

34

Looking at the changes, may want to bump the version.

62–64

General observation: you could keep BI_LAST element as the last one in the enum (just like the rest,
without specifying it's value), and use it just like the end(), i.e. v < BI_LAST instead of v <= BI_LAST.

[juliehockett]

Addressing comments

[lebedev.ri]

Global question: you are using NamedDecl::getNameAsString(), and passing it as StringRef.
You have looked at this with ASAN, and it's ok?

Also, have you considered using the NamedDecl::getName(), which already returns StringRef.?

clang-doc/Serialize.cpp

184

This change from InfoType::IT_record is intentional?

201–217

This very closely matches the parseFields(), with a few changes (I.Params vs I.Members,
getUSRForDecl(T) vs getUSRForDecl(N), F->getQualifiedNameAsString() vs P->getQualifiedNameAsString()).
If it makes sense, it might be a good idea to refactor them together?

[lebedev.ri]

clang-doc/BitcodeWriter.cpp

382

In D46281#1083806, @lebedev.ri wrote:

Global question: you are using NamedDecl::getNameAsString(), and passing it as StringRef.
You have looked at this with ASAN, and it's ok?

Also, have you considered using the NamedDecl::getName(), which already returns StringRef.?

Hm, looking at those two functions, not sure NamedDecl::getName() will work here.
Alternatively, have you considered just making this Name field store DeclarationName,
and call getNameAsString() only here?

[juliehockett]

Addressing a fixme and updating tests

clang-doc/BitcodeWriter.cpp

382

The field stores it as a string? So the name string is copied into the info data structure itself -- this is so that the backend need have no knowledge of the AST to do its job.

clang-doc/Serialize.cpp

201–217

So the fixme in parseFields was the main difference -- I fixed it, and they are subtly different (that is, parseFields adds a MemberTypeInfo with an access attached to it, where as parseParameters adds a FieldTypeInfo without the access attached). Also, the way to get the information we want from a ParmVarDecl is slightly different from how you get it from a FieldDecl.

[lebedev.ri]

I can't really comment on the BC change since i don't think anything
here makes use of that yet, but the code changes look ok to me.

LGTM.

clang-doc/BitcodeWriter.cpp

382

Oh i see, forgot about that.

clang-doc/BitcodeWriter.h

146

There is llvm::SmallDenseMap, apparently. Not sure if it helps here.

[lebedev.ri]

clang-doc/BitcodeWriter.cpp

382

One more thing to consider, then: does it always receive std::string?
(from getNameAsString() and others, maybe).

If yes, maybe it would be simpler, more efficient (Since you could std::move() it,
no copying/allocating needed.) to just store the std::string itself.

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 = 1;
+static const unsigned VersionNumber = 2;
 
 struct BitCodeConstants {
   static constexpr unsigned RecordSize = 16U;
   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_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_FUNCTION_BLOCK_ID,
   BI_COMMENT_BLOCK_ID,
-  BI_FIRST = BI_VERSION_BLOCK_ID,
-  BI_LAST = 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
 // initialization list in the implementation file.
-#define INFORECORDS(X) X##_USR, X##_NAME, X##_NAMESPACE
+#define INFORECORDS(X) X##_USR, X##_NAME
 
 enum RecordId {
   VERSION = 1,
   INFORECORDS(FUNCTION),
   FUNCTION_DEFLOCATION,
   FUNCTION_LOCATION,
-  FUNCTION_PARENT,
   FUNCTION_ACCESS,
   FUNCTION_IS_METHOD,
   COMMENT_KIND,
   COMMENT_TEXT,
   COMMENT_NAME,
   COMMENT_DIRECTION,
   COMMENT_PARAMNAME,
   COMMENT_CLOSENAME,
   COMMENT_SELFCLOSING,
   COMMENT_EXPLICIT,
   COMMENT_ATTRKEY,
   COMMENT_ATTRVAL,
   COMMENT_ARG,
-  TYPE_REF,
-  FIELD_TYPE_REF,
   FIELD_TYPE_NAME,
-  MEMBER_TYPE_REF,
   MEMBER_TYPE_NAME,
   MEMBER_TYPE_ACCESS,
   INFORECORDS(NAMESPACE),
   INFORECORDS(ENUM),
   ENUM_DEFLOCATION,
   ENUM_LOCATION,
   ENUM_MEMBER,
   ENUM_SCOPED,
   INFORECORDS(RECORD),
   RECORD_DEFLOCATION,
   RECORD_LOCATION,
   RECORD_TAG_TYPE,
-  RECORD_PARENT,
-  RECORD_VPARENT,
-  RI_FIRST = VERSION,
-  RI_LAST = RECORD_VPARENT
+  REFERENCE_USR,
+  REFERENCE_NAME,
+  REFERENCE_TYPE,
+  REFERENCE_FIELD,
+  RI_LAST,
+  RI_FIRST = VERSION
 };
 
-static constexpr unsigned BlockIdCount = BI_LAST - BI_FIRST + 1;
-static constexpr unsigned RecordIdCount = RI_LAST - RI_FIRST + 1;
+static constexpr unsigned BlockIdCount = BI_LAST - BI_FIRST;
+static constexpr unsigned RecordIdCount = RI_LAST - RI_FIRST;
 
 #undef INFORECORDS
 
+// Identifiers for differentiating between subblocks
+enum class FieldId { F_namespace = 1, F_parent, F_vparent, F_type };
+
 class ClangDocBitcodeWriter {
 public:
   ClangDocBitcodeWriter(llvm::BitstreamWriter &Stream) : Stream(Stream) {
     emitHeader();
     emitBlockInfoBlock();
     emitVersionBlock();
   }
 
 #ifndef NDEBUG // Don't want explicit dtor unless needed.
   ~ClangDocBitcodeWriter() {
     // Check that the static size is large-enough.
     assert(Record.capacity() > BitCodeConstants::RecordSize);
   }
 #endif
 
   // Block emission of different info types.
   void emitBlock(const NamespaceInfo &I);
   void emitBlock(const RecordInfo &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);
 
 private:
   class AbbreviationMap {
     llvm::DenseMap<unsigned, unsigned> Abbrevs;
 
   public:
     AbbreviationMap() : Abbrevs(RecordIdCount) {}
 
     void add(RecordId RID, unsigned AbbrevID);
     unsigned get(RecordId RID) const;
   };
 

clang-doc/BitcodeWriter.cpp

 //===--  BitcodeWriter.cpp - ClangDoc Bitcode Writer ------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BitcodeWriter.h"
 #include "llvm/ADT/IndexedMap.h"
 #include <initializer_list>
 
 namespace clang {
 namespace doc {
 
+// Empty SymbolID for comparison, so we don't have to construct one every time.
+static const SymbolID EmptySID = SymbolID();
+
 // Since id enums are not zero-indexed, we need to transform the given id into
 // its associated index.
 struct BlockIdToIndexFunctor {
   using argument_type = unsigned;
   unsigned operator()(unsigned ID) const { return ID - BI_FIRST; }
 };
 
 struct RecordIdToIndexFunctor {
AbbrevGen(
                              BitCodeConstants::LineNumberSize),
        // 1. Fixed-size integer (length of the following string (filename))
        llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
                              BitCodeConstants::StringLengthSize),
        // 2. The string blob
        llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
 }
 
-static void ReferenceAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
-  AbbrevGen(Abbrev,
-            {// 0. Fixed-size integer (ref type)
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                                   BitCodeConstants::ReferenceTypeSize),
-             // 1. Fixed-size integer (length of the USR or UnresolvedName)
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                                   BitCodeConstants::StringLengthSize),
-             // 2. The string blob
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
-}
-
 struct RecordIdDsc {
   llvm::StringRef Name;
   AbbrevDsc Abbrev = nullptr;
 
   RecordIdDsc() = default;
   RecordIdDsc(llvm::StringRef Name, AbbrevDsc Abbrev)
       : Name(Name), Abbrev(Abbrev) {}
 
BlockIdNameMap = []() {
           {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_FUNCTION_BLOCK_ID, "FunctionBlock"},
-          {BI_COMMENT_BLOCK_ID, "CommentBlock"}};
+          {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;
     }();
 
 static const llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor>
RecordIdNameMap = []() {
           {COMMENT_DIRECTION, {"Direction", &StringAbbrev}},
           {COMMENT_PARAMNAME, {"ParamName", &StringAbbrev}},
           {COMMENT_CLOSENAME, {"CloseName", &StringAbbrev}},
           {COMMENT_SELFCLOSING, {"SelfClosing", &BoolAbbrev}},
           {COMMENT_EXPLICIT, {"Explicit", &BoolAbbrev}},
           {COMMENT_ATTRKEY, {"AttrKey", &StringAbbrev}},
           {COMMENT_ATTRVAL, {"AttrVal", &StringAbbrev}},
           {COMMENT_ARG, {"Arg", &StringAbbrev}},
-          {TYPE_REF, {"Type", &ReferenceAbbrev}},
-          {FIELD_TYPE_REF, {"Type", &ReferenceAbbrev}},
           {FIELD_TYPE_NAME, {"Name", &StringAbbrev}},
-          {MEMBER_TYPE_REF, {"Type", &ReferenceAbbrev}},
           {MEMBER_TYPE_NAME, {"Name", &StringAbbrev}},
           {MEMBER_TYPE_ACCESS, {"Access", &IntAbbrev}},
           {NAMESPACE_USR, {"USR", &SymbolIDAbbrev}},
           {NAMESPACE_NAME, {"Name", &StringAbbrev}},
-          {NAMESPACE_NAMESPACE, {"Namespace", &ReferenceAbbrev}},
           {ENUM_USR, {"USR", &SymbolIDAbbrev}},
           {ENUM_NAME, {"Name", &StringAbbrev}},
-          {ENUM_NAMESPACE, {"Namespace", &ReferenceAbbrev}},
           {ENUM_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
           {ENUM_LOCATION, {"Location", &LocationAbbrev}},
           {ENUM_MEMBER, {"Member", &StringAbbrev}},
           {ENUM_SCOPED, {"Scoped", &BoolAbbrev}},
           {RECORD_USR, {"USR", &SymbolIDAbbrev}},
           {RECORD_NAME, {"Name", &StringAbbrev}},
-          {RECORD_NAMESPACE, {"Namespace", &ReferenceAbbrev}},
           {RECORD_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
           {RECORD_LOCATION, {"Location", &LocationAbbrev}},
           {RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
-          {RECORD_PARENT, {"Parent", &ReferenceAbbrev}},
-          {RECORD_VPARENT, {"VParent", &ReferenceAbbrev}},
           {FUNCTION_USR, {"USR", &SymbolIDAbbrev}},
           {FUNCTION_NAME, {"Name", &StringAbbrev}},
-          {FUNCTION_NAMESPACE, {"Namespace", &ReferenceAbbrev}},
           {FUNCTION_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
           {FUNCTION_LOCATION, {"Location", &LocationAbbrev}},
-          {FUNCTION_PARENT, {"Parent", &ReferenceAbbrev}},
           {FUNCTION_ACCESS, {"Access", &IntAbbrev}},
-          {FUNCTION_IS_METHOD, {"IsMethod", &BoolAbbrev}}};
+          {FUNCTION_IS_METHOD, {"IsMethod", &BoolAbbrev}},
+          {REFERENCE_USR, {"USR", &SymbolIDAbbrev}},
+          {REFERENCE_NAME, {"Name", &StringAbbrev}},
+          {REFERENCE_TYPE, {"RefType", &IntAbbrev}},
+          {REFERENCE_FIELD, {"Field", &IntAbbrev}}};
       assert(Inits.size() == RecordIdCount);
       for (const auto &Init : Inits) {
         RecordIdNameMap[Init.first] = Init.second;
         assert((Init.second.Name.size() + 1) <= BitCodeConstants::RecordSize);
       }
       assert(RecordIdNameMap.size() == RecordIdCount);
       return RecordIdNameMap;
     }();
 
 static const std::vector<std::pair<BlockId, std::vector<RecordId>>>
     RecordsByBlock{
         // Version Block
         {BI_VERSION_BLOCK_ID, {VERSION}},
         // Comment Block
         {BI_COMMENT_BLOCK_ID,
          {COMMENT_KIND, COMMENT_TEXT, COMMENT_NAME, COMMENT_DIRECTION,
           COMMENT_PARAMNAME, COMMENT_CLOSENAME, COMMENT_SELFCLOSING,
           COMMENT_EXPLICIT, COMMENT_ATTRKEY, COMMENT_ATTRVAL, COMMENT_ARG}},
         // Type Block
-        {BI_TYPE_BLOCK_ID, {TYPE_REF}},
+        {BI_TYPE_BLOCK_ID, {}},
         // FieldType Block
-        {BI_FIELD_TYPE_BLOCK_ID, {FIELD_TYPE_REF, FIELD_TYPE_NAME}},
+        {BI_FIELD_TYPE_BLOCK_ID, {FIELD_TYPE_NAME}},
         // MemberType Block
-        {BI_MEMBER_TYPE_BLOCK_ID,
-         {MEMBER_TYPE_REF, MEMBER_TYPE_NAME, MEMBER_TYPE_ACCESS}},
+        {BI_MEMBER_TYPE_BLOCK_ID, {MEMBER_TYPE_NAME, MEMBER_TYPE_ACCESS}},
         // Enum Block
         {BI_ENUM_BLOCK_ID,
-         {ENUM_USR, ENUM_NAME, ENUM_NAMESPACE, ENUM_DEFLOCATION, ENUM_LOCATION,
-          ENUM_MEMBER, ENUM_SCOPED}},
+         {ENUM_USR, ENUM_NAME, ENUM_DEFLOCATION, ENUM_LOCATION, ENUM_MEMBER,
+          ENUM_SCOPED}},
         // Namespace Block
-        {BI_NAMESPACE_BLOCK_ID,
-         {NAMESPACE_USR, NAMESPACE_NAME, NAMESPACE_NAMESPACE}},
+        {BI_NAMESPACE_BLOCK_ID, {NAMESPACE_USR, NAMESPACE_NAME}},
         // Record Block
         {BI_RECORD_BLOCK_ID,
-         {RECORD_USR, RECORD_NAME, RECORD_NAMESPACE, RECORD_DEFLOCATION,
-          RECORD_LOCATION, RECORD_TAG_TYPE, RECORD_PARENT, RECORD_VPARENT}},
+         {RECORD_USR, RECORD_NAME, RECORD_DEFLOCATION, RECORD_LOCATION,
+          RECORD_TAG_TYPE}},
         // Function Block
         {BI_FUNCTION_BLOCK_ID,
-         {FUNCTION_USR, FUNCTION_NAME, FUNCTION_NAMESPACE, FUNCTION_DEFLOCATION,
-          FUNCTION_LOCATION, FUNCTION_PARENT, FUNCTION_ACCESS,
-          FUNCTION_IS_METHOD}}};
+         {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_FIELD}}};
 
 // AbbreviationMap
 
 void ClangDocBitcodeWriter::AbbreviationMap::add(RecordId RID,
                                                  unsigned AbbrevID) {
   assert(RecordIdNameMap[RID] && "Unknown RecordId.");
   assert(Abbrevs.find(RID) == Abbrevs.end() && "Abbreviation already added.");
   Abbrevs[RID] = AbbrevID;
void ClangDocBitcodeWriter::emitAbbrev(RecordId ID, BlockId Block) {
   auto Abbrev = std::make_shared<llvm::BitCodeAbbrev>();
   Abbrev->Add(llvm::BitCodeAbbrevOp(ID));
   RecordIdNameMap[ID].Abbrev(Abbrev);
   Abbrevs.add(ID, Stream.EmitBlockInfoAbbrev(Block, std::move(Abbrev)));
 }
 
 // Records
 
 void ClangDocBitcodeWriter::emitRecord(const SymbolID &Sym, RecordId ID) {
   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
   assert(RecordIdNameMap[ID].Abbrev == &SymbolIDAbbrev &&
          "Abbrev type mismatch.");
-  if (!prepRecordData(ID, !Sym.empty()))
+  if (!prepRecordData(ID, Sym != EmptySID))
     return;
   assert(Sym.size() == 20);
   Record.push_back(Sym.size());
   Record.append(Sym.begin(), Sym.end());
   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
 }
 
 void ClangDocBitcodeWriter::emitRecord(llvm::StringRef Str, RecordId ID) {
void ClangDocBitcodeWriter::emitRecord(const Location &Loc, RecordId ID) {
   Record.push_back(Loc.LineNumber);
   assert(Loc.Filename.size() < (1U << BitCodeConstants::StringLengthSize));
   // Record.push_back(Loc.Filename.size());
   // Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Loc.Filename);
   Record.push_back(4);
   Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, "test");
 }
 
-void ClangDocBitcodeWriter::emitRecord(const Reference &Ref, RecordId ID) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  assert(RecordIdNameMap[ID].Abbrev == &ReferenceAbbrev &&
-         "Abbrev type mismatch.");
-  SmallString<40> StringUSR;
-  StringRef OutString;
-  if (Ref.RefType == InfoType::IT_default)
-    OutString = Ref.UnresolvedName;
-  else {
-    StringUSR = llvm::toHex(llvm::toStringRef(Ref.USR));
-    OutString = StringUSR;
-  }
-  if (!prepRecordData(ID, !OutString.empty()))
-    return;
-  assert(OutString.size() < (1U << BitCodeConstants::StringLengthSize));
-  Record.push_back((int)Ref.RefType);
-  Record.push_back(OutString.size());
-  Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, OutString);
-}
-
 void ClangDocBitcodeWriter::emitRecord(bool Val, RecordId ID) {
   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
   assert(RecordIdNameMap[ID].Abbrev == &BoolAbbrev && "Abbrev type mismatch.");
   if (!prepRecordData(ID, Val))
     return;
   Record.push_back(Val);
   Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
 }
void ClangDocBitcodeWriter::emitBlockInfo(BlockId BID,
   for (RecordId RID : RIDs) {
     emitRecordID(RID);
     emitAbbrev(RID, BID);
   }
 }
 
 // Block emission
 
+void ClangDocBitcodeWriter::emitBlock(const Reference &R, FieldId Field) {
+  if (R.USR == EmptySID && R.Name.empty())
+    return;
+  StreamSubBlockGuard Block(Stream, BI_REFERENCE_BLOCK_ID);
+  emitRecord(R.USR, REFERENCE_USR);
+  emitRecord(R.Name, REFERENCE_NAME);
+  emitRecord((unsigned)R.RefType, REFERENCE_TYPE);
+  emitRecord((unsigned)Field, REFERENCE_FIELD);
+}
+
 void ClangDocBitcodeWriter::emitBlock(const TypeInfo &T) {
   StreamSubBlockGuard Block(Stream, BI_TYPE_BLOCK_ID);
-  emitRecord(T.Type, TYPE_REF);
+  emitBlock(T.Type, FieldId::F_type);
 }
 
 void ClangDocBitcodeWriter::emitBlock(const FieldTypeInfo &T) {
   StreamSubBlockGuard Block(Stream, BI_FIELD_TYPE_BLOCK_ID);
-  emitRecord(T.Type, FIELD_TYPE_REF);
+  emitBlock(T.Type, FieldId::F_type);
   emitRecord(T.Name, FIELD_TYPE_NAME);
 }
 
 void ClangDocBitcodeWriter::emitBlock(const MemberTypeInfo &T) {
   StreamSubBlockGuard Block(Stream, BI_MEMBER_TYPE_BLOCK_ID);
-  emitRecord(T.Type, MEMBER_TYPE_REF);
+  emitBlock(T.Type, FieldId::F_type);
   emitRecord(T.Name, MEMBER_TYPE_NAME);
   emitRecord(T.Access, MEMBER_TYPE_ACCESS);
 }
 
 void ClangDocBitcodeWriter::emitBlock(const CommentInfo &I) {
   StreamSubBlockGuard Block(Stream, BI_COMMENT_BLOCK_ID);
-  for (const auto &L :
-       std::vector<std::pair<llvm::StringRef, RecordId>>{
+  for (const auto &L : std::vector<std::pair<llvm::StringRef, RecordId>>{
            {I.Kind, COMMENT_KIND},
            {I.Text, COMMENT_TEXT},
            {I.Name, COMMENT_NAME},
            {I.Direction, COMMENT_DIRECTION},
            {I.ParamName, COMMENT_PARAMNAME},
            {I.CloseName, COMMENT_CLOSENAME}})
     emitRecord(L.first, L.second);
   emitRecord(I.SelfClosing, COMMENT_SELFCLOSING);
   emitRecord(I.Explicit, COMMENT_EXPLICIT);
   for (const auto &A : I.AttrKeys)
     emitRecord(A, COMMENT_ATTRKEY);
   for (const auto &A : I.AttrValues)
     emitRecord(A, COMMENT_ATTRVAL);
   for (const auto &A : I.Args)
     emitRecord(A, COMMENT_ARG);
   for (const auto &C : I.Children)
     emitBlock(*C);
 }
 
 #define EMITINFO(X)                                                            \
   emitRecord(I.USR, X##_USR);                                                  \
   emitRecord(I.Name, X##_NAME);                                                \
   for (const auto &N : I.Namespace)                                            \
-    emitRecord(N, X##_NAMESPACE);                                              \
+    emitBlock(N, FieldId::F_namespace);                                        \
   for (const auto &CI : I.Description)                                         \
     emitBlock(CI);
 
 void ClangDocBitcodeWriter::emitBlock(const NamespaceInfo &I) {
   StreamSubBlockGuard Block(Stream, BI_NAMESPACE_BLOCK_ID);
   EMITINFO(NAMESPACE)
 }
 
void ClangDocBitcodeWriter::emitBlock(const RecordInfo &I) {
   if (I.DefLoc)
     emitRecord(I.DefLoc.getValue(), RECORD_DEFLOCATION);
   for (const auto &L : I.Loc)
     emitRecord(L, RECORD_LOCATION);
   emitRecord(I.TagType, RECORD_TAG_TYPE);
   for (const auto &N : I.Members)
     emitBlock(N);
   for (const auto &P : I.Parents)
-    emitRecord(P, RECORD_PARENT);
+    emitBlock(P, FieldId::F_parent);
   for (const auto &P : I.VirtualParents)
-    emitRecord(P, RECORD_VPARENT);
+    emitBlock(P, FieldId::F_vparent);
 }
 
 void ClangDocBitcodeWriter::emitBlock(const FunctionInfo &I) {
   StreamSubBlockGuard Block(Stream, BI_FUNCTION_BLOCK_ID);
   EMITINFO(FUNCTION)
   emitRecord(I.IsMethod, FUNCTION_IS_METHOD);
   if (I.DefLoc)
     emitRecord(I.DefLoc.getValue(), FUNCTION_DEFLOCATION);
   for (const auto &L : I.Loc)
     emitRecord(L, FUNCTION_LOCATION);
-  emitRecord(I.Parent, FUNCTION_PARENT);
+  emitBlock(I.Parent, FieldId::F_parent);
   emitBlock(I.ReturnType);
   for (const auto &N : I.Params)
     emitBlock(N);
 }
 
 #undef EMITINFO
 
 } // namespace doc
 } // namespace clang

clang-doc/Representation.h

 
 namespace clang {
 namespace doc {
 
 using SymbolID = std::array<uint8_t, 20>;
 
 struct Info;
 enum class InfoType {
+  IT_default,
   IT_namespace,
   IT_record,
   IT_function,
-  IT_enum,
-  IT_default
+  IT_enum
 };
 
 // A representation of a parsed comment.
 struct CommentInfo {
   CommentInfo() = default;
   CommentInfo(CommentInfo &&Other) : Children(std::move(Other.Children)) {}
 
-  SmallString<16>
-      Kind; // Kind of comment (TextComment, InlineCommandComment,
-            // HTMLStartTagComment, HTMLEndTagComment, BlockCommandComment,
-            // ParamCommandComment, TParamCommandComment, VerbatimBlockComment,
+  SmallString<16> Kind; // Kind of comment (TextComment, InlineCommandComment,
+                        // HTMLStartTagComment, HTMLEndTagComment,
+                        // BlockCommandComment, ParamCommandComment,
+                        // TParamCommandComment, VerbatimBlockComment,
                         // VerbatimBlockLineComment, VerbatimLineComment).
-  SmallString<64> Text;      // Text of the comment.
-  SmallString<16> Name;      // Name of the comment (for Verbatim and HTML).
+  SmallString<64> Text; // Text of the comment.
+  SmallString<16> Name; // Name of the comment (for Verbatim and HTML).
   SmallString<8> Direction;  // Parameter direction (for (T)ParamCommand).
   SmallString<16> ParamName; // Parameter name (for (T)ParamCommand).
   SmallString<16> CloseName; // Closing tag name (for VerbatimBlock).
   bool SelfClosing = false;  // Indicates if tag is self-closing (for HTML).
   bool Explicit = false; // Indicates if the direction of a param is explicit
                          // (for (T)ParamCommand).
   llvm::SmallVector<SmallString<16>, 4>
       AttrKeys; // List of attribute keys (for HTML).
   llvm::SmallVector<SmallString<16>, 4>
       AttrValues; // List of attribute values for each key (for HTML).
   llvm::SmallVector<SmallString<16>, 4>
       Args; // List of arguments to commands (for InlineCommand).
   std::vector<std::unique_ptr<CommentInfo>>
       Children; // List of child comments for this CommentInfo.
 };
 
 struct Reference {
   Reference() = default;
-  Reference(llvm::StringRef Name) : UnresolvedName(Name) {}
-  Reference(SymbolID USR, InfoType IT) : USR(USR), RefType(IT) {}
-
-  SymbolID USR;                   // Unique identifer for referenced decl
-  SmallString<16> UnresolvedName; // Name of unresolved type.
-  InfoType RefType =
-      InfoType::IT_default; // Indicates the type of this Reference (namespace,
-                            // record, function, enum, default).
+  Reference(llvm::StringRef Name) : Name(Name) {}
+  Reference(SymbolID USR, StringRef Name, InfoType IT)
+      : USR(USR), Name(Name), RefType(IT) {}
+
+  SymbolID USR = SymbolID(); // Unique identifer for referenced decl
+  SmallString<16> Name;      // Name of type (possibly unresolved).
+  InfoType RefType = InfoType::IT_default; // Indicates the type of this
+                                           // Reference (namespace, record,
+                                           // function, enum, default).
 };
 
 // A base struct for TypeInfos
 struct TypeInfo {
   TypeInfo() = default;
-  TypeInfo(SymbolID &Type, InfoType IT) : Type(Type, IT) {}
+  TypeInfo(SymbolID Type, StringRef Field, InfoType IT)
+      : Type(Type, Field, IT) {}
   TypeInfo(llvm::StringRef RefName) : Type(RefName) {}
 
   Reference Type; // Referenced type in this info.
 };
 
 // Info for field types.
 struct FieldTypeInfo : public TypeInfo {
   FieldTypeInfo() = default;
-  FieldTypeInfo(SymbolID &Type, InfoType IT, llvm::StringRef Name)
-      : TypeInfo(Type, IT), Name(Name) {}
+  FieldTypeInfo(SymbolID Type, StringRef Field, InfoType IT,
+                llvm::StringRef Name)
+      : TypeInfo(Type, Field, IT), Name(Name) {}
   FieldTypeInfo(llvm::StringRef RefName, llvm::StringRef Name)
       : TypeInfo(RefName), Name(Name) {}
 
   SmallString<16> Name; // Name associated with this info.
 };
 
 // Info for member types.
 struct MemberTypeInfo : public FieldTypeInfo {
   MemberTypeInfo() = default;
-  MemberTypeInfo(SymbolID &Type, InfoType IT, llvm::StringRef Name)
-      : FieldTypeInfo(Type, IT, Name) {}
-  MemberTypeInfo(llvm::StringRef RefName, llvm::StringRef Name)
-      : FieldTypeInfo(RefName, Name) {}
-
-  AccessSpecifier Access =
-      clang::AccessSpecifier::AS_none; // Access level associated with this
-                                       // info (public, protected, private,
+  MemberTypeInfo(SymbolID Type, StringRef Field, InfoType IT,
+                 llvm::StringRef Name, AccessSpecifier Access)
+      : FieldTypeInfo(Type, Field, IT, Name), Access(Access) {}
+  MemberTypeInfo(llvm::StringRef RefName, llvm::StringRef Name,
+                 AccessSpecifier Access)
+      : FieldTypeInfo(RefName, Name), Access(Access) {}
+
+  AccessSpecifier Access = AccessSpecifier::AS_none; // Access level associated
+                                                     // with this info (public,
+                                                     // protected, private,
                                                      // none).
 };
 
 struct Location {
   Location() = default;
   Location(int LineNumber, SmallString<16> Filename)
       : LineNumber(LineNumber), Filename(std::move(Filename)) {}
 
   int LineNumber;           // Line number of this Location.

 };
 
 // TODO: Expand to allow for documenting templating and default args.
 // Info for functions.
 struct FunctionInfo : public SymbolInfo {
   bool IsMethod = false; // Indicates whether this function is a class method.
   Reference Parent;      // Reference to the parent class decl for this method.
   TypeInfo ReturnType;   // Info about the return type of this function.
-  llvm::SmallVector<FieldTypeInfo, 4> Params; // List of parameters.
-  AccessSpecifier Access =
-      AccessSpecifier::AS_none; // Access level for this method (public,
-                                // private, protected, none).
+  llvm::SmallVector<FieldTypeInfo, 4> Params;        // List of parameters.
+  AccessSpecifier Access = AccessSpecifier::AS_none; // Access level for this
+                                                     // method (public, private,
+                                                     // protected, none).
 };
 
 // TODO: Expand to allow for documenting templating, inheritance access,
 // friend classes
 // Info for types.
 struct RecordInfo : public SymbolInfo {
   TagTypeKind TagType = TagTypeKind::TTK_Struct; // Type of this record (struct,
                                                  // class, union, interface).

clang-doc/Serialize.cpp

static RecordDecl *getDeclForType(const QualType &T) {
   auto *Ty = T->getAs<RecordType>();
   if (!Ty)
     return nullptr;
   return Ty->getDecl()->getDefinition();
 }
 
 static void parseFields(RecordInfo &I, const RecordDecl *D) {
   for (const FieldDecl *F : D->fields()) {
-    // FIXME: Set Access to the appropriate value.
-    SymbolID Type;
-    std::string Name;
-    InfoType RefType;
     if (const auto *T = getDeclForType(F->getTypeSourceInfo()->getType())) {
-      Type = getUSRForDecl(T);
-      if (dyn_cast<EnumDecl>(T))
-        RefType = InfoType::IT_enum;
-      else if (dyn_cast<RecordDecl>(T))
-        RefType = InfoType::IT_record;
-      I.Members.emplace_back(Type, RefType, F->getQualifiedNameAsString());
-    } else {
-      Name = F->getTypeSourceInfo()->getType().getAsString();
-      I.Members.emplace_back(Name, F->getQualifiedNameAsString());
+      // 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, F->getNameAsString(),
+                               N->getAccessUnsafe());
+        continue;
+      } else if (const auto *N = dyn_cast<RecordDecl>(T)) {
+        I.Members.emplace_back(getUSRForDecl(T), N->getNameAsString(),
+                               InfoType::IT_record, F->getNameAsString(),
+                               N->getAccessUnsafe());
+        continue;
+      }
     }
+    I.Members.emplace_back(F->getTypeSourceInfo()->getType().getAsString(),
+                           F->getNameAsString(), F->getAccessUnsafe());
   }
 }
 
 static void parseEnumerators(EnumInfo &I, const EnumDecl *D) {
   for (const EnumConstantDecl *E : D->enumerators())
     I.Members.emplace_back(E->getNameAsString());
 }
 
 static void parseParameters(FunctionInfo &I, const FunctionDecl *D) {
   for (const ParmVarDecl *P : D->parameters()) {
-    SymbolID Type;
-    std::string Name;
-    InfoType RefType;
     if (const auto *T = getDeclForType(P->getOriginalType())) {
-      Type = getUSRForDecl(T);
-      if (dyn_cast<EnumDecl>(T))
-        RefType = InfoType::IT_enum;
-      else if (dyn_cast<RecordDecl>(T))
-        RefType = InfoType::IT_record;
-      I.Params.emplace_back(Type, RefType, P->getQualifiedNameAsString());
-    } else {
-      Name = P->getOriginalType().getAsString();
-      I.Params.emplace_back(Name, P->getQualifiedNameAsString());
+      if (const auto *N = dyn_cast<EnumDecl>(T)) {
+        I.Params.emplace_back(getUSRForDecl(N), N->getNameAsString(),
+                              InfoType::IT_enum, P->getNameAsString());
+        continue;
+      } else if (const auto *N = dyn_cast<RecordDecl>(T)) {
+        I.Params.emplace_back(getUSRForDecl(N), N->getNameAsString(),
+                              InfoType::IT_record, P->getNameAsString());
+        continue;
+      }
     }
+    I.Params.emplace_back(P->getOriginalType().getAsString(),
+                          P->getNameAsString());
   }
 }
 
 static void parseBases(RecordInfo &I, const CXXRecordDecl *D) {
   for (const CXXBaseSpecifier &B : D->bases()) {
     if (B.isVirtual())
       continue;
     if (const auto *P = getDeclForType(B.getType()))
-      I.Parents.emplace_back(getUSRForDecl(P), InfoType::IT_record);
+      I.Parents.emplace_back(getUSRForDecl(P), P->getNameAsString(),
+                             InfoType::IT_record);
     else
       I.Parents.emplace_back(B.getType().getAsString());
   }
   for (const CXXBaseSpecifier &B : D->vbases()) {
     if (const auto *P = getDeclForType(B.getType()))
-      I.VirtualParents.emplace_back(getUSRForDecl(P), InfoType::IT_record);
+      I.VirtualParents.emplace_back(getUSRForDecl(P), P->getNameAsString(),
+                                    InfoType::IT_record);
     else
       I.VirtualParents.emplace_back(B.getType().getAsString());
   }
 }
 
 template <typename T>
 static void
 populateParentNamespaces(llvm::SmallVector<Reference, 4> &Namespaces,
                          const T *D) {
   const auto *DC = dyn_cast<DeclContext>(D);
   while ((DC = DC->getParent())) {
     if (const auto *N = dyn_cast<NamespaceDecl>(DC))
-      Namespaces.emplace_back(getUSRForDecl(N), InfoType::IT_namespace);
+      Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
+                              InfoType::IT_namespace);
     else if (const auto *N = dyn_cast<RecordDecl>(DC))
-      Namespaces.emplace_back(getUSRForDecl(N), InfoType::IT_record);
+      Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
+                              InfoType::IT_record);
     else if (const auto *N = dyn_cast<FunctionDecl>(DC))
-      Namespaces.emplace_back(getUSRForDecl(N), InfoType::IT_function);
+      Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
+                              InfoType::IT_function);
     else if (const auto *N = dyn_cast<EnumDecl>(DC))
-      Namespaces.emplace_back(getUSRForDecl(N), InfoType::IT_enum);
+      Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
+                              InfoType::IT_enum);
   }
 }
 
 template <typename T>
 static void populateInfo(Info &I, const T *D, const FullComment *C) {
   I.USR = getUSRForDecl(D);
   I.Name = D->getNameAsString();
   populateParentNamespaces(I.Namespace, D);
else
     I.Loc.emplace_back(LineNumber, Filename);
 }
 
 static void populateFunctionInfo(FunctionInfo &I, const FunctionDecl *D,
                                  const FullComment *FC, int LineNumber,
                                  StringRef Filename) {
   populateSymbolInfo(I, D, FC, LineNumber, Filename);
   if (const auto *T = getDeclForType(D->getReturnType())) {
-    I.ReturnType.Type.USR = getUSRForDecl(T);
     if (dyn_cast<EnumDecl>(T))
-      I.ReturnType.Type.RefType = InfoType::IT_enum;
+      I.ReturnType =
+          TypeInfo(getUSRForDecl(T), T->getNameAsString(), InfoType::IT_enum);
     else if (dyn_cast<RecordDecl>(T))
-      I.ReturnType.Type.RefType = InfoType::IT_record;
+      I.ReturnType =
+          TypeInfo(getUSRForDecl(T), T->getNameAsString(), InfoType::IT_record);
   } else {
-    I.ReturnType.Type.UnresolvedName = D->getReturnType().getAsString();
+    I.ReturnType = TypeInfo(D->getReturnType().getAsString());
   }
   parseParameters(I, D);
 }
 
 std::string emitInfo(const NamespaceDecl *D, const FullComment *FC,
                      int LineNumber, llvm::StringRef File) {
   NamespaceInfo I;
   populateInfo(I, D, FC);
std::string emitInfo(const FunctionDecl *D, const FullComment *FC,
   return serialize(I);
 }
 
 std::string emitInfo(const CXXMethodDecl *D, const FullComment *FC,
                      int LineNumber, llvm::StringRef File) {
   FunctionInfo I;
   populateFunctionInfo(I, D, FC, LineNumber, File);
   I.IsMethod = true;
-  I.Parent = Reference(getUSRForDecl(D->getParent()), InfoType::IT_record);
+  I.Parent = Reference{getUSRForDecl(D->getParent()),
+                       D->getParent()->getNameAsString(), InfoType::IT_record};
   I.Access = D->getAccess();
   return serialize(I);
 }
 
 std::string emitInfo(const EnumDecl *D, const FullComment *FC, int LineNumber,
                      llvm::StringRef File) {
   EnumInfo I;
   populateSymbolInfo(I, D, FC, LineNumber, File);
   I.Scoped = D->isScoped();
   parseEnumerators(I, D);
   return serialize(I);
 }
 
 } // namespace serialize
 } // namespace doc
 } // namespace clang

test/clang-doc/mapper-class-in-class.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "" > %t/compile_flags.txt
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: clang-doc --dump-mapper -doxygen -p %t %t/test.cpp -output=%t/docs
 // RUN: llvm-bcanalyzer %t/docs/bc/641AB4A3D36399954ACDE29C7A8833032BF40472.bc --dump | FileCheck %s --check-prefix CHECK-X-Y
 // RUN: llvm-bcanalyzer %t/docs/bc/CA7C7935730B5EACD25F080E9C83FA087CCDC75E.bc --dump | FileCheck %s --check-prefix CHECK-X
 
 class X {
   class Y {};
 };
 
 // CHECK-X: <BLOCKINFO_BLOCK/>
 // CHECK-X-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-X-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-X-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-X-NEXT: </VersionBlock>
 // CHECK-X-NEXT: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-X-NEXT: <USR abbrevid=4 op0=20 op1=202 op2=124 op3=121 op4=53 op5=115 op6=11 op7=94 op8=172 op9=210 op10=95 op11=8 op12=14 op13=156 op14=131 op15=250 op16=8 op17=124 op18=205 op19=199 op20=94/>
   // CHECK-X-NEXT: <Name abbrevid=5 op0=1/> blob data = 'X'
-  // CHECK-X-NEXT: <DefLocation abbrevid=7 op0=9 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-X-NEXT: <TagType abbrevid=9 op0=3/>
+  // CHECK-X-NEXT: <DefLocation abbrevid=6 op0=9 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-X-NEXT: <TagType abbrevid=8 op0=3/>
 // CHECK-X-NEXT: </RecordBlock>
 
 
 // CHECK-X-Y: <BLOCKINFO_BLOCK/>
 // CHECK-X-Y-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-X-Y-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-X-Y-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-X-Y-NEXT: </VersionBlock>
 // CHECK-X-Y-NEXT: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-X-Y-NEXT: <USR abbrevid=4 op0=20 op1=100 op2=26 op3=180 op4=163 op5=211 op6=99 op7=153 op8=149 op9=74 op10=205 op11=226 op12=156 op13=122 op14=136 op15=51 op16=3 op17=43 op18=244 op19=4 op20=114/>
   // CHECK-X-Y-NEXT: <Name abbrevid=5 op0=1/> blob data = 'Y'
-  // CHECK-X-Y-NEXT: <Namespace abbrevid=6 op0=1 op1=40/> blob data = 'CA7C7935730B5EACD25F080E9C83FA087CCDC75E'
-  // CHECK-X-Y-NEXT: <DefLocation abbrevid=7 op0=10 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-X-Y-NEXT: <TagType abbrevid=9 op0=3/>
+  // CHECK-X-Y-NEXT: <ReferenceBlock NumWords=10 BlockCodeSize=4>
+      // CHECK-X-Y-NEXT: <USR abbrevid=4 op0=20 op1=202 op2=124 op3=121 op4=53 op5=115 op6=11 op7=94 op8=172 op9=210 op10=95 op11=8 op12=14 op13=156 op14=131 op15=250 op16=8 op17=124 op18=205 op19=199 op20=94/>
+      // CHECK-X-Y-NEXT: <Name abbrevid=5 op0=1/> blob data = 'X'
+      // CHECK-X-Y-NEXT: <RefType abbrevid=6 op0=2/>
+      // CHECK-X-Y-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-X-Y-NEXT: </ReferenceBlock>  
+  // CHECK-X-Y-NEXT: <DefLocation abbrevid=6 op0=10 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-X-Y-NEXT: <TagType abbrevid=8 op0=3/>
 // CHECK-X-Y-NEXT: </RecordBlock>

test/clang-doc/mapper-class-in-function.cpp

 // RUN: llvm-bcanalyzer %t/docs/bc/01A95F3F73F53281B3E50109A577FD2493159365.bc --dump | FileCheck %s --check-prefix CHECK-H-I
 
 void H() {
   class I {};
 }
 
 // CHECK-H: <BLOCKINFO_BLOCK/>
 // CHECK-H-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-H-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-H-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-H-NEXT: </VersionBlock>
 // CHECK-H-NEXT: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-H-NEXT: <USR abbrevid=4 op0=20 op1=182 op2=172 op3=76 op4=92 op5=159 op6=46 op7=163 op8=242 op9=179 op10=236 op11=225 op12=163 op13=61 op14=52 op15=159 op16=78 op17=229 op18=2 op19=178 op20=78/>
   // CHECK-H-NEXT: <Name abbrevid=5 op0=1/> blob data = 'H'
-  // CHECK-H-NEXT: <DefLocation abbrevid=7 op0=12 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-H-NEXT: <TypeBlock NumWords=4 BlockCodeSize=4>
-    // CHECK-H-NEXT: <Type abbrevid=4 op0=4 op1=4/> blob data = 'void'
+  // CHECK-H-NEXT: <DefLocation abbrevid=6 op0=12 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-H-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-H-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-H-NEXT: <Name abbrevid=5 op0=4/> blob data = 'void'
+      // CHECK-H-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-H-NEXT: </ReferenceBlock>
   // CHECK-H-NEXT: </TypeBlock>
 // CHECK-H-NEXT: </FunctionBlock>
 
 // CHECK-H-I: <BLOCKINFO_BLOCK/>
 // CHECK-H-I-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-H-I-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-H-I-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-H-I-NEXT: </VersionBlock>
 // CHECK-H-I-NEXT: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-H-I-NEXT: <USR abbrevid=4 op0=20 op1=1 op2=169 op3=95 op4=63 op5=115 op6=245 op7=50 op8=129 op9=179 op10=229 op11=1 op12=9 op13=165 op14=119 op15=253 op16=36 op17=147 op18=21 op19=147 op20=101/>
   // CHECK-H-I-NEXT: <Name abbrevid=5 op0=1/> blob data = 'I'
-  // CHECK-H-I-NEXT: <Namespace abbrevid=6 op0=2 op1=40/> blob data = 'B6AC4C5C9F2EA3F2B3ECE1A33D349F4EE502B24E'
-  // CHECK-H-I-NEXT: <DefLocation abbrevid=7 op0=13 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-H-I-NEXT: <TagType abbrevid=9 op0=3/>
+  // CHECK-H-I-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-H-I-NEXT: <USR abbrevid=4 op0=20 op1=182 op2=172 op3=76 op4=92 op5=159 op6=46 op7=163 op8=242 op9=179 op10=236 op11=225 op12=163 op13=61 op14=52 op15=159 op16=78 op17=229 op18=2 op19=178 op20=78/>
+    // CHECK-H-I-NEXT: <Name abbrevid=5 op0=1/> blob data = 'H'
+    // CHECK-H-I-NEXT: <RefType abbrevid=6 op0=3/>
+    // CHECK-H-I-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-H-I-NEXT: </ReferenceBlock>
+  // CHECK-H-I-NEXT: <DefLocation abbrevid=6 op0=13 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-H-I-NEXT: <TagType abbrevid=8 op0=3/>
 // CHECK-H-I-NEXT: </RecordBlock>
 
 

test/clang-doc/mapper-class.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "" > %t/compile_flags.txt
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: clang-doc --dump-mapper -doxygen -p %t %t/test.cpp -output=%t/docs
 // RUN: llvm-bcanalyzer %t/docs/bc/289584A8E0FF4178A794622A547AA622503967A1.bc --dump | FileCheck %s
 
 class E {};
 
 // CHECK: <BLOCKINFO_BLOCK/>
 // CHECK-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-NEXT: </VersionBlock>
 // CHECK-NEXT: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-NEXT: <USR abbrevid=4 op0=20 op1=40 op2=149 op3=132 op4=168 op5=224 op6=255 op7=65 op8=120 op9=167 op10=148 op11=98 op12=42 op13=84 op14=122 op15=166 op16=34 op17=80 op18=57 op19=103 op20=161/>
   // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'E'
-  // CHECK-NEXT: <DefLocation abbrevid=7 op0=8 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-NEXT: <TagType abbrevid=9 op0=3/>
+  // CHECK-NEXT: <DefLocation abbrevid=6 op0=8 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-NEXT: <TagType abbrevid=8 op0=3/>
 // CHECK-NEXT: </RecordBlock>

test/clang-doc/mapper-comments.cpp

 ///
 /// \param [out] I is a parameter.
 /// \param J is a parameter.
 /// \return int
 int F(int I, int J);
 
 // CHECK: <BLOCKINFO_BLOCK/>
 // CHECK-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-NEXT: </VersionBlock>
 // CHECK-NEXT: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-NEXT: <USR abbrevid=4 op0=20 op1=117 op2=116 op3=99 op4=6 op5=20 op6=165 op7=53 op8=113 op9=14 op10=90 op11=106 op12=188 op13=255 op14=249 op15=139 op16=202 op17=45 op18=6 op19=164 op20=202/>
   // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'F'
   // CHECK-NEXT: <CommentBlock NumWords=351 BlockCodeSize=4>
     // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'FullComment'
     // CHECK-NEXT: <CommentBlock NumWords=13 BlockCodeSize=4>
       // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
// CHECK-NEXT: <CommentBlock NumWords=27 BlockCodeSize=4>
         // CHECK-NEXT: <Kind abbrevid=4 op0=16/> blob data = 'ParagraphComment'
         // CHECK-NEXT: <CommentBlock NumWords=7 BlockCodeSize=4>
           // CHECK-NEXT: <Kind abbrevid=4 op0=11/> blob data = 'TextComment'
           // CHECK-NEXT: <Text abbrevid=5 op0=4/> blob data = ' int'
         // CHECK-NEXT: </CommentBlock>
       // CHECK-NEXT: </CommentBlock>
     // CHECK-NEXT: </CommentBlock>
   // CHECK-NEXT: </CommentBlock>
-  // CHECK-NEXT: <Location abbrevid=8 op0=24 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-NEXT: <TypeBlock NumWords=4 BlockCodeSize=4>
-    // CHECK-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
+  // CHECK-NEXT: <Location abbrevid=7 op0=24 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
   // CHECK-NEXT: </TypeBlock>
-  // CHECK-NEXT: <FieldTypeBlock NumWords=6 BlockCodeSize=4>
-    // CHECK-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
-    // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'I'
+  // CHECK-NEXT: <FieldTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+    // CHECK-NEXT: <Name abbrevid=4 op0=1/> blob data = 'I'
   // CHECK-NEXT: </FieldTypeBlock>
-  // CHECK-NEXT: <FieldTypeBlock NumWords=6 BlockCodeSize=4>
-    // CHECK-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
-    // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'J'
+  // CHECK-NEXT: <FieldTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+    // CHECK-NEXT: <Name abbrevid=4 op0=1/> blob data = 'J'
   // CHECK-NEXT: </FieldTypeBlock>
 // CHECK-NEXT: </FunctionBlock>

test/clang-doc/mapper-enum.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "" > %t/compile_flags.txt
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: clang-doc --dump-mapper -doxygen -p %t %t/test.cpp -output=%t/docs
 // RUN: llvm-bcanalyzer %t/docs/bc/FC07BD34D5E77782C263FA944447929EA8753740.bc --dump | FileCheck %s --check-prefix CHECK-B
 // RUN: llvm-bcanalyzer %t/docs/bc/020E6C32A700C3170C009FCCD41671EDDBEAF575.bc --dump | FileCheck %s --check-prefix CHECK-C
 
 enum B { X, Y };
 
 // CHECK-B: <BLOCKINFO_BLOCK/>
 // CHECK-B-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-B-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-B-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-B-NEXT: </VersionBlock>
 // CHECK-B-NEXT: <EnumBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-B-NEXT: <USR abbrevid=4 op0=20 op1=252 op2=7 op3=189 op4=52 op5=213 op6=231 op7=119 op8=130 op9=194 op10=99 op11=250 op12=148 op13=68 op14=71 op15=146 op16=158 op17=168 op18=117 op19=55 op20=64/>
   // CHECK-B-NEXT: <Name abbrevid=5 op0=1/> blob data = 'B'
-  // CHECK-B-NEXT: <DefLocation abbrevid=7 op0=9 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-B-NEXT: <Member abbrevid=9 op0=1/> blob data = 'X'
-  // CHECK-B-NEXT: <Member abbrevid=9 op0=1/> blob data = 'Y'
+  // CHECK-B-NEXT: <DefLocation abbrevid=6 op0=9 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-B-NEXT: <Member abbrevid=8 op0=1/> blob data = 'X'
+  // CHECK-B-NEXT: <Member abbrevid=8 op0=1/> blob data = 'Y'
 // CHECK-B-NEXT: </EnumBlock>
 
 enum class C { A, B };
 
 // CHECK-C: <BLOCKINFO_BLOCK/>
 // CHECK-C-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-C-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-C-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-C-NEXT: </VersionBlock>
 // CHECK-C-NEXT: <EnumBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-C-NEXT: <USR abbrevid=4 op0=20 op1=2 op2=14 op3=108 op4=50 op5=167 op6=0 op7=195 op8=23 op9=12 op10=0 op11=159 op12=204 op13=212 op14=22 op15=113 op16=237 op17=219 op18=234 op19=245 op20=117/>
   // CHECK-C-NEXT: <Name abbrevid=5 op0=1/> blob data = 'C'
-  // CHECK-C-NEXT: <DefLocation abbrevid=7 op0=23 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-C-NEXT: <Scoped abbrevid=10 op0=1/>
-  // CHECK-C-NEXT: <Member abbrevid=9 op0=1/> blob data = 'A'
-  // CHECK-C-NEXT: <Member abbrevid=9 op0=1/> blob data = 'B'
+  // CHECK-C-NEXT: <DefLocation abbrevid=6 op0=23 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-C-NEXT: <Scoped abbrevid=9 op0=1/>
+  // CHECK-C-NEXT: <Member abbrevid=8 op0=1/> blob data = 'A'
+  // CHECK-C-NEXT: <Member abbrevid=8 op0=1/> blob data = 'B'
 // CHECK-C-NEXT: </EnumBlock>

test/clang-doc/mapper-function.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "" > %t/compile_flags.txt
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: clang-doc --dump-mapper -doxygen -p %t %t/test.cpp -output=%t/docs
 // RUN: llvm-bcanalyzer %t/docs/bc/A44B32CC3C087C9AF75DAF50DE193E85E7B2C16B.bc --dump | FileCheck %s
 
 int F(int param) { return param; }
 
 // CHECK: <BLOCKINFO_BLOCK/>
 // CHECK-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-NEXT: </VersionBlock>
 // CHECK-NEXT: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-NEXT: <USR abbrevid=4 op0=20 op1=164 op2=75 op3=50 op4=204 op5=60 op6=8 op7=124 op8=154 op9=247 op10=93 op11=175 op12=80 op13=222 op14=25 op15=62 op16=133 op17=231 op18=178 op19=193 op20=107/>
   // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'F'
-  // CHECK-NEXT: <DefLocation abbrevid=7 op0=8 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-NEXT: <TypeBlock NumWords=4 BlockCodeSize=4>
-    // CHECK-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
+  // CHECK-NEXT: <DefLocation abbrevid=6 op0=8 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
   // CHECK-NEXT: </TypeBlock>
-  // CHECK-NEXT: <FieldTypeBlock NumWords=7 BlockCodeSize=4>
-    // CHECK-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
-    // CHECK-NEXT: <Name abbrevid=5 op0=5/> blob data = 'param'
+  // CHECK-NEXT: <FieldTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+    // CHECK-NEXT: <Name abbrevid=4 op0=5/> blob data = 'param'
   // CHECK-NEXT: </FieldTypeBlock>
 // CHECK-NEXT: </FunctionBlock>

test/clang-doc/mapper-method.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "" > %t/compile_flags.txt
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: clang-doc --dump-mapper -doxygen -p %t %t/test.cpp -output=%t/docs
 // RUN: llvm-bcanalyzer %t/docs/bc/F0F9FC65FC90F54F690144A7AFB15DFC3D69B6E6.bc --dump | FileCheck %s --check-prefix CHECK-G-F
 // RUN: llvm-bcanalyzer %t/docs/bc/4202E8BF0ECB12AE354C8499C52725B0EE30AED5.bc --dump | FileCheck %s --check-prefix CHECK-G
 
 class G {
 public: 
   int Method(int param) { return param; }
 };
 
 // CHECK-G: <BLOCKINFO_BLOCK/>
 // CHECK-G-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-G-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-G-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-G-NEXT: </VersionBlock>
 // CHECK-G-NEXT: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-G-NEXT: <USR abbrevid=4 op0=20 op1=66 op2=2 op3=232 op4=191 op5=14 op6=203 op7=18 op8=174 op9=53 op10=76 op11=132 op12=153 op13=197 op14=39 op15=37 op16=176 op17=238 op18=48 op19=174 op20=213/>
   // CHECK-G-NEXT: <Name abbrevid=5 op0=1/> blob data = 'G'
-  // CHECK-G-NEXT: <DefLocation abbrevid=7 op0=9 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-G-NEXT: <TagType abbrevid=9 op0=3/>
+  // CHECK-G-NEXT: <DefLocation abbrevid=6 op0=9 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-G-NEXT: <TagType abbrevid=8 op0=3/>
 // CHECK-G-NEXT: </RecordBlock>
 
 // CHECK-G-F: <BLOCKINFO_BLOCK/>
 // CHECK-G-F-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-G-F-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-G-F-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-G-F-NEXT: </VersionBlock>
 // CHECK-G-F-NEXT: <FunctionBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-G-F-NEXT: <USR abbrevid=4 op0=20 op1=240 op2=249 op3=252 op4=101 op5=252 op6=144 op7=245 op8=79 op9=105 op10=1 op11=68 op12=167 op13=175 op14=177 op15=93 op16=252 op17=61 op18=105 op19=182 op20=230/>
   // CHECK-G-F-NEXT: <Name abbrevid=5 op0=6/> blob data = 'Method'
-  // CHECK-G-F-NEXT: <Namespace abbrevid=6 op0=1 op1=40/> blob data = '4202E8BF0ECB12AE354C8499C52725B0EE30AED5'
-  // CHECK-G-F-NEXT: <IsMethod abbrevid=11 op0=1/>
-  // CHECK-G-F-NEXT: <DefLocation abbrevid=7 op0=11 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-G-F-NEXT: <Parent abbrevid=9 op0=1 op1=40/> blob data = '4202E8BF0ECB12AE354C8499C52725B0EE30AED5'
-  // CHECK-G-F-NEXT: <TypeBlock NumWords=4 BlockCodeSize=4>
-    // CHECK-G-F-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
+  // CHECK-G-F-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-G-F-NEXT: <USR abbrevid=4 op0=20 op1=66 op2=2 op3=232 op4=191 op5=14 op6=203 op7=18 op8=174 op9=53 op10=76 op11=132 op12=153 op13=197 op14=39 op15=37 op16=176 op17=238 op18=48 op19=174 op20=213/>
+    // CHECK-G-F-NEXT: <Name abbrevid=5 op0=1/> blob data = 'G'
+    // CHECK-G-F-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-G-F-NEXT: <Field abbrevid=7 op0=1/>
+  // CHECK-G-F-NEXT: </ReferenceBlock>
+  // CHECK-G-F-NEXT: <IsMethod abbrevid=9 op0=1/>
+  // CHECK-G-F-NEXT: <DefLocation abbrevid=6 op0=11 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-G-F-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-G-F-NEXT: <USR abbrevid=4 op0=20 op1=66 op2=2 op3=232 op4=191 op5=14 op6=203 op7=18 op8=174 op9=53 op10=76 op11=132 op12=153 op13=197 op14=39 op15=37 op16=176 op17=238 op18=48 op19=174 op20=213/>
+    // CHECK-G-F-NEXT: <Name abbrevid=5 op0=1/> blob data = 'G'
+    // CHECK-G-F-NEXT: <RefType abbrevid=6 op0=2/>
+    // CHECK-G-F-NEXT: <Field abbrevid=7 op0=2/>
+  // CHECK-G-F-NEXT: </ReferenceBlock>
+    // CHECK-G-F-NEXT: <TypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-G-F-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-G-F-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-G-F-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-G-F-NEXT: </ReferenceBlock>
   // CHECK-G-F-NEXT: </TypeBlock>
-  // CHECK-G-F-NEXT: <FieldTypeBlock NumWords=7 BlockCodeSize=4>
-    // CHECK-G-F-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
-    // CHECK-G-F-NEXT: <Name abbrevid=5 op0=5/> blob data = 'param'
+  // CHECK-G-F-NEXT: <FieldTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-G-F-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-G-F-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-G-F-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-G-F-NEXT: </ReferenceBlock>
+    // CHECK-G-F-NEXT: <Name abbrevid=4 op0=5/> blob data = 'param'
   // CHECK-G-F-NEXT: </FieldTypeBlock>
 // CHECK-G-F-NEXT: </FunctionBlock>

test/clang-doc/mapper-namespace.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "" > %t/compile_flags.txt
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: clang-doc --dump-mapper -doxygen -p %t %t/test.cpp -output=%t/docs
 // RUN: llvm-bcanalyzer %t/docs/bc/8D042EFFC98B373450BC6B5B90A330C25A150E9C.bc --dump | FileCheck %s
 
 namespace A {}
 
 // CHECK: <BLOCKINFO_BLOCK/>
 // CHECK-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-NEXT: </VersionBlock>
 // CHECK-NEXT: <NamespaceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-NEXT: <USR abbrevid=4 op0=20 op1=141 op2=4 op3=46 op4=255 op5=201 op6=139 op7=55 op8=52 op9=80 op10=188 op11=107 op12=91 op13=144 op14=163 op15=48 op16=194 op17=90 op18=21 op19=14 op20=156/>
   // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'A'
 // CHECK-NEXT: </NamespaceBlock>

test/clang-doc/mapper-struct.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "" > %t/compile_flags.txt
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: clang-doc --dump-mapper -doxygen -p %t %t/test.cpp -output=%t/docs
 // RUN: llvm-bcanalyzer %t/docs/bc/06B5F6A19BA9F6A832E127C9968282B94619B210.bc --dump | FileCheck %s
 
 struct C { int i; };
 
 // CHECK: <BLOCKINFO_BLOCK/>
 // CHECK-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-NEXT: </VersionBlock>
 // CHECK-NEXT: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-NEXT: <USR abbrevid=4 op0=20 op1=6 op2=181 op3=246 op4=161 op5=155 op6=169 op7=246 op8=168 op9=50 op10=225 op11=39 op12=201 op13=150 op14=130 op15=130 op16=185 op17=70 op18=25 op19=178 op20=16/>
   // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'C'
-  // CHECK-NEXT: <DefLocation abbrevid=7 op0=8 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-NEXT: <MemberTypeBlock NumWords=6 BlockCodeSize=4>
-    // CHECK-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
-    // CHECK-NEXT: <Name abbrevid=5 op0=4/> blob data = 'C::i'
-    // CHECK-NEXT: <Access abbrevid=6 op0=3/>
+  // CHECK-NEXT: <DefLocation abbrevid=6 op0=8 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-NEXT: <MemberTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+    // CHECK-NEXT: <Name abbrevid=4 op0=1/> blob data = 'i'
   // CHECK-NEXT: </MemberTypeBlock>
 // CHECK-NEXT: </RecordBlock>

test/clang-doc/mapper-union.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: echo "" > %t/compile_flags.txt
 // RUN: cp "%s" "%t/test.cpp"
 // RUN: clang-doc --dump-mapper -doxygen -p %t %t/test.cpp -output=%t/docs
 // RUN: llvm-bcanalyzer %t/docs/bc/0B8A6B938B939B77C6325CCCC8AA3E938BF9E2E8.bc --dump | FileCheck %s
 
 union D { int X; int Y; };
 
 // CHECK: <BLOCKINFO_BLOCK/>
 // CHECK-NEXT: <VersionBlock NumWords=1 BlockCodeSize=4>
-  // CHECK-NEXT: <Version abbrevid=4 op0=1/>
+  // CHECK-NEXT: <Version abbrevid=4 op0=2/>
 // CHECK-NEXT: </VersionBlock>
 // CHECK-NEXT: <RecordBlock NumWords={{[0-9]*}} BlockCodeSize=4>
   // CHECK-NEXT: <USR abbrevid=4 op0=20 op1=11 op2=138 op3=107 op4=147 op5=139 op6=147 op7=155 op8=119 op9=198 op10=50 op11=92 op12=204 op13=200 op14=170 op15=62 op16=147 op17=139 op18=249 op19=226 op20=232/>
   // CHECK-NEXT: <Name abbrevid=5 op0=1/> blob data = 'D'
-  // CHECK-NEXT: <DefLocation abbrevid=7 op0=8 op1={{[0-9]*}}/> blob data = '{{.*}}'
-  // CHECK-NEXT: <TagType abbrevid=9 op0=2/>
-  // CHECK-NEXT: <MemberTypeBlock NumWords=6 BlockCodeSize=4>
-    // CHECK-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
-    // CHECK-NEXT: <Name abbrevid=5 op0=4/> blob data = 'D::X'
-    // CHECK-NEXT: <Access abbrevid=6 op0=3/>
+  // CHECK-NEXT: <DefLocation abbrevid=6 op0=8 op1={{[0-9]*}}/> blob data = '{{.*}}'
+  // CHECK-NEXT: <TagType abbrevid=8 op0=2/>
+  // CHECK-NEXT: <MemberTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+    // CHECK-NEXT: <Name abbrevid=4 op0=1/> blob data = 'X'
   // CHECK-NEXT: </MemberTypeBlock>
-  // CHECK-NEXT: <MemberTypeBlock NumWords=6 BlockCodeSize=4>
-    // CHECK-NEXT: <Type abbrevid=4 op0=4 op1=3/> blob data = 'int'
-    // CHECK-NEXT: <Name abbrevid=5 op0=4/> blob data = 'D::Y'
-    // CHECK-NEXT: <Access abbrevid=6 op0=3/>
+  // CHECK-NEXT: <MemberTypeBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+    // CHECK-NEXT: <ReferenceBlock NumWords={{[0-9]*}} BlockCodeSize=4>
+      // CHECK-NEXT: <Name abbrevid=5 op0=3/> blob data = 'int'
+      // CHECK-NEXT: <Field abbrevid=7 op0=4/>
+    // CHECK-NEXT: </ReferenceBlock>
+    // CHECK-NEXT: <Name abbrevid=4 op0=1/> blob data = 'Y'
   // CHECK-NEXT: </MemberTypeBlock>
 // CHECK-NEXT: </RecordBlock>