[clang-doc] Clean up *Info constructors.

[brettw]

Summary

The *Info object (for the copy of the AST") constructors had many duplicated variants. Many of the variants seemed to be in an attempt to avoid default arguments. But default arguments are not prohibited and using them allows most of the variants to be removed which improves readability.

Remove the IsInGlobalNamespace flag on a Reference. This is set when the path is empty, and only read once in the HTML generator with the identical condition. The constructor cleanup exposed a problem where this was set to false when the constructor with no path was used, but true when the path was set to empty.

There should be no observable change with the exception that IsInGlobalNamespace is no longer emitted in YAML.

[haowei]

I am a bit puzzled by the intent of cleaning up the constructors in Info object. I didn't see it as an issue to have multiple constructors, which is a common practice. After this clean up It doesn't make it easier to use these objects, in fact, in Serialize.cpp, you have to explicitly specify a new SymbolID() when creating a new Reference object. While this change won't affect (except for the global namespace) the output from clang-docs, it is not semantically equivalent before the cleanup.

Would you mind explaining the reasons for removing these constructors?

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

165

The clean up here prevents setting a customized SymbolID for TypeInfo, which becomes a problem in the HTMLGeneratorTest, in which TypeInfo is constructed with an constant EmptySID. While the outcome is the same, it is not semantically equivalent.

219

This is already set in the constructor. Does it still need to be set explicitly here?

[brettw]

First, for the mechanical part of the change, this code implement multiple constructors:

  Info() = default;
  Info(InfoType IT) : IT(IT) {}
  Info(InfoType IT, SymbolID USR) : USR(USR), IT(IT) {}
  Info(InfoType IT, SymbolID USR, StringRef Name)
      : USR(USR), IT(IT), Name(Name) {}
  Info(InfoType IT, SymbolID USR, StringRef Name, StringRef Path)

is not common practice. This is an extremely verbose and error-prone way of implementing default arguments. It seems obvious to me that the one constructor that implements the exact same behavior is much more clear. Most of this patch is doing this mechanical change for these objects.

There are a few cases in this patch where I removed some constructors that took some "other" subset of parameters.

  Reference() = default;
  Reference(llvm::StringRef Name) : Name(Name) {}
  Reference(llvm::StringRef Name, StringRef Path)
      : Name(Name), Path(Path), IsInGlobalNamespace(Path.empty()) {}
  Reference(SymbolID USR, StringRef Name, InfoType IT)
      : USR(USR), Name(Name), RefType(IT) {}
  Reference(SymbolID USR, StringRef Name, InfoType IT, StringRef Path)
      : USR(USR), Name(Name), RefType(IT), Path(Path),
        IsInGlobalNamespace(Path.empty()) {}

Working on this code, I found the number of constructors with different parameters to make things more difficult to follow. It's harder to figure out what exactly a line of code is doing when there are so many variants you have to match against. It's also more difficult to figure out how to create one of these objects when you have to read so many variants to see what to call. This mental overhead may not be obvious when just looking at a diff, especially the test code where you may see an extra empty SID parameter inserted here and there. This new one tries to have a single constructor with default arguments from the right, with the exception of the "TypeInfo" that creates a single named type with no SymbolID because that's by far the most common variant in tests.

With this Reference constructor in particular, all of these variants hide a bug. If I didn't call that bug out in the change description, would you have seen it? Having a standard constructor makes this much easier to follow. Changing several callers to manually specify an empty SymbolID() seems like a small price to pay (I think this is the only case where any calls get "more complicated."

I tried to standardize on a single way to construct these objects. As an example, the TypeInfo is just a wrapper around a Reference. Reference has many constructors, not all of which are a subset of the others. Does this mean TypeInfo should get these same 5 constructor variants? The author said no, they picked 3 of the variants and implemented TypeInfo constructors, and used different names for some of the parameters which makes it even harder to follow. Continuing down the chain, FieldTypeInfo derives from TypeInfo, and MemberTypeInfo derives from FieldTypeInfo. Does this mean they should get the same 5 variants, plus initializers for their own values? I would say no. If these derived classes needed to specify the Reference information, they should take a Reference as the first parameter (they don't all need to do this today).

There's a problem with the current object model. The FieldTypeInfo and MemberTypeInfo derive from TypeInfo. But I think that this is wrong. The FieldTypeInfo isn't the type information for a field, it's really a "Field" and a MemberTypeInfo isn't the type info for a member, it's the "Member" itself. Conceptually, FieldTypeInfo should be a FieldInfo and have a struct TypeInfo Type; rather than using an "is a" relationship and deriving from a type. Given that, this object naming and constructor "should" be:

  MemberInfo(TypeInfo Type, StringRef Name, AccessSpecifier Access = Public)

This patch gets us closer to this, where we still have the weird "is a" derivation but the constructors match what I think they should be:

  MemberTypeInfo() = default;
  MemberTypeInfo(const TypeInfo &TI, StringRef Name, AccessSpecifier Access)

The parameters that define the implementation details of how the type is represented don't belong on this class: if the caller wants to create a type, they should create it using one of the appropriate TypeInfo constructors rather than each variant being duplicated here.

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

165

It does not prevent setting a custom SymbolID. The full constructor is the one above that takes a Reference. That is the one that's normally used in the production code; I added it in my previous patch. This patch is a followup from that one because I wanted to remove some now-redundant constructors but thought that I would separate it out to make it easier to review. The minority of cases in HTMLGeneratorTest that needed to pass more than the simple name/path have been updated to take a Reference.

The only code that changed in a way that you described is on line 373. But I'm not sure what you're arguing about "semantically equivalent". In this case, the caller wanted a "void" TypeInfo but tryped a bunch of unnecessary stuff. I think it's likely that the author of this code was confused about the constructor situation for TypeInfo and used a more complex variant than was required. It illustrates exactly why this cleanup is useful.

219

It does not, but I have learned to always supply default initializers for POD types when there's a trivial initial value. It's easy for somebody to later come by and add a constructor in such a way that the value is not uninitialized (you seem to be arguing above that you would prefer some of the old constructors, and making those additions could easily cause this problem). This has no runtime overhead and provides some insurance against hard-to-diagnose uninitialized data bugs in the future.

[brettw]

If you have more questions, I can schedule a meeting.

[paulkirth]

@brettw Thanks for the clarification. While I'm more familiar w/ these set of patches, I have to say that that I was also unsure/surprised by some of these changes. If you have concrete plans for cleanups letting us know about those plans in the initial review will help things proceed more smoothly. For instance, I wasn't aware that you had plans to refactor the various TypeInfos until now, and that context will make reviewing new patches more straightforward on my end.

Anyway, thanks for taking the time to provide the full context for us. I found it very helpful.

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

165

It does not prevent setting a custom SymbolID. The full constructor is the one above that takes a Reference. That is the one that's normally used in the production code; I added it in my previous patch.

I think the more salient point is that the SymbolID is only used in TypeInfo to instantiate a Reference, so I don't think we're losing too much flexibility by forcing users of this API to construct the Reference directly.

If we want to leave support for setting the SymbolD in place, we should mark it with a FIXME and an issue on github to revisit. Otherwise, I think we can move on.

This patch is a followup from that one because I wanted to remove some now-redundant constructors but thought that I would separate it out to make it easier to review.

Thank you. Small incremental patches are always appreciated.

The minority of cases in HTMLGeneratorTest that needed to pass more than the simple name/path have been updated to take a Reference.

The only code that changed in a way that you described is on line 373. But I'm not sure what you're arguing about "semantically equivalent".

I agree w/ @haowei that these are not semantically equivalent, despite the fact that they result in the same output. EmptySID is const and is a specific instance of SymbolID that has a unique meaning. While it is just default constructed, using another instance is semantically different, regardless if the resulting output will be the same or not.

In this case, the caller wanted a "void" TypeInfo but tryped a bunch of unnecessary stuff. I think it's likely that the author of this code was confused about the constructor situation for TypeInfo and used a more complex variant than was required. It illustrates exactly why this cleanup is useful.

Let's leave speculation about the original authors out of this review. we all agree that clang-doc is in need of maintenance, so thank you for your patch.

200–202

do we still want to use std::move here now that its a StringRef? I don't think we would do that w/ const char*, which is what StringRef boils down to. It should be passed by value everywhere.

see
https://llvm.org/docs/ProgrammersManual.html#passing-strings-the-stringref-and-twine-classes,
https://llvm.org/docs/ProgrammersManual.html#the-stringref-class
https://llvm.org/docs/ProgrammersManual.html#string-like-containers

[brettw]

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

200–202

The move is unnecessary and I removed it.

[haowei]

@brettw Thanks for the clarification. I was oncall for buildgardener last week and got quite busy due to breakages.

Thanks for your clarification, that is really helpful to understand the your intent. While I still don't see the way these constructors are implemented is an issue. I don't have a strong opinions on this and OK with your refactors.

"semantically equivalent" means these test code should have same input/output, performance same routines of task and use same amount of memory. Before your change, these typeinfo's symbolID in the test are always pointing to a constant EmptySID, after your change, some of these typeinfo points to an empty symbol ID in allocated in memory when typeinfo is created. While the output is the same, they are not equivalent. For refactor changes, I would prefer to avoid introducing such changes.

I have one question about deleting the IsInGlobalNamespace. I understand it is not well implemented and has a bug in its constructor, but I don't think we should simply delete it just because it is buggy and not well used. It is part of C++ and commonly used. Do you have any plan to add it back after all the refactor work finishes?

[haowei]

Please avoid directly replying to the email as they won't be logged in the
phabricator.

This boolean is logged into YAML output, while I don't have data, I could
bet there will be users depending on it even if it looks so unlikely. We
don't own the tool in the first place, in that case, I felt if there is a
bug in its constructor, we should fix the bug instead of abruptly deleting
it, even if it looks so easy to be derived from other values.

[brettw]

I can guarantee that nobody uses this for anything useful because it doesn't work well enough. For example, before I started changing it, requesting HTML output crashed on startup and many of the most basic syntactic things were broken. My previous patch changed enums from being a list of dictionaries which is much more backwards incompatible than this. I don't think we need to worry about that.

[haowei]

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

336

This block ID came from L582, which read from a bitcode file when BI_REFERENCE_BLOCK_ID is encountered. I am not familiar with the content of an arbitrary bitcode file. But after your patch, if this block ID is encountered, it will result in an error (a behavior change).

It looks like REFERENCE_IS_IN_GLOBAL_NAMESPACE is only defined in in clang-doc and not part of LLVM's bitcode header. So it looks like it is not a standardized ID to me. Could you confirm it?

If REFERENCE_IS_IN_GLOBAL_NAMESPACE only presents in bitcode file generated from BitcodeWriter from clang-doc and we are not expecting to provide compatibility to an arbitrary bitcode generated from elsewhere, I am OK with deleting this field (I still don't think this is the right approach to do but I don't have a strong opinion on this either).

[brettw]

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

336

Correct, this whole bitcode system is used only to communicate within clang-doc between threads (!) (I think it should be entirely removed but I don't have the time for that). It is never serialized to a file and is not shared with any other component.

[haowei]

LGTM
@paulkirth Do you have more comments?

[paulkirth]

I'm good w/ this. LGTM

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

llvm::Error parseRecord(const Record &R, unsigned ID, llvm::StringRef Blob,
   default:
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "invalid field for CommentInfo");
   }
 }
 
 llvm::Error parseRecord(const Record &R, unsigned ID, llvm::StringRef Blob,
                         Reference *I, FieldId &F) {
   switch (ID) {
   case REFERENCE_USR:
     return decodeRecord(R, I->USR, Blob);
   case REFERENCE_NAME:
     return decodeRecord(R, I->Name, Blob);
   case REFERENCE_TYPE:
     return decodeRecord(R, I->RefType, Blob);
   case REFERENCE_PATH:
     return decodeRecord(R, I->Path, Blob);
-  case REFERENCE_IS_IN_GLOBAL_NAMESPACE:
-    return decodeRecord(R, I->IsInGlobalNamespace, Blob);
   case REFERENCE_FIELD:
     return decodeRecord(R, F, Blob);
   default:
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "invalid field for Reference");
   }
 }
 

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

enum RecordId {
   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
 };
 
 static constexpr unsigned BlockIdCount = BI_LAST - BI_FIRST;
 static constexpr unsigned RecordIdCount = RI_LAST - RI_FIRST;
 

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

RecordIdNameMap = []() {
           {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}},
           {REFERENCE_TYPE, {"RefType", &IntAbbrev}},
           {REFERENCE_PATH, {"Path", &StringAbbrev}},
-          {REFERENCE_IS_IN_GLOBAL_NAMESPACE,
-           {"IsInGlobalNamespace", &BoolAbbrev}},
           {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;
RecordsByBlock{
           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}}};
+          REFERENCE_FIELD}}};
 
 // AbbreviationMap
 
 constexpr unsigned char BitCodeConstants::Signature[];
 
 void ClangDocBitcodeWriter::AbbreviationMap::add(RecordId RID,
                                                  unsigned AbbrevID) {
   assert(RecordIdNameMap[RID] && "Unknown RecordId.");

 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(R.Path, REFERENCE_PATH);
-  emitRecord(R.IsInGlobalNamespace, REFERENCE_IS_IN_GLOBAL_NAMESPACE);
   emitRecord((unsigned)Field, REFERENCE_FIELD);
 }
 
 void ClangDocBitcodeWriter::emitBlock(const TypeInfo &T) {
   StreamSubBlockGuard Block(Stream, BI_TYPE_BLOCK_ID);
   emitBlock(T.Type, FieldId::F_type);
 }
 

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

static std::unique_ptr<TagNode> genLink(const Twine &Text, const Twine &Link) {
   auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_A, Text);
   LinkNode->Attributes.emplace_back("href", Link.str());
   return LinkNode;
 }
 
 static std::unique_ptr<HTMLNode>
 genReference(const Reference &Type, StringRef CurrentDirectory,
              llvm::Optional<StringRef> JumpToSection = None) {
-  if (Type.Path.empty() && !Type.IsInGlobalNamespace) {
+  if (Type.Path.empty()) {
     if (!JumpToSection)
       return std::make_unique<TextNode>(Type.Name);
     else
       return genLink(Type.Name, "#" + *JumpToSection);
   }
   llvm::SmallString<64> Path = Type.getRelativeFilePath(CurrentDirectory);
   llvm::sys::path::append(Path, Type.getFileBaseName() + ".html");
 

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

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) : Name(Name) {}
-  // An empty path means the info is in the global namespace because the path is
-  // a composite of the parent namespaces.
-  Reference(llvm::StringRef Name, StringRef Path)
-      : Name(Name), Path(Path), IsInGlobalNamespace(Path.empty()) {}
-  Reference(SymbolID USR, StringRef Name, InfoType IT)
-      : USR(USR), Name(Name), RefType(IT) {}
-  // An empty path means the info is in the global namespace because the path is
-  // a composite of the parent namespaces.
-  Reference(SymbolID USR, StringRef Name, InfoType IT, StringRef Path)
-      : USR(USR), Name(Name), RefType(IT), Path(Path),
-        IsInGlobalNamespace(Path.empty()) {}
+  Reference(SymbolID USR = SymbolID(), StringRef Name = StringRef(),
+            InfoType IT = InfoType::IT_default, StringRef Path = StringRef())
+      : USR(USR), Name(Name), RefType(IT), Path(Path) {}
 
   bool operator==(const Reference &Other) const {
     return std::tie(USR, Name, RefType) ==
            std::tie(Other.USR, Other.Name, Other.RefType);
   }
 
   bool mergeable(const Reference &Other);
   void merge(Reference &&I);
 
   /// Returns the path for this Reference relative to CurrentPath.
   llvm::SmallString<64> getRelativeFilePath(const StringRef &CurrentPath) const;
 
   /// Returns the basename that should be used for this Reference.
   llvm::SmallString<16> getFileBaseName() const;
 
   SymbolID USR = SymbolID(); // Unique identifier 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).
   // Path of directory where the clang-doc generated file will be saved
   // (possibly unresolved)
   llvm::SmallString<128> Path;
-  // Indicates if the info's parent is the global namespace, or if the info is
-  // the global namespace
-  bool IsInGlobalNamespace = false;
 };
 
 // A base struct for TypeInfos
 struct TypeInfo {
   TypeInfo() = default;
   TypeInfo(const Reference &R) : Type(R) {}
 
-  TypeInfo(SymbolID Type, StringRef Field, InfoType IT)
-      : Type(Type, Field, IT) {}
-  TypeInfo(SymbolID Type, StringRef Field, InfoType IT, StringRef Path)
-      : Type(Type, Field, IT, Path) {}
-  TypeInfo(llvm::StringRef RefName) : Type(RefName) {}
-  TypeInfo(llvm::StringRef RefName, StringRef Path) : Type(RefName, Path) {}
+  // Convenience constructor for when there is no symbol ID or info type
+  // (normally used for built-in types in tests).
+  TypeInfo(StringRef Name, StringRef Path = StringRef())
+      : Type(SymbolID(), Name, InfoType::IT_default, Path) {}
 
   bool operator==(const TypeInfo &Other) const { return Type == Other.Type; }
 
   Reference Type; // Referenced type in this info.
 };
 
 // Info for field types.
 struct FieldTypeInfo : public TypeInfo {
   FieldTypeInfo() = default;
   FieldTypeInfo(const TypeInfo &TI, StringRef Name = StringRef(),
                 StringRef DefaultValue = StringRef())
       : TypeInfo(TI), Name(Name), DefaultValue(DefaultValue) {}
-  FieldTypeInfo(SymbolID Type, StringRef Field, InfoType IT, StringRef Path,
-                llvm::StringRef Name)
-      : TypeInfo(Type, Field, IT, Path), Name(Name) {}
-  FieldTypeInfo(llvm::StringRef RefName, llvm::StringRef Name)
-      : TypeInfo(RefName), Name(Name) {}
-  FieldTypeInfo(llvm::StringRef RefName, StringRef Path, llvm::StringRef Name)
-      : TypeInfo(RefName, Path), Name(Name) {}
 
   bool operator==(const FieldTypeInfo &Other) const {
     return std::tie(Type, Name, DefaultValue) ==
            std::tie(Other.Type, Other.Name, Other.DefaultValue);
   }
 
   SmallString<16> Name; // Name associated with this info.
 
   // When used for function parameters, contains the string representing the
   // expression of the default value, if any.
   SmallString<16> DefaultValue;
 };
 
 // Info for member types.
 struct MemberTypeInfo : public FieldTypeInfo {
   MemberTypeInfo() = default;
   MemberTypeInfo(const TypeInfo &TI, StringRef Name, AccessSpecifier Access)
       : FieldTypeInfo(TI, Name), Access(Access) {}
-  MemberTypeInfo(SymbolID Type, StringRef Field, InfoType IT, StringRef Path,
-                 llvm::StringRef Name, AccessSpecifier Access)
-      : FieldTypeInfo(Type, Field, IT, Path, Name), Access(Access) {}
-  MemberTypeInfo(llvm::StringRef RefName, llvm::StringRef Name,
-                 AccessSpecifier Access)
-      : FieldTypeInfo(RefName, Name), Access(Access) {}
-  MemberTypeInfo(llvm::StringRef RefName, StringRef Path, llvm::StringRef Name,
-                 AccessSpecifier Access)
-      : FieldTypeInfo(RefName, Path, Name), Access(Access) {}
 
   bool operator==(const MemberTypeInfo &Other) const {
     return std::tie(Type, Name, Access, Description) ==
            std::tie(Other.Type, Other.Name, Other.Access, Other.Description);
   }
 
   // Access level associated with this info (public, protected, private, none).
   // AS_public is set as default because the bitcode writer requires the enum
   // with value 0 to be used as the default.
   // (AS_public = 0, AS_protected = 1, AS_private = 2, AS_none = 3)
   AccessSpecifier Access = AccessSpecifier::AS_public;
 
   std::vector<CommentInfo> Description; // Comment description of this field.
 };
 
 struct Location {
-  Location() = default;
-  Location(int LineNumber, SmallString<16> Filename)
-      : LineNumber(LineNumber), Filename(std::move(Filename)) {}
-  Location(int LineNumber, SmallString<16> Filename, bool IsFileInRootDir)
-      : LineNumber(LineNumber), Filename(std::move(Filename)),
+  Location(int LineNumber = 0, StringRef Filename = StringRef(),
+           bool IsFileInRootDir = false)
+      : LineNumber(LineNumber), Filename(Filename),
         IsFileInRootDir(IsFileInRootDir) {}
 
   bool operator==(const Location &Other) const {
     return std::tie(LineNumber, Filename) ==
            std::tie(Other.LineNumber, Other.Filename);
   }
 
   // This operator is used to sort a vector of Locations.
   // No specific order (attributes more important than others) is required. Any
   // sort is enough, the order is only needed to call std::unique after sorting
   // the vector.
   bool operator<(const Location &Other) const {
     return std::tie(LineNumber, Filename) <
            std::tie(Other.LineNumber, Other.Filename);
   }
 
-  int LineNumber;               // Line number of this Location.
+  int LineNumber = 0;           // Line number of this Location.
   SmallString<32> Filename;     // File for this Location.
   bool IsFileInRootDir = false; // Indicates if file is inside root directory
 };
 
 /// A base struct for Infos.
 struct Info {
-  Info() = default;
-  Info(InfoType IT) : IT(IT) {}
-  Info(InfoType IT, SymbolID USR) : USR(USR), IT(IT) {}
-  Info(InfoType IT, SymbolID USR, StringRef Name)
-      : USR(USR), IT(IT), Name(Name) {}
-  Info(InfoType IT, SymbolID USR, StringRef Name, StringRef Path)
+  Info(InfoType IT = InfoType::IT_default, SymbolID USR = SymbolID(),
+       StringRef Name = StringRef(), StringRef Path = StringRef())
       : USR(USR), IT(IT), Name(Name), Path(Path) {}
+
   Info(const Info &Other) = delete;
   Info(Info &&Other) = default;
 
   virtual ~Info() = default;
 
   SymbolID USR =
       SymbolID(); // Unique identifier for the decl described by this Info.
   const InfoType IT = InfoType::IT_default; // InfoType of this particular Info.
struct Info {
 
   // Returns a reference to the parent scope (that is, the immediate parent
   // namespace or class in which this decl resides).
   llvm::Expected<Reference> getEnclosingScope();
 };
 
 // Info for namespaces.
 struct NamespaceInfo : public Info {
-  NamespaceInfo() : Info(InfoType::IT_namespace) {}
-  NamespaceInfo(SymbolID USR) : Info(InfoType::IT_namespace, USR) {}
-  NamespaceInfo(SymbolID USR, StringRef Name)
-      : Info(InfoType::IT_namespace, USR, Name) {}
-  NamespaceInfo(SymbolID USR, StringRef Name, StringRef Path)
+  NamespaceInfo(SymbolID USR = SymbolID(), StringRef Name = StringRef(),
+                StringRef Path = StringRef())
       : Info(InfoType::IT_namespace, USR, Name, Path) {}
 
   void merge(NamespaceInfo &&I);
 
   // Namespaces and 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> ChildNamespaces;
   std::vector<Reference> ChildRecords;
   std::vector<FunctionInfo> ChildFunctions;
   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)
+  SymbolInfo(InfoType IT, SymbolID USR = SymbolID(),
+             StringRef Name = StringRef(), StringRef Path = StringRef())
       : 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.
 // Info for functions.
 struct FunctionInfo : public SymbolInfo {
-  FunctionInfo() : SymbolInfo(InfoType::IT_function) {}
-  FunctionInfo(SymbolID USR) : SymbolInfo(InfoType::IT_function, USR) {}
+  FunctionInfo(SymbolID USR = SymbolID())
+      : SymbolInfo(InfoType::IT_function, USR) {}
 
   void merge(FunctionInfo &&I);
 
   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.
   // Access level for this method (public, private, protected, none).
   // AS_public is set as default because the bitcode writer requires the enum
   // with value 0 to be used as the default.
   // (AS_public = 0, AS_protected = 1, AS_private = 2, AS_none = 3)
   AccessSpecifier Access = AccessSpecifier::AS_public;
 };
 
 // TODO: Expand to allow for documenting templating, inheritance access,
 // friend classes
 // Info for types.
 struct RecordInfo : public SymbolInfo {
-  RecordInfo() : SymbolInfo(InfoType::IT_record) {}
-  RecordInfo(SymbolID USR) : SymbolInfo(InfoType::IT_record, USR) {}
-  RecordInfo(SymbolID USR, StringRef Name)
-      : SymbolInfo(InfoType::IT_record, USR, Name) {}
-  RecordInfo(SymbolID USR, StringRef Name, StringRef Path)
+  RecordInfo(SymbolID USR = SymbolID(), StringRef Name = StringRef(),
+             StringRef Path = StringRef())
       : SymbolInfo(InfoType::IT_record, USR, Name, Path) {}
 
   void merge(RecordInfo &&I);
 
   // Type of this record (struct, class, union, interface).
   TagTypeKind TagType = TagTypeKind::TTK_Struct;
 
   // Indicates if the record was declared using a typedef. Things like anonymous
struct EnumInfo : public SymbolInfo {
   // this will be "short".
   llvm::Optional<TypeInfo> BaseType;
 
   llvm::SmallVector<EnumValueInfo, 4> Members; // List of enum members.
 };
 
 struct Index : public Reference {
   Index() = default;
-  Index(StringRef Name) : Reference(Name) {}
+  Index(StringRef Name) : Reference(SymbolID(), Name) {}
   Index(StringRef Name, StringRef JumpToSection)
-      : Reference(Name), JumpToSection(JumpToSection) {}
+      : Reference(SymbolID(), Name), JumpToSection(JumpToSection) {}
   Index(SymbolID USR, StringRef Name, InfoType IT, StringRef Path)
       : Reference(USR, Name, IT, Path) {}
   // This is used to look for a USR in a vector of Indexes using std::find
   bool operator==(const SymbolID &Other) const { return USR == Other; }
   bool operator<(const Index &Other) const;
 
   llvm::Optional<SmallString<16>> JumpToSection;
   std::vector<Index> Children;

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

 }
 
 void Reference::merge(Reference &&Other) {
   assert(mergeable(Other));
   if (Name.empty())
     Name = Other.Name;
   if (Path.empty())
     Path = Other.Path;
-  if (!IsInGlobalNamespace)
-    IsInGlobalNamespace = Other.IsInGlobalNamespace;
 }
 
 void Info::mergeBase(Info &&Other) {
   assert(mergeable(Other));
   if (USR == EmptySID)
     USR = Other.USR;
   if (Name == "")
     Name = Other.Name;

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

static RecordDecl *getRecordDeclForType(const QualType &T) {
   if (const RecordDecl *D = T->getAsRecordDecl())
     return D->getDefinition();
   return nullptr;
 }
 
 TypeInfo getTypeInfoForType(const QualType &T) {
   const TagDecl *TD = getTagDeclForType(T);
   if (!TD)
-    return TypeInfo(Reference(T.getAsString()));
+    return TypeInfo(Reference(SymbolID(), T.getAsString()));
 
   InfoType IT;
   if (dyn_cast<EnumDecl>(TD)) {
     IT = InfoType::IT_enum;
   } else if (dyn_cast<RecordDecl>(TD)) {
     IT = InfoType::IT_record;
   } else {
     IT = InfoType::IT_default;
for (const CXXBaseSpecifier &B : D->bases()) {
     if (const auto *Ty = B.getType()->getAs<TemplateSpecializationType>()) {
       const TemplateDecl *D = Ty->getTemplateName().getAsTemplateDecl();
       I.Parents.emplace_back(getUSRForDecl(D), B.getType().getAsString(),
                              InfoType::IT_record);
     } else if (const RecordDecl *P = getRecordDeclForType(B.getType()))
       I.Parents.emplace_back(getUSRForDecl(P), P->getNameAsString(),
                              InfoType::IT_record, getInfoRelativePath(P));
     else
-      I.Parents.emplace_back(B.getType().getAsString());
+      I.Parents.emplace_back(SymbolID(), B.getType().getAsString());
   }
   for (const CXXBaseSpecifier &B : D->vbases()) {
     if (const RecordDecl *P = getRecordDeclForType(B.getType()))
       I.VirtualParents.emplace_back(getUSRForDecl(P), P->getNameAsString(),
                                     InfoType::IT_record,
                                     getInfoRelativePath(P));
     else
-      I.VirtualParents.emplace_back(B.getType().getAsString());
+      I.VirtualParents.emplace_back(SymbolID(), B.getType().getAsString());
   }
 }
 
 template <typename T>
 static void
 populateParentNamespaces(llvm::SmallVector<Reference, 4> &Namespaces,
                          const T *D, bool &IsInAnonymousNamespace) {
   const auto *DC = cast<DeclContext>(D);

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

 };
 
 template <> struct MappingTraits<Reference> {
   static void mapping(IO &IO, Reference &Ref) {
     IO.mapOptional("Type", Ref.RefType, InfoType::IT_default);
     IO.mapOptional("Name", Ref.Name, SmallString<16>());
     IO.mapOptional("USR", Ref.USR, SymbolID());
     IO.mapOptional("Path", Ref.Path, SmallString<128>());
-    IO.mapOptional("IsInGlobalNamespace", Ref.IsInGlobalNamespace, false);
   }
 };
 
 template <> struct MappingTraits<TypeInfo> {
   static void mapping(IO &IO, TypeInfo &I) { TypeInfoMapping(IO, I); }
 };
 
 template <> struct MappingTraits<FieldTypeInfo> {

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

 TEST(BitcodeTest, emitRecordInfoBitcode) {
   RecordInfo I;
   I.Name = "r";
   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.Members.emplace_back(TypeInfo("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.Bases.back().Members.emplace_back(TypeInfo("int"), "X",
+                                      AccessSpecifier::AS_private);
   I.Parents.emplace_back(EmptySID, "F", InfoType::IT_record);
   I.VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record);
 
   // Documentation for the data member.
   CommentInfo TopComment;
   TopComment.Kind = "FullComment";
   TopComment.Children.emplace_back(std::make_unique<CommentInfo>());
   CommentInfo *Brief = TopComment.Children.back().get();

 TEST(BitcodeTest, emitFunctionInfoBitcode) {
   FunctionInfo I;
   I.Name = "f";
   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.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
-  I.Params.emplace_back("int", "P");
+  I.ReturnType = TypeInfo("void");
+  I.Params.emplace_back(TypeInfo("int"), "P");
 
   I.Access = AccessSpecifier::AS_none;
 
   std::string WriteResult = writeInfo(&I);
   EXPECT_TRUE(WriteResult.size() > 0);
   std::vector<std::unique_ptr<Info>> ReadResults = readInfo(WriteResult, 1);
 
   CheckFunctionInfo(&I, InfoAsFunction(ReadResults[0].get()));
 }
 
 TEST(BitcodeTest, emitMethodInfoBitcode) {
   FunctionInfo I;
   I.Name = "f";
   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.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
-  I.Params.emplace_back("int", "P");
+  I.ReturnType = TypeInfo("void");
+  I.Params.emplace_back(TypeInfo("int"), "P");
   I.IsMethod = true;
   I.Parent = Reference(EmptySID, "Parent", InfoType::IT_record);
 
   I.Access = AccessSpecifier::AS_public;
 
   std::string WriteResult = writeInfo(&I);
   EXPECT_TRUE(WriteResult.size() > 0);
   std::vector<std::unique_ptr<Info>> ReadResults = readInfo(WriteResult, 1);
TEST(BitcodeTest, emitEnumInfoBitcode) {
   std::vector<std::unique_ptr<Info>> ReadResults = readInfo(WriteResult, 1);
 
   CheckEnumInfo(&I, InfoAsEnum(ReadResults[0].get()));
 }
 
 TEST(SerializeTest, emitInfoWithCommentBitcode) {
   FunctionInfo F;
   F.Name = "F";
-  F.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  F.ReturnType = TypeInfo("void");
   F.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
-  F.Params.emplace_back("int", "I");
+  F.Params.emplace_back(TypeInfo("int"), "I");
 
   CommentInfo Top;
   Top.Kind = "FullComment";
 
   Top.Children.emplace_back(std::make_unique<CommentInfo>());
   CommentInfo *BlankLine = Top.Children.back().get();
   BlankLine->Kind = "ParagraphComment";
   BlankLine->Children.emplace_back(std::make_unique<CommentInfo>());

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

TEST(GeneratorTest, emitIndex) {
   Index Idx;
   auto InfoA = std::make_unique<Info>();
   InfoA->Name = "A";
   InfoA->USR = serialize::hashUSR("1");
   Generator::addInfoToIndex(Idx, InfoA.get());
   auto InfoC = std::make_unique<Info>();
   InfoC->Name = "C";
   InfoC->USR = serialize::hashUSR("3");
-  Reference RefB = Reference("B");
+  Reference RefB = Reference(SymbolID(), "B");
   RefB.USR = serialize::hashUSR("2");
   InfoC->Namespace = {std::move(RefB)};
   Generator::addInfoToIndex(Idx, InfoC.get());
   auto InfoD = std::make_unique<Info>();
   InfoD->Name = "D";
   InfoD->USR = serialize::hashUSR("4");
   auto InfoF = std::make_unique<Info>();
   InfoF->Name = "F";
   InfoF->USR = serialize::hashUSR("6");
-  Reference RefD = Reference("D");
+  Reference RefD = Reference(SymbolID(), "D");
   RefD.USR = serialize::hashUSR("4");
-  Reference RefE = Reference("E");
+  Reference RefE = Reference(SymbolID(), "E");
   RefE.USR = serialize::hashUSR("5");
   InfoF->Namespace = {std::move(RefE), std::move(RefD)};
   Generator::addInfoToIndex(Idx, InfoF.get());
   auto InfoG = std::make_unique<Info>(InfoType::IT_namespace);
   Generator::addInfoToIndex(Idx, InfoG.get());
 
   Index ExpectedIdx;
   Index IndexA;

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

TEST(HTMLGeneratorTest, emitRecordHTML) {
   I.Path = "X/Y/Z";
   I.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 
   I.DefLoc = Location(10, llvm::SmallString<16>{"dir/test.cpp"}, true);
   I.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"});
 
   SmallString<16> PathTo;
   llvm::sys::path::native("path/to", PathTo);
-  I.Members.emplace_back("int", "X/Y", "X", AccessSpecifier::AS_private);
+  I.Members.emplace_back(TypeInfo("int", "X/Y"), "X",
+                         AccessSpecifier::AS_private);
   I.TagType = TagTypeKind::TTK_Class;
   I.Parents.emplace_back(EmptySID, "F", InfoType::IT_record, PathTo);
   I.VirtualParents.emplace_back(EmptySID, "G", InfoType::IT_record);
 
   I.ChildRecords.emplace_back(EmptySID, "ChildStruct", InfoType::IT_record,
                               "X/Y/Z/r");
   I.ChildFunctions.emplace_back();
   I.ChildFunctions.back().Name = "OneFunction";
TEST(HTMLGeneratorTest, emitFunctionHTML) {
 
   I.DefLoc = Location(10, llvm::SmallString<16>{"dir/test.cpp"}, false);
   I.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"});
 
   I.Access = AccessSpecifier::AS_none;
 
   SmallString<16> PathTo;
   llvm::sys::path::native("path/to", PathTo);
-  I.ReturnType = TypeInfo(EmptySID, "float", InfoType::IT_default, PathTo);
-  I.Params.emplace_back("int", PathTo, "P");
+  I.ReturnType =
+      TypeInfo(Reference(EmptySID, "float", InfoType::IT_default, PathTo));
+  I.Params.emplace_back(TypeInfo("int", PathTo), "P");
   I.IsMethod = true;
   I.Parent = Reference(EmptySID, "Parent", InfoType::IT_record);
 
   auto G = getHTMLGenerator();
   assert(G);
   std::string Buffer;
   llvm::raw_string_ostream Actual(Buffer);
   ClangDocContext CDCtx = getClangDocContext({}, "https://www.repository.com");
)raw";
 
   EXPECT_EQ(Expected, Actual.str());
 }
 
 TEST(HTMLGeneratorTest, emitCommentHTML) {
   FunctionInfo I;
   I.Name = "f";
   I.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
-  I.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
-  I.Params.emplace_back("int", "I");
-  I.Params.emplace_back("int", "J");
+  I.ReturnType = TypeInfo("void");
+  I.Params.emplace_back(TypeInfo("int"), "I");
+  I.Params.emplace_back(TypeInfo("int"), "J");
   I.Access = AccessSpecifier::AS_none;
 
   CommentInfo Top;
   Top.Kind = "FullComment";
 
   Top.Children.emplace_back(std::make_unique<CommentInfo>());
   CommentInfo *BlankLine = Top.Children.back().get();
   BlankLine->Kind = "ParagraphComment";

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

 TEST(MDGeneratorTest, emitRecordMD) {
   RecordInfo I;
   I.Name = "r";
   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.Members.emplace_back(TypeInfo("int"), "X", AccessSpecifier::AS_private);
   I.TagType = TagTypeKind::TTK_Class;
   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.ChildFunctions.back().Name = "OneFunction";
   I.ChildEnums.emplace_back();
TEST(MDGeneratorTest, emitFunctionMD) {
   I.Name = "f";
   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.Access = AccessSpecifier::AS_none;
 
-  I.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
-  I.Params.emplace_back("int", "P");
+  I.ReturnType = TypeInfo("void");
+  I.Params.emplace_back(TypeInfo("int"), "P");
   I.IsMethod = true;
   I.Parent = Reference(EmptySID, "Parent", InfoType::IT_record);
 
   auto G = getMDGenerator();
   assert(G);
   std::string Buffer;
   llvm::raw_string_ostream Actual(Buffer);
   auto Err = G->generateDocForInfo(&I, Actual, ClangDocContext());
)raw";
 
   EXPECT_EQ(Expected, Actual.str());
 }
 
 TEST(MDGeneratorTest, emitCommentMD) {
   FunctionInfo I;
   I.Name = "f";
   I.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
-  I.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
-  I.Params.emplace_back("int", "I");
-  I.Params.emplace_back("int", "J");
+  I.ReturnType = TypeInfo("void");
+  I.Params.emplace_back(TypeInfo("int"), "I");
+  I.Params.emplace_back(TypeInfo("int"), "J");
   I.Access = AccessSpecifier::AS_none;
 
   CommentInfo Top;
   Top.Kind = "FullComment";
 
   Top.Children.emplace_back(std::make_unique<CommentInfo>());
   CommentInfo *BlankLine = Top.Children.back().get();
   BlankLine->Kind = "ParagraphComment";

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

 TEST(MergeTest, mergeRecordInfos) {
   RecordInfo One;
   One.Name = "r";
   One.IsTypeDef = true;
   One.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 
   One.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
 
-  One.Members.emplace_back("int", "X", AccessSpecifier::AS_private);
+  One.Members.emplace_back(TypeInfo("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);
TEST(MergeTest, mergeRecordInfos) {
   auto Expected = std::make_unique<RecordInfo>();
   Expected->Name = "r";
   Expected->IsTypeDef = true;
   Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 
   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->Members.emplace_back(TypeInfo("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");
TEST(MergeTest, mergeFunctionInfos) {
   OneFullComment->Children.push_back(std::move(OneParagraphComment));
 
   FunctionInfo Two;
   Two.Name = "f";
   Two.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 
   Two.Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"});
 
-  Two.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
-  Two.Params.emplace_back("int", "P");
+  Two.ReturnType = TypeInfo("void");
+  Two.Params.emplace_back(TypeInfo("int"), "P");
 
   Two.Description.emplace_back();
   auto TwoFullComment = &Two.Description.back();
   TwoFullComment->Kind = "FullComment";
   auto TwoParagraphComment = std::make_unique<CommentInfo>();
   TwoParagraphComment->Kind = "ParagraphComment";
   auto TwoTextComment = std::make_unique<CommentInfo>();
   TwoTextComment->Kind = "TextComment";
   TwoTextComment->Text = "This is a text comment.";
   TwoParagraphComment->Children.push_back(std::move(TwoTextComment));
   TwoFullComment->Children.push_back(std::move(TwoParagraphComment));
 
   std::vector<std::unique_ptr<Info>> Infos;
   Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(One)));
   Infos.emplace_back(std::make_unique<FunctionInfo>(std::move(Two)));
 
   auto Expected = std::make_unique<FunctionInfo>();
   Expected->Name = "f";
   Expected->Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 
   Expected->DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
   Expected->Loc.emplace_back(12, llvm::SmallString<16>{"test.cpp"});
 
-  Expected->ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
-  Expected->Params.emplace_back("int", "P");
+  Expected->ReturnType = TypeInfo("void");
+  Expected->Params.emplace_back(TypeInfo("int"), "P");
   Expected->IsMethod = true;
   Expected->Parent = Reference(EmptySID, "Parent", InfoType::IT_namespace);
 
   Expected->Description.emplace_back();
   auto ExpectedFullComment = &Expected->Description.back();
   ExpectedFullComment->Kind = "FullComment";
   auto ExpectedParagraphComment = std::make_unique<CommentInfo>();
   ExpectedParagraphComment->Kind = "ParagraphComment";

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

TEST(SerializeTest, emitNamespaceInfo) {
   NamespaceInfo ExpectedB(EmptySID, /*Name=*/"B", /*Path=*/"A");
   ExpectedB.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
   CheckNamespaceInfo(&ExpectedB, B);
 
   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[4].get());
   NamespaceInfo ExpectedBWithFunction(EmptySID);
   FunctionInfo F;
   F.Name = "f";
-  F.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  F.ReturnType = TypeInfo("void");
   F.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   F.Namespace.emplace_back(EmptySID, "B", InfoType::IT_namespace);
   F.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
   F.Access = AccessSpecifier::AS_none;
   ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 }
 
typedef struct {} G;)raw",
                        10, /*Public=*/false, Infos);
 
   RecordInfo *E = InfoAsRecord(Infos[0].get());
   RecordInfo ExpectedE(EmptySID, /*Name=*/"E", /*Path=*/"GlobalNamespace");
   ExpectedE.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                    InfoType::IT_namespace);
   ExpectedE.TagType = TagTypeKind::TTK_Class;
   ExpectedE.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
-  ExpectedE.Members.emplace_back("int", "value", AccessSpecifier::AS_public);
+  ExpectedE.Members.emplace_back(TypeInfo("int"), "value",
+                                 AccessSpecifier::AS_public);
   // TODO the data member should have the docstring on it:
   //ExpectedE.Members.back().Description.push_back(MakeOneLineCommentInfo(" Some docs"));
   CheckRecordInfo(&ExpectedE, E);
 
   RecordInfo *RecordWithEConstructor = InfoAsRecord(Infos[2].get());
   RecordInfo ExpectedRecordWithEConstructor(EmptySID);
   FunctionInfo EConstructor;
   EConstructor.Name = "E";
   EConstructor.Parent = Reference(EmptySID, "E", InfoType::IT_record);
-  EConstructor.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  EConstructor.ReturnType = TypeInfo("void");
   EConstructor.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   EConstructor.Namespace.emplace_back(EmptySID, "E", InfoType::IT_record);
   EConstructor.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                       InfoType::IT_namespace);
   EConstructor.Access = AccessSpecifier::AS_public;
   EConstructor.IsMethod = true;
   ExpectedRecordWithEConstructor.ChildFunctions.emplace_back(
       std::move(EConstructor));
   CheckRecordInfo(&ExpectedRecordWithEConstructor, RecordWithEConstructor);
 
   RecordInfo *RecordWithMethod = InfoAsRecord(Infos[3].get());
   RecordInfo ExpectedRecordWithMethod(EmptySID);
   FunctionInfo Method;
   Method.Name = "ProtectedMethod";
   Method.Parent = Reference(EmptySID, "E", InfoType::IT_record);
-  Method.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  Method.ReturnType = TypeInfo("void");
   Method.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
   Method.Namespace.emplace_back(EmptySID, "E", InfoType::IT_record);
   Method.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                 InfoType::IT_namespace);
   Method.Access = AccessSpecifier::AS_protected;
   Method.IsMethod = true;
   ExpectedRecordWithMethod.ChildFunctions.emplace_back(std::move(Method));
   CheckRecordInfo(&ExpectedRecordWithMethod, RecordWithMethod);
 
   RecordInfo *F = InfoAsRecord(Infos[4].get());
   RecordInfo ExpectedF(EmptySID, /*Name=*/"F", /*Path=*/"GlobalNamespace");
   ExpectedF.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                    InfoType::IT_namespace);
   ExpectedF.TagType = TagTypeKind::TTK_Struct;
   ExpectedF.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   CheckRecordInfo(&ExpectedF, F);
 
   RecordInfo *RecordWithTemplateMethod = InfoAsRecord(Infos[6].get());
   RecordInfo ExpectedRecordWithTemplateMethod(EmptySID);
   FunctionInfo TemplateMethod;
   TemplateMethod.Name = "TemplateMethod";
   TemplateMethod.Parent = Reference(EmptySID, "F", InfoType::IT_record);
-  TemplateMethod.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  TemplateMethod.ReturnType = TypeInfo("void");
   TemplateMethod.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
   TemplateMethod.Namespace.emplace_back(EmptySID, "F", InfoType::IT_record);
   TemplateMethod.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                         InfoType::IT_namespace);
   TemplateMethod.Access = AccessSpecifier::AS_public;
   TemplateMethod.IsMethod = true;
   ExpectedRecordWithTemplateMethod.ChildFunctions.emplace_back(
       std::move(TemplateMethod));
   CheckRecordInfo(&ExpectedRecordWithTemplateMethod, RecordWithTemplateMethod);
 
   RecordInfo *TemplatedRecord = InfoAsRecord(Infos[7].get());
   RecordInfo ExpectedTemplatedRecord(EmptySID);
   FunctionInfo SpecializedTemplateMethod;
   SpecializedTemplateMethod.Name = "TemplateMethod";
   SpecializedTemplateMethod.Parent =
       Reference(EmptySID, "F", InfoType::IT_record);
-  SpecializedTemplateMethod.ReturnType =
-      TypeInfo(EmptySID, "void", InfoType::IT_default);
+  SpecializedTemplateMethod.ReturnType = TypeInfo("void");
   SpecializedTemplateMethod.Loc.emplace_back(0,
                                              llvm::SmallString<16>{"test.cpp"});
   SpecializedTemplateMethod.Namespace.emplace_back(EmptySID, "F",
                                                    InfoType::IT_record);
   SpecializedTemplateMethod.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                                    InfoType::IT_namespace);
   SpecializedTemplateMethod.Access = AccessSpecifier::AS_public;
   SpecializedTemplateMethod.IsMethod = true;
TEST(SerializeTest, emitRecordMemberInfo) {
   ExtractInfosFromCode("struct E { int I; };", 2, /*Public=*/false, Infos);
 
   RecordInfo *E = InfoAsRecord(Infos[0].get());
   RecordInfo ExpectedE(EmptySID, /*Name=*/"E", /*Path=*/"GlobalNamespace");
   ExpectedE.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                    InfoType::IT_namespace);
   ExpectedE.TagType = TagTypeKind::TTK_Struct;
   ExpectedE.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
-  ExpectedE.Members.emplace_back("int", "I", AccessSpecifier::AS_public);
+  ExpectedE.Members.emplace_back(TypeInfo("int"), "I",
+                                 AccessSpecifier::AS_public);
   CheckRecordInfo(&ExpectedE, E);
 }
 
 TEST(SerializeTest, emitInternalRecordInfo) {
   EmittedInfoList Infos;
   ExtractInfosFromCode("class E { class G {}; };", 4, /*Public=*/false, Infos);
 
   RecordInfo *E = InfoAsRecord(Infos[0].get());
TEST(SerializeTest, emitPublicFunctionInternalInfo) {
   EmittedInfoList Infos;
   ExtractInfosFromCode("int F() { class G {}; return 0; };", 1, /*Public=*/true,
                        Infos);
 
   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
   NamespaceInfo ExpectedBWithFunction(EmptySID);
   FunctionInfo F;
   F.Name = "F";
-  F.ReturnType = TypeInfo(EmptySID, "int", InfoType::IT_default);
+  F.ReturnType = TypeInfo("int");
   F.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   F.Access = AccessSpecifier::AS_none;
   ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 }
 
 TEST(SerializeTest, emitInlinedFunctionInfo) {
   EmittedInfoList Infos;
   ExtractInfosFromCode("inline void F(int I) { };", 1, /*Public=*/true, Infos);
 
   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
   NamespaceInfo ExpectedBWithFunction(EmptySID);
   FunctionInfo F;
   F.Name = "F";
-  F.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  F.ReturnType = TypeInfo("void");
   F.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
-  F.Params.emplace_back("int", "I");
+  F.Params.emplace_back(TypeInfo("int"), "I");
   F.Access = AccessSpecifier::AS_none;
   ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 }
 
 TEST(SerializeTest, emitInheritedRecordInfo) {
   EmittedInfoList Infos;
   ExtractInfosFromCode(R"raw(class F { protected: void set(int N); };
class J : public I<int> {} ;)raw",
   CheckRecordInfo(&ExpectedF, F);
 
   RecordInfo *G = InfoAsRecord(Infos[3].get());
   RecordInfo ExpectedG(EmptySID, /*Name=*/"G", /*Path=*/"GlobalNamespace");
   ExpectedG.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                    InfoType::IT_namespace);
   ExpectedG.TagType = TagTypeKind::TTK_Class;
   ExpectedG.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
-  ExpectedG.Members.emplace_back("int", "I", AccessSpecifier::AS_protected);
+  ExpectedG.Members.emplace_back(TypeInfo("int"), "I",
+                                 AccessSpecifier::AS_protected);
   CheckRecordInfo(&ExpectedG, G);
 
   RecordInfo *E = InfoAsRecord(Infos[6].get());
   RecordInfo ExpectedE(EmptySID, /*Name=*/"E", /*Path=*/"GlobalNamespace");
   ExpectedE.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                    InfoType::IT_namespace);
   ExpectedE.Parents.emplace_back(EmptySID, /*Name=*/"F", InfoType::IT_record,
                                  /*Path*=*/"GlobalNamespace");
   ExpectedE.VirtualParents.emplace_back(
       EmptySID, /*Name=*/"G", InfoType::IT_record, /*Path*=*/"GlobalNamespace");
   ExpectedE.Bases.emplace_back(EmptySID, /*Name=*/"F",
                                /*Path=*/"GlobalNamespace", false,
                                AccessSpecifier::AS_public, true);
   FunctionInfo FunctionSet;
   FunctionSet.Name = "set";
-  FunctionSet.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  FunctionSet.ReturnType = TypeInfo("void");
   FunctionSet.Loc.emplace_back();
-  FunctionSet.Params.emplace_back("int", "N");
+  FunctionSet.Params.emplace_back(TypeInfo("int"), "N");
   FunctionSet.Namespace.emplace_back(EmptySID, "F", InfoType::IT_record);
   FunctionSet.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                      InfoType::IT_namespace);
   FunctionSet.Access = AccessSpecifier::AS_protected;
   FunctionSet.IsMethod = true;
   ExpectedE.Bases.back().ChildFunctions.emplace_back(std::move(FunctionSet));
   ExpectedE.Bases.emplace_back(EmptySID, /*Name=*/"G",
                                /*Path=*/"GlobalNamespace", true,
                                AccessSpecifier::AS_private, true);
   FunctionInfo FunctionGet;
   FunctionGet.Name = "get";
-  FunctionGet.ReturnType = TypeInfo(EmptySID, "int", InfoType::IT_default);
+  FunctionGet.ReturnType = TypeInfo("int");
   FunctionGet.DefLoc = Location();
   FunctionGet.Namespace.emplace_back(EmptySID, "G", InfoType::IT_record);
   FunctionGet.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                      InfoType::IT_namespace);
   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",
+  ExpectedE.Bases.back().Members.emplace_back(TypeInfo("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[8].get());
   RecordInfo ExpectedH(EmptySID, /*Name=*/"H", /*Path=*/"GlobalNamespace");
   ExpectedH.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                    InfoType::IT_namespace);
   ExpectedH.TagType = TagTypeKind::TTK_Class;
   ExpectedH.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
   ExpectedH.Parents.emplace_back(EmptySID, /*Name=*/"E", InfoType::IT_record,
                                  /*Path=*/"GlobalNamespace");
   ExpectedH.VirtualParents.emplace_back(
       EmptySID, /*Name=*/"G", InfoType::IT_record, /*Path=*/"GlobalNamespace");
   ExpectedH.Bases.emplace_back(EmptySID, /*Name=*/"E",
                                /*Path=*/"GlobalNamespace", false,
                                AccessSpecifier::AS_private, true);
   ExpectedH.Bases.emplace_back(EmptySID, /*Name=*/"F",
                                /*Path=*/"GlobalNamespace", false,
                                AccessSpecifier::AS_private, false);
   FunctionInfo FunctionSetNew;
   FunctionSetNew.Name = "set";
-  FunctionSetNew.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
+  FunctionSetNew.ReturnType = TypeInfo("void");
   FunctionSetNew.Loc.emplace_back();
-  FunctionSetNew.Params.emplace_back("int", "N");
+  FunctionSetNew.Params.emplace_back(TypeInfo("int"), "N");
   FunctionSetNew.Namespace.emplace_back(EmptySID, "F", InfoType::IT_record);
   FunctionSetNew.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                         InfoType::IT_namespace);
   FunctionSetNew.Access = AccessSpecifier::AS_private;
   FunctionSetNew.IsMethod = true;
   ExpectedH.Bases.back().ChildFunctions.emplace_back(std::move(FunctionSetNew));
   ExpectedH.Bases.emplace_back(EmptySID, /*Name=*/"G",
                                /*Path=*/"GlobalNamespace", true,
                                AccessSpecifier::AS_private, false);
   FunctionInfo FunctionGetNew;
   FunctionGetNew.Name = "get";
-  FunctionGetNew.ReturnType = TypeInfo(EmptySID, "int", InfoType::IT_default);
+  FunctionGetNew.ReturnType = TypeInfo("int");
   FunctionGetNew.DefLoc = Location();
   FunctionGetNew.Namespace.emplace_back(EmptySID, "G", InfoType::IT_record);
   FunctionGetNew.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                         InfoType::IT_namespace);
   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",
+  ExpectedH.Bases.back().Members.emplace_back(TypeInfo("int"), "I",
                                               AccessSpecifier::AS_private);
   CheckRecordInfo(&ExpectedH, H);
 
   RecordInfo *I = InfoAsRecord(Infos[10].get());
   RecordInfo ExpectedI(EmptySID, /*Name=*/"I", /*Path=*/"GlobalNamespace");
   ExpectedI.Namespace.emplace_back(EmptySID, "GlobalNamespace",
                                    InfoType::IT_namespace);
   ExpectedI.TagType = TagTypeKind::TTK_Class;

 static int staticModuleFunction(int x);
 export double exportedModuleFunction(double y);)raw",
                                2, /*Public=*/true, Infos, Args);
 
   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
   NamespaceInfo ExpectedBWithFunction(EmptySID);
   FunctionInfo F;
   F.Name = "moduleFunction";
-  F.ReturnType = TypeInfo(EmptySID, "int", InfoType::IT_default);
+  F.ReturnType = TypeInfo("int");
   F.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
-  F.Params.emplace_back("int", "x");
-  F.Params.emplace_back("double", "d");
+  F.Params.emplace_back(TypeInfo("int"), "x");
+  F.Params.emplace_back(TypeInfo("double"), "d");
   F.Params.back().DefaultValue = "3.2 - 1.0";
   F.Access = AccessSpecifier::AS_none;
   ExpectedBWithFunction.ChildFunctions.emplace_back(std::move(F));
   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 
   NamespaceInfo *BWithExportedFunction = InfoAsNamespace(Infos[1].get());
   NamespaceInfo ExpectedBWithExportedFunction(EmptySID);
   FunctionInfo ExportedF;
   ExportedF.Name = "exportedModuleFunction";
-  ExportedF.ReturnType = TypeInfo(EmptySID, "double", InfoType::IT_default);
+  ExportedF.ReturnType =
+      TypeInfo(Reference(EmptySID, "double", InfoType::IT_default));
   ExportedF.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
-  ExportedF.Params.emplace_back("double", "y");
+  ExportedF.Params.emplace_back(TypeInfo("double"), "y");
   ExportedF.Access = AccessSpecifier::AS_none;
   ExpectedBWithExportedFunction.ChildFunctions.emplace_back(
       std::move(ExportedF));
   CheckNamespaceInfo(&ExpectedBWithExportedFunction, BWithExportedFunction);
 }
 
 // Test serialization of child records in namespaces and other records
 TEST(SerializeTest, emitChildRecords) {

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

TEST(YAMLGeneratorTest, emitRecordYAML) {
   I.Name = "r";
   I.Path = "path/to/A";
   I.IsTypeDef = true;
   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",
+  I.Members.emplace_back(TypeInfo("int", "path/to/int"), "X",
                          AccessSpecifier::AS_private);
 
   // Member documentation.
   CommentInfo TopComment;
   TopComment.Kind = "FullComment";
   TopComment.Children.emplace_back(std::make_unique<CommentInfo>());
   CommentInfo *Brief = TopComment.Children.back().get();
   Brief->Kind = "ParagraphComment";
   Brief->Children.emplace_back(std::make_unique<CommentInfo>());
   Brief->Children.back()->Kind = "TextComment";
   Brief->Children.back()->Name = "ParagraphComment";
   Brief->Children.back()->Text = "Value of the thing.";
   I.Members.back().Description.push_back(std::move(TopComment));
 
   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",
+  I.Bases.back().Members.emplace_back(TypeInfo("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");
ChildFunctions:
         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'
 ChildRecords:
   - Type:            Record
     Name:            'ChildStruct'
     Path:            'path/to/A/r'
TEST(YAMLGeneratorTest, emitFunctionYAML) {
   I.Name = "f";
   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.Access = AccessSpecifier::AS_none;
 
-  I.ReturnType =
-      TypeInfo(EmptySID, "void", InfoType::IT_default, "path/to/void");
-  I.Params.emplace_back("int", "path/to/int", "P");
-  I.Params.emplace_back("double", "path/to/double", "D");
+  I.ReturnType = TypeInfo(
+      Reference(EmptySID, "void", InfoType::IT_default, "path/to/void"));
+  I.Params.emplace_back(TypeInfo("int", "path/to/int"), "P");
+  I.Params.emplace_back(TypeInfo("double", "path/to/double"), "D");
   I.Params.back().DefaultValue = "2.0 * M_PI";
   I.IsMethod = true;
   I.Parent = Reference(EmptySID, "Parent", InfoType::IT_record);
 
   auto G = getYAMLGenerator();
   assert(G);
   std::string Buffer;
   llvm::raw_string_ostream Actual(Buffer);

 )raw";
   EXPECT_EQ(Expected, Actual.str());
 }
 
 TEST(YAMLGeneratorTest, emitCommentYAML) {
   FunctionInfo I;
   I.Name = "f";
   I.DefLoc = Location(10, llvm::SmallString<16>{"test.cpp"});
-  I.ReturnType = TypeInfo(EmptySID, "void", InfoType::IT_default);
-  I.Params.emplace_back("int", "I");
-  I.Params.emplace_back("int", "J");
+  I.ReturnType = TypeInfo("void");
+  I.Params.emplace_back(TypeInfo("int"), "I");
+  I.Params.emplace_back(TypeInfo("int"), "J");
   I.Access = AccessSpecifier::AS_none;
 
   CommentInfo Top;
   Top.Kind = "FullComment";
 
   Top.Children.emplace_back(std::make_unique<CommentInfo>());
   CommentInfo *BlankLine = Top.Children.back().get();
   BlankLine->Kind = "ParagraphComment";