ADT: Allow IntrusiveRefCntPtr construction from std::unique_ptr, NFC

[dexonsmith]

Summary

Allow a std::unique_ptr to be moved into the an IntrusiveRefCntPtr,
and remove a couple of now-unnecessary release() calls.

[dblaikie]

Looks good with one minor tweak

llvm/include/llvm/ADT/IntrusiveRefCntPtr.h

180

Pass 'S' by value here - that's the usual way to pass ownership of unique_ptr, and unlike the IntrusiveRefCntPtr's copy/move ctors there's no issue with invoking the operation in its implementation (infinitely recursively).

[dexonsmith]

Thanks for the review!

llvm/include/llvm/ADT/IntrusiveRefCntPtr.h

180

Right, thanks; I'll update it that way before pushing the commit.

[JDevlieghere]

LGTM

clang-tools-extra/clangd/support/ThreadsafeFS.cpp

ThreadsafeFS::view(PathRef CWD) const {
   return FS;
 }
 
 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 RealThreadsafeFS::viewImpl() const {
   // Avoid using memory-mapped files.
   // FIXME: Try to use a similar approach in Sema instead of relying on
   //        propagation of the 'isVolatile' flag through all layers.
-  return new VolatileFileSystem(
-      llvm::vfs::createPhysicalFileSystem().release());
+  return new VolatileFileSystem(llvm::vfs::createPhysicalFileSystem());
 }
 } // namespace clangd
 } // namespace clang

clang/lib/Tooling/AllTUsExecution.cpp

auto &Action = Actions.front();
     for (std::string File : Files) {
       Pool.async(
           [&](std::string Path) {
             Log("[" + std::to_string(Count()) + "/" + TotalNumStr +
                 "] Processing file " + Path);
             // Each thread gets an indepent copy of a VFS to allow different
             // concurrent working directories.
             IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS =
-                llvm::vfs::createPhysicalFileSystem().release();
+                llvm::vfs::createPhysicalFileSystem();
             ClangTool Tool(Compilations, {Path},
                            std::make_shared<PCHContainerOperations>(), FS);
             Tool.appendArgumentsAdjuster(Action.second);
             Tool.appendArgumentsAdjuster(getDefaultArgumentsAdjusters());
             for (const auto &FileAndContent : OverlayFiles)
               Tool.mapVirtualFile(FileAndContent.first(),
                                   FileAndContent.second);
             if (Tool.run(Action.first.get()))

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

 
 } // end anonymous namespace
 
 DependencyScanningWorker::DependencyScanningWorker(
     DependencyScanningService &Service)
     : Format(Service.getFormat()) {
   DiagOpts = new DiagnosticOptions();
   PCHContainerOps = std::make_shared<PCHContainerOperations>();
-  RealFS = llvm::vfs::createPhysicalFileSystem().release();
+  RealFS = llvm::vfs::createPhysicalFileSystem();
   if (Service.canSkipExcludedPPRanges())
     PPSkipMappings =
         std::make_unique<ExcludedPreprocessorDirectiveSkipMapping>();
   if (Service.getMode() == ScanningMode::MinimizedSourcePreprocessing)
     DepFS = new DependencyScanningWorkerFilesystem(
         Service.getSharedCache(), RealFS, PPSkipMappings.get());
   if (Service.canReuseFileManager())
     Files = new FileManager(FileSystemOptions(), RealFS);

llvm/include/llvm/ADT/IntrusiveRefCntPtr.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_INTRUSIVEREFCNTPTR_H
 #define LLVM_ADT_INTRUSIVEREFCNTPTR_H
 
 #include <atomic>
 #include <cassert>
 #include <cstddef>
+#include <memory>
 
 namespace llvm {
 
 /// A CRTP mixin class that adds reference counting to a type.
 ///
 /// The lifetime of an object which inherits from RefCountedBase is managed by
 /// calls to Release() and Retain(), which increment and decrement the object's
 /// refcount, respectively.  When a Release() call decrements the refcount to 0,
public:
   IntrusiveRefCntPtr(IntrusiveRefCntPtr &&S) : Obj(S.Obj) { S.Obj = nullptr; }
 
   template <class X>
   IntrusiveRefCntPtr(IntrusiveRefCntPtr<X> &&S) : Obj(S.get()) {
     S.Obj = nullptr;
   }
 
   template <class X>
+  IntrusiveRefCntPtr(std::unique_ptr<X> &&S) : Obj(S.release()) {
+    retain();
+  }
+
+  template <class X>
   IntrusiveRefCntPtr(const IntrusiveRefCntPtr<X> &S) : Obj(S.get()) {
     retain();
   }
 
   ~IntrusiveRefCntPtr() { release(); }
 
   IntrusiveRefCntPtr &operator=(IntrusiveRefCntPtr S) {
     swap(S);

llvm/unittests/ADT/IntrusiveRefCntPtrTest.cpp

EXPECT_EQ(0, NumInstances);
     IntrusiveRefCntPtr<TypeParam> R1 = S1;
     TypeParam *S2 = new TypeParam(*S1);
     IntrusiveRefCntPtr<TypeParam> R2 = S2;
     EXPECT_EQ(2, NumInstances);
   }
   EXPECT_EQ(0, NumInstances);
 }
 
+TYPED_TEST(IntrusiveRefCntPtrTest, InteropsWithUniquePtr) {
+  EXPECT_EQ(0, NumInstances);
+  {
+    auto S1 = std::make_unique<TypeParam>();
+    IntrusiveRefCntPtr<TypeParam> R1 = std::move(S1);
+    EXPECT_EQ(1, NumInstances);
+    EXPECT_EQ(S1, nullptr);
+  }
+  EXPECT_EQ(0, NumInstances);
+}
+
 struct InterceptRefCounted : public RefCountedBase<InterceptRefCounted> {
   InterceptRefCounted(bool *Released, bool *Retained)
     : Released(Released), Retained(Retained) {}
   bool * const Released;
   bool * const Retained;
 };
 template <> struct IntrusiveRefCntPtrInfo<InterceptRefCounted> {
   static void retain(InterceptRefCounted *I) {