[clang-doc] Fix memory leaks

[juliehockett]

Summary

Adds a virtual destructor to the base Info class.

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

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(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.
   SmallString<16> Name;                     // Unqualified name of the decl.
   llvm::SmallVector<Reference, 4>
       Namespace; // List of parent namespaces for this decl.
   std::vector<CommentInfo> Description; // Comment description of this decl.
 

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

std::unique_ptr<Info> emitInfo(const FunctionDecl *D, const FullComment *FC,
   Func.Access = clang::AccessSpecifier::AS_none;
 
   // Wrap in enclosing scope
   auto I = llvm::make_unique<NamespaceInfo>();
   if (!Func.Namespace.empty())
     I->USR = Func.Namespace[0].USR;
   else
     I->USR = SymbolID();
-  I->ChildFunctions.push_back(std::move(Func));
+  I->ChildFunctions.emplace_back(std::move(Func));
   return std::unique_ptr<Info>{std::move(I)};
 }
 
 std::unique_ptr<Info> emitInfo(const CXXMethodDecl *D, const FullComment *FC,
                                int LineNumber, llvm::StringRef File,
                                bool PublicOnly) {
   if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
     return nullptr;
   FunctionInfo Func;
   populateFunctionInfo(Func, D, FC, LineNumber, File);
   Func.IsMethod = true;
 
   SymbolID ParentUSR = getUSRForDecl(D->getParent());
   Func.Parent = Reference{ParentUSR, D->getParent()->getNameAsString(),
                           InfoType::IT_record};
   Func.Access = D->getAccess();
 
   // Wrap in enclosing scope
   auto I = llvm::make_unique<RecordInfo>();
   I->USR = ParentUSR;
-  I->ChildFunctions.push_back(std::move(Func));
+  I->ChildFunctions.emplace_back(std::move(Func));
   return std::unique_ptr<Info>{std::move(I)};
 }
 
 std::unique_ptr<Info> emitInfo(const EnumDecl *D, const FullComment *FC,
                                int LineNumber, llvm::StringRef File,
                                bool PublicOnly) {
   if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
     return nullptr;
   EnumInfo Enum;
   populateSymbolInfo(Enum, D, FC, LineNumber, File);
   Enum.Scoped = D->isScoped();
   parseEnumerators(Enum, D);
 
   // Wrap in enclosing scope
   if (!Enum.Namespace.empty()) {
     switch (Enum.Namespace[0].RefType) {
     case InfoType::IT_namespace: {
       auto I = llvm::make_unique<NamespaceInfo>();
       I->USR = Enum.Namespace[0].USR;
-      I->ChildEnums.push_back(std::move(Enum));
+      I->ChildEnums.emplace_back(std::move(Enum));
       return std::unique_ptr<Info>{std::move(I)};
     }
     case InfoType::IT_record: {
       auto I = llvm::make_unique<RecordInfo>();
       I->USR = Enum.Namespace[0].USR;
-      I->ChildEnums.push_back(std::move(Enum));
+      I->ChildEnums.emplace_back(std::move(Enum));
       return std::unique_ptr<Info>{std::move(I)};
     }
     default:
       break;
     }
   }
 
   // Put in global namespace
   auto I = llvm::make_unique<NamespaceInfo>();
   I->USR = SymbolID();
-  I->ChildEnums.push_back(std::move(Enum));
+  I->ChildEnums.emplace_back(std::move(Enum));
   return std::unique_ptr<Info>{std::move(I)};
 }
 
 } // namespace serialize
 } // namespace doc
 } // namespace clang