[clang-doc] Fix unique_ptr error on bots

[juliehockett]

Summary

Explicitly declare the return unique_ptr instead of using auto type deduction, as some of the bots' older compilers don't support some C++11 type deduction features.

[jakehehrlich]

Make sure the commit message reflects this change but other than that LGTM

clang-doc/Serialize.cpp

 std::unique_ptr<Info> emitInfo(const NamespaceDecl *D, const FullComment *FC,
                                int LineNumber, llvm::StringRef File,
                                bool PublicOnly) {
   if (PublicOnly && ((D->isAnonymousNamespace()) ||
                      !isPublic(D->getAccess(), D->getLinkageInternal())))
     return nullptr;
   auto I = llvm::make_unique<NamespaceInfo>();
   populateInfo(*I, D, FC);
-  return I;
+  return std::unique_ptr<Info>{std::move(I)};
 }
 
 std::unique_ptr<Info> emitInfo(const RecordDecl *D, const FullComment *FC,
                                int LineNumber, llvm::StringRef File,
                                bool PublicOnly) {
   if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
     return nullptr;
   auto I = llvm::make_unique<RecordInfo>();
   populateSymbolInfo(*I, D, FC, LineNumber, File);
   I->TagType = D->getTagKind();
   parseFields(*I, D, PublicOnly);
   if (const auto *C = dyn_cast<CXXRecordDecl>(D))
     parseBases(*I, C);
-  return I;
+  return std::unique_ptr<Info>{std::move(I)};
 }
 
 std::unique_ptr<Info> emitInfo(const FunctionDecl *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.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));
-  return I;
+  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));
-  return I;
+  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: {
-      std::unique_ptr<Info> IPtr = llvm::make_unique<NamespaceInfo>();
-      NamespaceInfo *I = static_cast<NamespaceInfo *>(IPtr.get());
+      auto I = llvm::make_unique<NamespaceInfo>();
       I->USR = Enum.Namespace[0].USR;
       I->ChildEnums.push_back(std::move(Enum));
-      return IPtr;
+      return std::unique_ptr<Info>{std::move(I)};
     }
     case InfoType::IT_record: {
-      std::unique_ptr<Info> IPtr = llvm::make_unique<RecordInfo>();
-      RecordInfo *I = static_cast<RecordInfo *>(IPtr.get());
+      auto I = llvm::make_unique<RecordInfo>();
       I->USR = Enum.Namespace[0].USR;
       I->ChildEnums.push_back(std::move(Enum));
-      return IPtr;
+      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));
-  return I;
+  return std::unique_ptr<Info>{std::move(I)};
 }
 
 } // namespace serialize
 } // namespace doc
 } // namespace clang