Change vfs::FileSystem to be managed with std::shared_ptr

[resistor]

Summary

Managing it with IntrusiveRefCntPtr caused the virtual destructor not to be called properly.

include/clang/Basic/FileManager.h

 
 #ifndef LLVM_CLANG_BASIC_FILEMANAGER_H
 #define LLVM_CLANG_BASIC_FILEMANAGER_H
 
 #include "clang/Basic/FileSystemOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/VirtualFileSystem.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include <memory>
 #include <map>
 
 namespace llvm {

 /// \brief Implements support for file system lookup, file system caching,
 /// and directory search management.
 ///
 /// This also handles more advanced properties, such as uniquing files based
 /// on "inode", so that a file with two names (e.g. symlinked) will be treated
 /// as a single file.
 ///
 class FileManager : public RefCountedBase<FileManager> {
-  IntrusiveRefCntPtr<vfs::FileSystem> FS;
+  std::shared_ptr<vfs::FileSystem> FS;
   FileSystemOptions FileSystemOpts;
 
   /// \brief Cache for existing real directories.
   std::map<llvm::sys::fs::UniqueID, DirectoryEntry> UniqueRealDirs;
 
   /// \brief Cache for existing real files.
   std::map<llvm::sys::fs::UniqueID, FileEntry> UniqueRealFiles;
 
bool getStatValue(const char *Path, FileData &Data, bool isFile,
                     std::unique_ptr<vfs::File> *F);
 
   /// Add all ancestors of the given path (pointing to either a file
   /// or a directory) as virtual directories.
   void addAncestorsAsVirtualDirs(StringRef Path);
 
 public:
   FileManager(const FileSystemOptions &FileSystemOpts,
-              IntrusiveRefCntPtr<vfs::FileSystem> FS = nullptr);
+              std::shared_ptr<vfs::FileSystem> FS = nullptr);
   ~FileManager();
 
   /// \brief Installs the provided FileSystemStatCache object within
   /// the FileManager.
   ///
   /// Ownership of this object is transferred to the FileManager.
   ///
   /// \param statCache the new stat cache to install. Ownership of this
public:
   /// the failure to find this file.
   const FileEntry *getFile(StringRef Filename, bool OpenFile = false,
                            bool CacheFailure = true);
 
   /// \brief Returns the current file system options
   FileSystemOptions &getFileSystemOpts() { return FileSystemOpts; }
   const FileSystemOptions &getFileSystemOpts() const { return FileSystemOpts; }
 
-  IntrusiveRefCntPtr<vfs::FileSystem> getVirtualFileSystem() const {
+  std::shared_ptr<vfs::FileSystem> getVirtualFileSystem() const {
     return FS;
   }
 
   /// \brief Retrieve a file entry for a "virtual" file that acts as
   /// if there were a file with the given name on disk.
   ///
   /// The file itself is not accessed.
   const FileEntry *getVirtualFile(StringRef Filename, off_t Size,

include/clang/Basic/VirtualFileSystem.h

 //===- VirtualFileSystem.h - Virtual File System Layer ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// \brief Defines the virtual file system interface vfs::FileSystem.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_VIRTUALFILESYSTEM_H
 #define LLVM_CLANG_BASIC_VIRTUALFILESYSTEM_H
 
 #include "clang/Basic/LLVM.h"
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 class MemoryBuffer;
bool operator==(const recursive_directory_iterator &Other) const {
     return State == Other.State; // identity
   }
   bool operator!=(const recursive_directory_iterator &RHS) const {
     return !(*this == RHS);
   }
 };
 
 /// \brief The virtual file system interface.
-class FileSystem : public llvm::ThreadSafeRefCountedBase<FileSystem> {
+class FileSystem {
 public:
   virtual ~FileSystem();
 
   /// \brief Get the status of the entry at \p Path, if one exists.
   virtual llvm::ErrorOr<Status> status(const Twine &Path) = 0;
   /// \brief Get a \p File object for the file at \p Path, if one exists.
   virtual llvm::ErrorOr<std::unique_ptr<File>>
   openFileForRead(const Twine &Path) = 0;
public:
   /// \param Path A path that is modified to be an absolute path.
   /// \returns success if \a path has been made absolute, otherwise a
   ///          platform-specific error_code.
   std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const;
 };
 
 /// \brief Gets an \p vfs::FileSystem for the 'real' file system, as seen by
 /// the operating system.
-IntrusiveRefCntPtr<FileSystem> getRealFileSystem();
+std::shared_ptr<FileSystem> getRealFileSystem();
 
 /// \brief A file system that allows overlaying one \p AbstractFileSystem on top
 /// of another.
 ///
 /// Consists of a stack of >=1 \p FileSystem objects, which are treated as being
 /// one merged file system. When there is a directory that exists in more than
 /// one file system, the \p OverlayFileSystem contains a directory containing
 /// the union of their contents.  The attributes (permissions, etc.) of the
 /// top-most (most recently added) directory are used.  When there is a file
 /// that exists in more than one file system, the file in the top-most file
 /// system overrides the other(s).
 class OverlayFileSystem : public FileSystem {
-  typedef SmallVector<IntrusiveRefCntPtr<FileSystem>, 1> FileSystemList;
+  typedef SmallVector<std::shared_ptr<FileSystem>, 1> FileSystemList;
   /// \brief The stack of file systems, implemented as a list in order of
   /// their addition.
   FileSystemList FSList;
 
 public:
-  OverlayFileSystem(IntrusiveRefCntPtr<FileSystem> Base);
+  OverlayFileSystem(std::shared_ptr<FileSystem> Base);
   /// \brief Pushes a file system on top of the stack.
-  void pushOverlay(IntrusiveRefCntPtr<FileSystem> FS);
+  void pushOverlay(std::shared_ptr<FileSystem> FS);
 
   llvm::ErrorOr<Status> status(const Twine &Path) override;
   llvm::ErrorOr<std::unique_ptr<File>>
   openFileForRead(const Twine &Path) override;
   directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;
   llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override;
   std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
 
public:
   std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
 };
 
 /// \brief Get a globally unique ID for a virtual file or directory.
 llvm::sys::fs::UniqueID getNextVirtualUniqueID();
 
 /// \brief Gets a \p FileSystem for a virtual file system described in YAML
 /// format.
-IntrusiveRefCntPtr<FileSystem>
+std::shared_ptr<FileSystem>
 getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                llvm::SourceMgr::DiagHandlerTy DiagHandler,
                void *DiagContext = nullptr,
-               IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem());
+               std::shared_ptr<FileSystem> ExternalFS = getRealFileSystem());
 
 struct YAMLVFSEntry {
   template <typename T1, typename T2> YAMLVFSEntry(T1 &&VPath, T2 &&RPath)
       : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)) {}
   std::string VPath;
   std::string RPath;
 };
 

include/clang/Driver/Driver.h

 
 /// Driver - Encapsulate logic for constructing compilation processes
 /// from a set of gcc-driver-like command line arguments.
 class Driver {
   llvm::opt::OptTable *Opts;
 
   DiagnosticsEngine &Diags;
 
-  IntrusiveRefCntPtr<vfs::FileSystem> VFS;
+  std::shared_ptr<vfs::FileSystem> VFS;
 
   enum DriverMode {
     GCCMode,
     GXXMode,
     CPPMode,
     CLMode
   } Mode;
 
private:
   void setUpResponseFiles(Compilation &C, Command &Cmd);
 
   void generatePrefixedToolNames(const char *Tool, const ToolChain &TC,
                                  SmallVectorImpl<std::string> &Names) const;
 
 public:
   Driver(StringRef ClangExecutable, StringRef DefaultTargetTriple,
          DiagnosticsEngine &Diags,
-         IntrusiveRefCntPtr<vfs::FileSystem> VFS = nullptr);
+         std::shared_ptr<vfs::FileSystem> VFS = nullptr);
   ~Driver();
 
   /// @name Accessors
   /// @{
 
   /// Name to use when invoking gcc/g++.
   const std::string &getCCCGenericGCCName() const { return CCCGenericGCCName; }
 

include/clang/Frontend/CompilerInstance.h

class CompilerInstance : public ModuleLoader {
 
   /// The target being compiled for.
   IntrusiveRefCntPtr<TargetInfo> Target;
 
   /// Auxiliary Target info.
   IntrusiveRefCntPtr<TargetInfo> AuxTarget;
 
   /// The virtual file system.
-  IntrusiveRefCntPtr<vfs::FileSystem> VirtualFileSystem;
+  std::shared_ptr<vfs::FileSystem> VirtualFileSystem;
 
   /// The file manager.
   IntrusiveRefCntPtr<FileManager> FileMgr;
 
   /// The source manager.
   IntrusiveRefCntPtr<SourceManager> SourceMgr;
 
   /// The preprocessor.
public:
   void setAuxTarget(TargetInfo *Value);
 
   /// }
   /// @name Virtual File System
   /// {
 
   bool hasVirtualFileSystem() const { return VirtualFileSystem != nullptr; }
 
-  vfs::FileSystem &getVirtualFileSystem() const {
+  std::shared_ptr<vfs::FileSystem> getVirtualFileSystem() const {
     assert(hasVirtualFileSystem() &&
            "Compiler instance has no virtual file system");
-    return *VirtualFileSystem;
+    return VirtualFileSystem;
   }
 
   /// \brief Replace the current virtual file system.
   ///
   /// \note Most clients should use setFileManager, which will implicitly reset
   /// the virtual file system to the one contained in the file manager.
-  void setVirtualFileSystem(IntrusiveRefCntPtr<vfs::FileSystem> FS) {
+  void setVirtualFileSystem(std::shared_ptr<vfs::FileSystem> FS) {
     VirtualFileSystem = FS;
   }
 
   /// }
   /// @name File Manager
   /// {
 
   bool hasFileManager() const { return FileMgr != nullptr; }

include/clang/Frontend/CompilerInvocation.h

public:
 
   /// @}
 };
 
 namespace vfs {
   class FileSystem;
 }
 
-IntrusiveRefCntPtr<vfs::FileSystem>
+std::shared_ptr<vfs::FileSystem>
 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
                                 DiagnosticsEngine &Diags);
 
 } // end namespace clang
 
 #endif

include/clang/Tooling/Tooling.h

public:
   /// The file manager is shared between all translation units.
   FileManager &getFiles() { return *Files; }
 
  private:
   const CompilationDatabase &Compilations;
   std::vector<std::string> SourcePaths;
   std::shared_ptr<PCHContainerOperations> PCHContainerOps;
 
-  llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem;
-  llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem;
+  std::shared_ptr<vfs::OverlayFileSystem> OverlayFileSystem;
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem;
   llvm::IntrusiveRefCntPtr<FileManager> Files;
   // Contains a list of pairs (<file name>, <file content>).
   std::vector< std::pair<StringRef, StringRef> > MappedFileContents;
   llvm::StringSet<> SeenWorkingDirectories;
 
   ArgumentsAdjuster ArgsAdjuster;
 
   DiagnosticConsumer *DiagConsumer;

lib/Basic/FileManager.cpp

 /// represent a filename that doesn't exist on the disk.
 #define NON_EXISTENT_FILE reinterpret_cast<FileEntry*>((intptr_t)-1)
 
 //===----------------------------------------------------------------------===//
 // Common logic.
 //===----------------------------------------------------------------------===//
 
 FileManager::FileManager(const FileSystemOptions &FSO,
-                         IntrusiveRefCntPtr<vfs::FileSystem> FS)
+                         std::shared_ptr<vfs::FileSystem> FS)
   : FS(FS), FileSystemOpts(FSO),
     SeenDirEntries(64), SeenFileEntries(64), NextFileUID(0) {
   NumDirLookups = NumFileLookups = 0;
   NumDirCacheMisses = NumFileCacheMisses = 0;
 
   // If the caller doesn't provide a virtual file system, just grab the real
   // file system.
   if (!FS)

lib/Basic/VirtualFileSystem.cpp

std::error_code RealFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
   // file system abstraction that allows openat() style interactions.
   SmallString<256> Storage;
   StringRef Dir = Path.toNullTerminatedStringRef(Storage);
   if (int Err = ::chdir(Dir.data()))
     return std::error_code(Err, std::generic_category());
   return std::error_code();
 }
 
-IntrusiveRefCntPtr<FileSystem> vfs::getRealFileSystem() {
-  static IntrusiveRefCntPtr<FileSystem> FS = new RealFileSystem();
+std::shared_ptr<FileSystem> vfs::getRealFileSystem() {
+  static std::shared_ptr<FileSystem> FS(new RealFileSystem());
   return FS;
 }
 
 namespace {
 class RealFSDirIter : public clang::vfs::detail::DirIterImpl {
   std::string Path;
   llvm::sys::fs::directory_iterator Iter;
 public:

 directory_iterator RealFileSystem::dir_begin(const Twine &Dir,
                                              std::error_code &EC) {
   return directory_iterator(std::make_shared<RealFSDirIter>(Dir, EC));
 }
 
 //===-----------------------------------------------------------------------===/
 // OverlayFileSystem implementation
 //===-----------------------------------------------------------------------===/
-OverlayFileSystem::OverlayFileSystem(IntrusiveRefCntPtr<FileSystem> BaseFS) {
+OverlayFileSystem::OverlayFileSystem(std::shared_ptr<FileSystem> BaseFS) {
   FSList.push_back(BaseFS);
 }
 
-void OverlayFileSystem::pushOverlay(IntrusiveRefCntPtr<FileSystem> FS) {
+void OverlayFileSystem::pushOverlay(std::shared_ptr<FileSystem> FS) {
   FSList.push_back(FS);
   // Synchronize added file systems by duplicating the working directory from
   // the first one in the list.
   FS->setCurrentWorkingDirectory(getCurrentWorkingDirectory().get());
 }
 
 ErrorOr<Status> OverlayFileSystem::status(const Twine &Path) {
   // FIXME: handle symlinks that cross file systems

 ///
 /// In both cases, the 'name' field may contain multiple path components (e.g.
 /// /path/to/file). However, any directory that contains more than one child
 /// must be uniquely represented by a directory entry.
 class RedirectingFileSystem : public vfs::FileSystem {
   /// The root(s) of the virtual file system.
   std::vector<std::unique_ptr<Entry>> Roots;
   /// \brief The file system to use for external references.
-  IntrusiveRefCntPtr<FileSystem> ExternalFS;
+  std::shared_ptr<FileSystem> ExternalFS;
 
   /// @name Configuration
   /// @{
 
   /// \brief Whether to perform case-sensitive comparisons.
   ///
   /// Currently, case-insensitive matching only works correctly with ASCII.
   bool CaseSensitive;
 
   /// \brief Whether to use to use the value of 'external-contents' for the
   /// names of files.  This global value is overridable on a per-file basis.
   bool UseExternalNames;
   /// @}
 
   friend class RedirectingFileSystemParser;
 
 private:
-  RedirectingFileSystem(IntrusiveRefCntPtr<FileSystem> ExternalFS)
+  RedirectingFileSystem(std::shared_ptr<FileSystem> ExternalFS)
       : ExternalFS(ExternalFS), CaseSensitive(true), UseExternalNames(true) {}
 
   /// \brief Looks up \p Path in \c Roots.
   ErrorOr<Entry *> lookupPath(const Twine &Path);
 
   /// \brief Looks up the path <tt>[Start, End)</tt> in \p From, possibly
   /// recursing into the contents of \p From if it is a directory.
   ErrorOr<Entry *> lookupPath(sys::path::const_iterator Start,
                               sys::path::const_iterator End, Entry *From);
 
   /// \brief Get the status of a given an \c Entry.
   ErrorOr<Status> status(const Twine &Path, Entry *E);
 
 public:
   /// \brief Parses \p Buffer, which is expected to be in YAML format and
   /// returns a virtual file system representing its contents.
   static RedirectingFileSystem *
   create(std::unique_ptr<MemoryBuffer> Buffer,
          SourceMgr::DiagHandlerTy DiagHandler, void *DiagContext,
-         IntrusiveRefCntPtr<FileSystem> ExternalFS);
+         std::shared_ptr<FileSystem> ExternalFS);
 
   ErrorOr<Status> status(const Twine &Path) override;
   ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;
 
   llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override {
     return ExternalFS->getCurrentWorkingDirectory();
   }
   std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
public:
   }
 };
 } // end of anonymous namespace
 
 Entry::~Entry() = default;
 
 RedirectingFileSystem *RedirectingFileSystem::create(
     std::unique_ptr<MemoryBuffer> Buffer, SourceMgr::DiagHandlerTy DiagHandler,
-    void *DiagContext, IntrusiveRefCntPtr<FileSystem> ExternalFS) {
+    void *DiagContext, std::shared_ptr<FileSystem> ExternalFS) {
 
   SourceMgr SM;
   yaml::Stream Stream(Buffer->getMemBufferRef(), SM);
 
   SM.setDiagHandler(DiagHandler, DiagContext);
   yaml::document_iterator DI = Stream.begin();
   yaml::Node *Root = DI->getRoot();
   if (DI == Stream.end() || !Root) {
RedirectingFileSystem::openFileForRead(const Twine &Path) {
 
   // FIXME: Update the status with the name and VFSMapped.
   Status S = getRedirectedFileStatus(Path, F->useExternalName(UseExternalNames),
                                      *ExternalStatus);
   return std::unique_ptr<File>(
       llvm::make_unique<FileWithFixedStatus>(std::move(*Result), S));
 }
 
-IntrusiveRefCntPtr<FileSystem>
+std::shared_ptr<FileSystem>
 vfs::getVFSFromYAML(std::unique_ptr<MemoryBuffer> Buffer,
                     SourceMgr::DiagHandlerTy DiagHandler, void *DiagContext,
-                    IntrusiveRefCntPtr<FileSystem> ExternalFS) {
-  return RedirectingFileSystem::create(std::move(Buffer), DiagHandler,
-                                       DiagContext, ExternalFS);
+                    std::shared_ptr<FileSystem> ExternalFS) {
+  std::shared_ptr<FileSystem> FS(
+    RedirectingFileSystem::create(std::move(Buffer), DiagHandler,
+                                  DiagContext, ExternalFS));
+  return FS;
 }
 
 UniqueID vfs::getNextVirtualUniqueID() {
   static std::atomic<unsigned> UID;
   unsigned ID = ++UID;
   // The following assumes that uint64_t max will never collide with a real
   // dev_t value from the OS.
   return UniqueID(std::numeric_limits<uint64_t>::max(), ID);

lib/Driver/Driver.cpp

 #include <memory>
 
 using namespace clang::driver;
 using namespace clang;
 using namespace llvm::opt;
 
 Driver::Driver(StringRef ClangExecutable, StringRef DefaultTargetTriple,
                DiagnosticsEngine &Diags,
-               IntrusiveRefCntPtr<vfs::FileSystem> VFS)
+               std::shared_ptr<vfs::FileSystem> VFS)
     : Opts(createDriverOptTable()), Diags(Diags), VFS(VFS), Mode(GCCMode),
       SaveTemps(SaveTempsNone), LTOMode(LTOK_None),
       ClangExecutable(ClangExecutable),
       SysRoot(DEFAULT_SYSROOT), UseStdLib(true),
       DefaultTargetTriple(DefaultTargetTriple),
       DriverTitle("clang LLVM compiler"), CCPrintOptionsFilename(nullptr),
       CCPrintHeadersFilename(nullptr), CCLogDiagnosticsFilename(nullptr),
       CCCPrintBindings(false), CCPrintHeaders(false), CCLogDiagnostics(false),

lib/Format/Format.cpp

 }
 
 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName, bool *IncompleteFormat) {
   if (Style.DisableFormat)
     return tooling::Replacements();
 
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   FileManager Files(FileSystemOptions(), InMemoryFileSystem);
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
       new DiagnosticOptions);
   SourceManager SourceMgr(Diagnostics, Files);
   InMemoryFileSystem->addFile(
       FileName, 0, llvm::MemoryBuffer::getMemBuffer(

lib/Frontend/ASTUnit.cpp

llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
     DiagCleanup(Diags.get());
 
   ConfigureDiags(Diags, *AST, CaptureDiagnostics);
 
   AST->OnlyLocalDecls = OnlyLocalDecls;
   AST->CaptureDiagnostics = CaptureDiagnostics;
   AST->Diagnostics = Diags;
-  IntrusiveRefCntPtr<vfs::FileSystem> VFS = vfs::getRealFileSystem();
+  std::shared_ptr<vfs::FileSystem> VFS = vfs::getRealFileSystem();
   AST->FileMgr = new FileManager(FileSystemOpts, VFS);
   AST->UserFilesAreVolatile = UserFilesAreVolatile;
   AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
                                      AST->getFileManager(),
                                      UserFilesAreVolatile);
   AST->HSOpts = new HeaderSearchOptions();
   AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat();
   AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts,
ASTUnit::getMainBufferWithPrecompiledPreamble(
   // Clear out old caches and data.
   getDiagnostics().Reset();
   ProcessWarningOptions(getDiagnostics(), Clang->getDiagnosticOpts());
   checkAndRemoveNonDriverDiags(StoredDiagnostics);
   TopLevelDecls.clear();
   TopLevelDeclsInPreamble.clear();
   PreambleDiagnostics.clear();
 
-  IntrusiveRefCntPtr<vfs::FileSystem> VFS =
+  std::shared_ptr<vfs::FileSystem> VFS =
       createVFSFromCompilerInvocation(Clang->getInvocation(), getDiagnostics());
   if (!VFS)
     return nullptr;
 
   // Create a file manager object to provide access to and cache the filesystem.
   Clang->setFileManager(new FileManager(Clang->getFileSystemOpts(), VFS));
   
   // Create the source manager.
ASTUnit *ASTUnit::create(CompilerInvocation *CI,
                          bool CaptureDiagnostics,
                          bool UserFilesAreVolatile) {
   std::unique_ptr<ASTUnit> AST;
   AST.reset(new ASTUnit(false));
   ConfigureDiags(Diags, *AST, CaptureDiagnostics);
   AST->Diagnostics = Diags;
   AST->Invocation = CI;
   AST->FileSystemOpts = CI->getFileSystemOpts();
-  IntrusiveRefCntPtr<vfs::FileSystem> VFS =
+  std::shared_ptr<vfs::FileSystem> VFS =
       createVFSFromCompilerInvocation(*CI, *Diags);
   if (!VFS)
     return nullptr;
   AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
   AST->UserFilesAreVolatile = UserFilesAreVolatile;
   AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
                                      UserFilesAreVolatile);
 
if (ModuleFormat)
     CI->getHeaderSearchOpts().ModuleFormat = ModuleFormat.getValue();
 
   // Create the AST unit.
   std::unique_ptr<ASTUnit> AST;
   AST.reset(new ASTUnit(false));
   ConfigureDiags(Diags, *AST, CaptureDiagnostics);
   AST->Diagnostics = Diags;
   AST->FileSystemOpts = CI->getFileSystemOpts();
-  IntrusiveRefCntPtr<vfs::FileSystem> VFS =
+  std::shared_ptr<vfs::FileSystem> VFS =
       createVFSFromCompilerInvocation(*CI, *Diags);
   if (!VFS)
     return nullptr;
   AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
   AST->OnlyLocalDecls = OnlyLocalDecls;
   AST->CaptureDiagnostics = CaptureDiagnostics;
   AST->TUKind = TUKind;
   AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;

lib/Frontend/CompilerInstance.cpp

static bool compileModuleImpl(CompilerInstance &ImportingInstance,
   CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
                             /*BuildingModule=*/true);
   Instance.setInvocation(&*Invocation);
 
   Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
                                    ImportingInstance.getDiagnosticClient()),
                              /*ShouldOwnClient=*/true);
 
-  Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
+  Instance.setVirtualFileSystem(ImportingInstance.getVirtualFileSystem());
 
   // Note that this module is part of the module build stack, so that we
   // can detect cycles in the module graph.
   Instance.setFileManager(&ImportingInstance.getFileManager());
   Instance.createSourceManager(Instance.getFileManager());
   SourceManager &SourceMgr = Instance.getSourceManager();
   SourceMgr.setModuleBuildStack(
     ImportingInstance.getSourceManager().getModuleBuildStack());

lib/Frontend/CompilerInvocation.cpp

void BuryPointer(const void *Ptr) {
   LLVM_ATTRIBUTE_UNUSED static const void *GraveYard[kGraveYardMaxSize];
   static std::atomic<unsigned> GraveYardSize;
   unsigned Idx = GraveYardSize++;
   if (Idx >= kGraveYardMaxSize)
     return;
   GraveYard[Idx] = Ptr;
 }
 
-IntrusiveRefCntPtr<vfs::FileSystem>
+std::shared_ptr<vfs::FileSystem>
 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
                                 DiagnosticsEngine &Diags) {
   if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
     return vfs::getRealFileSystem();
 
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem>
+  std::shared_ptr<vfs::OverlayFileSystem>
     Overlay(new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
   // earlier vfs files are on the bottom
   for (const std::string &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
         llvm::MemoryBuffer::getFile(File);
     if (!Buffer) {
       Diags.Report(diag::err_missing_vfs_overlay_file) << File;
-      return IntrusiveRefCntPtr<vfs::FileSystem>();
+      return std::shared_ptr<vfs::FileSystem>();
     }
 
-    IntrusiveRefCntPtr<vfs::FileSystem> FS =
+    std::shared_ptr<vfs::FileSystem> FS =
         vfs::getVFSFromYAML(std::move(Buffer.get()), /*DiagHandler*/ nullptr);
     if (!FS.get()) {
       Diags.Report(diag::err_invalid_vfs_overlay) << File;
-      return IntrusiveRefCntPtr<vfs::FileSystem>();
+      return std::shared_ptr<vfs::FileSystem>();
     }
     Overlay->pushOverlay(FS);
   }
   return Overlay;
 }
 } // end namespace clang

lib/Frontend/FrontendAction.cpp

if (Input.getKind() == IK_AST) {
     CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile));
     if (!CI.hasASTConsumer())
       goto failure;
 
     return true;
   }
 
   if (!CI.hasVirtualFileSystem()) {
-    if (IntrusiveRefCntPtr<vfs::FileSystem> VFS =
+    if (std::shared_ptr<vfs::FileSystem> VFS =
           createVFSFromCompilerInvocation(CI.getInvocation(),
                                           CI.getDiagnostics()))
       CI.setVirtualFileSystem(VFS);
     else
       goto failure;
   }
 
   // Set up the file and source managers, if needed.

lib/Index/SimpleFormatContext.h

std::string getRewrittenText(FileID ID) {
     llvm::raw_string_ostream OS(Result);
     Rewrite.getEditBuffer(ID).write(OS);
     OS.flush();
     return Result;
   }
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   IntrusiveRefCntPtr<DiagnosticsEngine> Diagnostics;
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem;
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem;
   FileManager Files;
   SourceManager Sources;
   Rewriter Rewrite;
 };
 
 } // end namespace index
 } // end namespace clang
 
 #endif

lib/StaticAnalyzer/Frontend/ModelInjector.cpp

void ModelInjector::onBodySynthesis(const NamedDecl *D) {
   CompilerInstance Instance(CI.getPCHContainerOperations());
   Instance.setInvocation(&*Invocation);
   Instance.createDiagnostics(
       new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
       /*ShouldOwnClient=*/true);
 
   Instance.getDiagnostics().setSourceManager(&SM);
 
-  Instance.setVirtualFileSystem(&CI.getVirtualFileSystem());
+  Instance.setVirtualFileSystem(CI.getVirtualFileSystem());
 
   // The instance wants to take ownership, however DisableFree frontend option
   // is set to true to avoid double free issues
   Instance.setFileManager(&CI.getFileManager());
   Instance.setSourceManager(&SM);
   Instance.setPreprocessor(&CI.getPreprocessor());
   Instance.setASTContext(&CI.getASTContext());
 

lib/Tooling/Core/Replacement.cpp

for (std::vector<Replacement>::const_iterator I = Replaces.begin(),
     } else {
       Result = false;
     }
   }
   return Result;
 }
 
 std::string applyAllReplacements(StringRef Code, const Replacements &Replaces) {
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   FileManager Files(FileSystemOptions(), InMemoryFileSystem);
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
       new DiagnosticOptions);
   SourceManager SourceMgr(Diagnostics, Files);
   Rewriter Rewrite(SourceMgr, LangOptions());
   InMemoryFileSystem->addFile(

lib/Tooling/Tooling.cpp

 
 // FIXME: This file contains structural duplication with other parts of the
 // code that sets up a compiler to run tools on it, and we should refactor
 // it to be based on the same framework.
 
 /// \brief Builds a clang driver initialized for running clang tools.
 static clang::driver::Driver *newDriver(
     clang::DiagnosticsEngine *Diagnostics, const char *BinaryName,
-    IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
+    std::shared_ptr<vfs::FileSystem> VFS) {
   clang::driver::Driver *CompilerDriver = new clang::driver::Driver(
       BinaryName, llvm::sys::getDefaultTargetTriple(), *Diagnostics, VFS);
   CompilerDriver->setTitle("clang_based_tool");
   return CompilerDriver;
 }
 
 /// \brief Retrieves the clang CC1 specific flags out of the compilation's jobs.
 ///

 bool runToolOnCodeWithArgs(
     clang::FrontendAction *ToolAction, const Twine &Code,
     const std::vector<std::string> &Args, const Twine &FileName,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     const FileContentMappings &VirtualMappedFiles) {
 
   SmallString<16> FileNameStorage;
   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
-  llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
+  std::shared_ptr<vfs::OverlayFileSystem> OverlayFileSystem(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
-  llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef),
                             ToolAction, Files.get(), PCHContainerOps);
 
   SmallString<1024> CodeStorage;
std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
     const Twine &Code, const std::vector<std::string> &Args,
     const Twine &FileName,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps) {
   SmallString<16> FileNameStorage;
   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
 
   std::vector<std::unique_ptr<ASTUnit>> ASTs;
   ASTBuilderAction Action(ASTs);
-  llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
+  std::shared_ptr<vfs::OverlayFileSystem> OverlayFileSystem(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
-  llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), &Action,
                             Files.get(), PCHContainerOps);
 
   SmallString<1024> CodeStorage;

tools/clang-format/ClangFormat.cpp

static bool parseLineRange(StringRef Input, unsigned &FromLine,
                            unsigned &ToLine) {
   std::pair<StringRef, StringRef> LineRange = Input.split(':');
   return LineRange.first.getAsInteger(0, FromLine) ||
          LineRange.second.getAsInteger(0, ToLine);
 }
 
 static bool fillRanges(MemoryBuffer *Code,
                        std::vector<tooling::Range> &Ranges) {
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   FileManager Files(FileSystemOptions(), InMemoryFileSystem);
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
       new DiagnosticOptions);
   SourceManager Sources(Diagnostics, Files);
   FileID ID = createInMemoryFile("<irrelevant>", Code, Sources, Files,
                                  InMemoryFileSystem.get());
if (OutputXML) {
     if (Cursor.getNumOccurrences() != 0)
       outs() << "<cursor>"
              << tooling::shiftedCodePosition(FormatChanges, CursorPosition)
              << "</cursor>\n";
 
     outputReplacementsXML(Replaces); 
     outs() << "</replacements>\n";
   } else {
-    IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+    std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
         new vfs::InMemoryFileSystem);
     FileManager Files(FileSystemOptions(), InMemoryFileSystem);
     DiagnosticsEngine Diagnostics(
         IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
         new DiagnosticOptions);
     SourceManager Sources(Diagnostics, Files);
     FileID ID = createInMemoryFile(AssumedFileName, Code.get(), Sources, Files,
                                    InMemoryFileSystem.get());

unittests/Basic/VirtualFileSystemTest.cpp

void addSymlink(StringRef Path) {
     vfs::Status S(Path, UniqueID(FSID, FileID++), sys::TimeValue::now(), 0, 0,
                   0, sys::fs::file_type::symlink_file, sys::fs::all_all);
     addEntry(Path, S);
   }
 };
 } // end anonymous namespace
 
 TEST(VirtualFileSystemTest, StatusQueries) {
-  IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> D(new DummyFileSystem());
   ErrorOr<vfs::Status> Status((std::error_code()));
 
   D->addRegularFile("/foo");
   Status = D->status("/foo");
   ASSERT_FALSE(Status.getError());
   EXPECT_TRUE(Status->isStatusKnown());
   EXPECT_FALSE(Status->isDirectory());
   EXPECT_TRUE(Status->isRegularFile());
TEST(VirtualFileSystemTest, StatusQueries) {
 
   EXPECT_TRUE(Status->equivalent(*Status));
   ErrorOr<vfs::Status> Status2 = D->status("/foo");
   ASSERT_FALSE(Status2.getError());
   EXPECT_FALSE(Status->equivalent(*Status2));
 }
 
 TEST(VirtualFileSystemTest, BaseOnlyOverlay) {
-  IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> D(new DummyFileSystem());
   ErrorOr<vfs::Status> Status((std::error_code()));
   EXPECT_FALSE(Status = D->status("/foo"));
 
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(D));
+  std::shared_ptr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(D));
   EXPECT_FALSE(Status = O->status("/foo"));
 
   D->addRegularFile("/foo");
   Status = D->status("/foo");
   EXPECT_FALSE(Status.getError());
 
   ErrorOr<vfs::Status> Status2((std::error_code()));
   Status2 = O->status("/foo");
   EXPECT_FALSE(Status2.getError());
   EXPECT_TRUE(Status->equivalent(*Status2));
 }
 
 TEST(VirtualFileSystemTest, OverlayFiles) {
-  IntrusiveRefCntPtr<DummyFileSystem> Base(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Top(new DummyFileSystem());
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<DummyFileSystem> Base(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Middle(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Top(new DummyFileSystem());
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Base));
   O->pushOverlay(Middle);
   O->pushOverlay(Top);
 
   ErrorOr<vfs::Status> Status1((std::error_code())),
       Status2((std::error_code())), Status3((std::error_code())),
       StatusB((std::error_code())), StatusM((std::error_code())),
       StatusT((std::error_code()));
TEST(VirtualFileSystemTest, OverlayFiles) {
   EXPECT_TRUE(Status3->equivalent(*StatusT));
 
   EXPECT_FALSE(Status1->equivalent(*Status2));
   EXPECT_FALSE(Status2->equivalent(*Status3));
   EXPECT_FALSE(Status1->equivalent(*Status3));
 }
 
 TEST(VirtualFileSystemTest, OverlayDirsNonMerged) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Upper(new DummyFileSystem());
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(Upper);
 
   Lower->addDirectory("/lower-only");
   Upper->addDirectory("/upper-only");
 
   // non-merged paths should be the same
   ErrorOr<vfs::Status> Status1 = Lower->status("/lower-only");
   ASSERT_FALSE(Status1.getError());
   ErrorOr<vfs::Status> Status2 = O->status("/lower-only");
   ASSERT_FALSE(Status2.getError());
   EXPECT_TRUE(Status1->equivalent(*Status2));
 
   Status1 = Upper->status("/upper-only");
   ASSERT_FALSE(Status1.getError());
   Status2 = O->status("/upper-only");
   ASSERT_FALSE(Status2.getError());
   EXPECT_TRUE(Status1->equivalent(*Status2));
 }
 
 TEST(VirtualFileSystemTest, MergedDirPermissions) {
   // merged directories get the permissions of the upper dir
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Upper(new DummyFileSystem());
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(Upper);
 
   ErrorOr<vfs::Status> Status((std::error_code()));
   Lower->addDirectory("/both", sys::fs::owner_read);
   Upper->addDirectory("/both", sys::fs::owner_all | sys::fs::group_read);
   Status = O->status("/both");
   ASSERT_FALSE(Status.getError());
if (Path != "")
       EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
   }
   operator StringRef() { return Path.str(); }
 };
 } // end anonymous namespace
 
 TEST(VirtualFileSystemTest, BasicRealFSIteration) {
   ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/true);
-  IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
+  std::shared_ptr<vfs::FileSystem> FS = vfs::getRealFileSystem();
 
   std::error_code EC;
   vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory), EC);
   ASSERT_FALSE(EC);
   EXPECT_EQ(vfs::directory_iterator(), I); // empty directory is empty
 
   ScopedDir _a(TestDirectory+"/a");
   ScopedDir _ab(TestDirectory+"/a/b");
TEST(VirtualFileSystemTest, BasicRealFSIteration) {
   ASSERT_NE(vfs::directory_iterator(), I);
   EXPECT_TRUE(I->getName().endswith("a") || I->getName().endswith("c"));
   I.increment(EC);
   EXPECT_EQ(vfs::directory_iterator(), I);
 }
 
 TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) {
   ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/true);
-  IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
+  std::shared_ptr<vfs::FileSystem> FS = vfs::getRealFileSystem();
 
   std::error_code EC;
   auto I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC);
   ASSERT_FALSE(EC);
   EXPECT_EQ(vfs::recursive_directory_iterator(), I); // empty directory is empty
 
   ScopedDir _a(TestDirectory+"/a");
   ScopedDir _ab(TestDirectory+"/a/b");
for (DirIter E;
        I.increment(EC), ++ExpectedIter)
     EXPECT_EQ(*ExpectedIter, I->getName());
 
   EXPECT_EQ(ExpectedEnd, ExpectedIter);
   EXPECT_EQ(DirIter(), I);
 }
 
 TEST(VirtualFileSystemTest, OverlayIteration) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Upper(new DummyFileSystem());
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(Upper);
 
   std::error_code EC;
   checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>());
 
   Lower->addRegularFile("/file1");
   checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file1"));
 
   Upper->addRegularFile("/file2");
   checkContents(O->dir_begin("/", EC), {"/file2", "/file1"});
 
   Lower->addDirectory("/dir1");
   Lower->addRegularFile("/dir1/foo");
   Upper->addDirectory("/dir2");
   Upper->addRegularFile("/dir2/foo");
   checkContents(O->dir_begin("/dir2", EC), ArrayRef<StringRef>("/dir2/foo"));
   checkContents(O->dir_begin("/", EC), {"/dir2", "/file2", "/dir1", "/file1"});
 }
 
 TEST(VirtualFileSystemTest, OverlayRecursiveIteration) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Middle(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Upper(new DummyFileSystem());
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(Middle);
   O->pushOverlay(Upper);
 
   std::error_code EC;
   checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
                 ArrayRef<StringRef>());
 
checkContents(vfs::recursive_directory_iterator(*O, "/dir2", EC),
                 ArrayRef<StringRef>("/dir2/foo"));
   checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
                 {"/dir", "/dir/file2", "/dir2", "/dir2/foo", "/hiddenByUp",
                  "/a", "/a/b", "/a/b/c", "/a/b/c/d", "/dir1", "/dir1/a",
                  "/dir1/a/b", "/dir1/foo", "/file1"});
 }
 
 TEST(VirtualFileSystemTest, ThreeLevelIteration) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Middle(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Upper(new DummyFileSystem());
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(Middle);
   O->pushOverlay(Upper);
 
   std::error_code EC;
   checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>());
 
   Middle->addRegularFile("/file2");
   checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file2"));
 
   Lower->addRegularFile("/file1");
   Upper->addRegularFile("/file3");
   checkContents(O->dir_begin("/", EC), {"/file3", "/file2", "/file1"});
 }
 
 TEST(VirtualFileSystemTest, HiddenInIteration) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
-  IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Middle(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Upper(new DummyFileSystem());
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(Middle);
   O->pushOverlay(Upper);
 
   std::error_code EC;
   Lower->addRegularFile("/onlyInLow", sys::fs::owner_read);
   Lower->addRegularFile("/hiddenByMid", sys::fs::owner_read);
   Lower->addRegularFile("/hiddenByUp", sys::fs::owner_read);
public:
 
   void SetUp() override { NumDiagnostics = 0; }
 
   static void CountingDiagHandler(const SMDiagnostic &, void *Context) {
     VFSFromYAMLTest *Test = static_cast<VFSFromYAMLTest *>(Context);
     ++Test->NumDiagnostics;
   }
 
-  IntrusiveRefCntPtr<vfs::FileSystem>
+  std::shared_ptr<vfs::FileSystem>
   getFromYAMLRawString(StringRef Content,
-                       IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS) {
+                       std::shared_ptr<vfs::FileSystem> ExternalFS) {
     std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Content);
     return getVFSFromYAML(std::move(Buffer), CountingDiagHandler, this,
                           ExternalFS);
   }
 
-  IntrusiveRefCntPtr<vfs::FileSystem> getFromYAMLString(
+  std::shared_ptr<vfs::FileSystem> getFromYAMLString(
       StringRef Content,
-      IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS = new DummyFileSystem()) {
+      std::shared_ptr<vfs::FileSystem> ExternalFS =
+        std::make_shared<DummyFileSystem>()) {
     std::string VersionPlusContent("{\n  'version':0,\n");
     VersionPlusContent += Content.slice(Content.find('{') + 1, StringRef::npos);
     return getFromYAMLRawString(VersionPlusContent, ExternalFS);
   }
 };
 
 TEST_F(VFSFromYAMLTest, BasicVFSFromYAML) {
-  IntrusiveRefCntPtr<vfs::FileSystem> FS;
+  std::shared_ptr<vfs::FileSystem> FS;
   FS = getFromYAMLString("");
   EXPECT_EQ(nullptr, FS.get());
   FS = getFromYAMLString("[]");
   EXPECT_EQ(nullptr, FS.get());
   FS = getFromYAMLString("'string'");
   EXPECT_EQ(nullptr, FS.get());
   EXPECT_EQ(3, NumDiagnostics);
 }
 
 TEST_F(VFSFromYAMLTest, MappedFiles) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addRegularFile("//root/foo/bar/a");
-  IntrusiveRefCntPtr<vfs::FileSystem> FS =
+  std::shared_ptr<vfs::FileSystem> FS =
       getFromYAMLString("{ 'roots': [\n"
                         "{\n"
                         "  'type': 'directory',\n"
                         "  'name': '//root/',\n"
                         "  'contents': [ {\n"
                         "                  'type': 'file',\n"
                         "                  'name': 'file1',\n"
                         "                  'external-contents': '//root/foo/bar/a'\n"
                         "                },\n"
                         "                {\n"
                         "                  'type': 'file',\n"
                         "                  'name': 'file2',\n"
                         "                  'external-contents': '//root/foo/b'\n"
                         "                }\n"
                         "              ]\n"
                         "}\n"
                         "]\n"
                         "}",
                         Lower);
   ASSERT_TRUE(FS.get() != nullptr);
 
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   // file
   ErrorOr<vfs::Status> S = O->status("//root/file1");
   ASSERT_FALSE(S.getError());
   EXPECT_EQ("//root/foo/bar/a", S->getName());
   EXPECT_TRUE(S->IsVFSMapped);
TEST_F(VFSFromYAMLTest, MappedFiles) {
 
   // broken mapping
   EXPECT_EQ(O->status("//root/file2").getError(),
             llvm::errc::no_such_file_or_directory);
   EXPECT_EQ(0, NumDiagnostics);
 }
 
 TEST_F(VFSFromYAMLTest, CaseInsensitive) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addRegularFile("//root/foo/bar/a");
-  IntrusiveRefCntPtr<vfs::FileSystem> FS =
+  std::shared_ptr<vfs::FileSystem> FS =
       getFromYAMLString("{ 'case-sensitive': 'false',\n"
                         "  'roots': [\n"
                         "{\n"
                         "  'type': 'directory',\n"
                         "  'name': '//root/',\n"
                         "  'contents': [ {\n"
                         "                  'type': 'file',\n"
                         "                  'name': 'XX',\n"
                         "                  'external-contents': '//root/foo/bar/a'\n"
                         "                }\n"
                         "              ]\n"
                         "}]}",
                         Lower);
   ASSERT_TRUE(FS.get() != nullptr);
 
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   ErrorOr<vfs::Status> S = O->status("//root/XX");
   ASSERT_FALSE(S.getError());
 
   ErrorOr<vfs::Status> SS = O->status("//root/xx");
   ASSERT_FALSE(SS.getError());
   EXPECT_TRUE(S->equivalent(*SS));
   SS = O->status("//root/xX");
   EXPECT_TRUE(S->equivalent(*SS));
   SS = O->status("//root/Xx");
   EXPECT_TRUE(S->equivalent(*SS));
   EXPECT_EQ(0, NumDiagnostics);
 }
 
 TEST_F(VFSFromYAMLTest, CaseSensitive) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addRegularFile("//root/foo/bar/a");
-  IntrusiveRefCntPtr<vfs::FileSystem> FS =
+  std::shared_ptr<vfs::FileSystem> FS =
       getFromYAMLString("{ 'case-sensitive': 'true',\n"
                         "  'roots': [\n"
                         "{\n"
                         "  'type': 'directory',\n"
                         "  'name': '//root/',\n"
                         "  'contents': [ {\n"
                         "                  'type': 'file',\n"
                         "                  'name': 'XX',\n"
                         "                  'external-contents': '//root/foo/bar/a'\n"
                         "                }\n"
                         "              ]\n"
                         "}]}",
                         Lower);
   ASSERT_TRUE(FS.get() != nullptr);
 
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   ErrorOr<vfs::Status> SS = O->status("//root/xx");
   EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
   SS = O->status("//root/xX");
   EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
   SS = O->status("//root/Xx");
   EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
   EXPECT_EQ(0, NumDiagnostics);
 }
 
 TEST_F(VFSFromYAMLTest, IllegalVFSFile) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
 
   // invalid YAML at top-level
-  IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString("{]", Lower);
+  std::shared_ptr<vfs::FileSystem> FS = getFromYAMLString("{]", Lower);
   EXPECT_EQ(nullptr, FS.get());
   // invalid YAML in roots
   FS = getFromYAMLString("{ 'roots':[}", Lower);
   // invalid YAML in directory
   FS = getFromYAMLString(
       "{ 'roots':[ { 'name': 'foo', 'type': 'directory', 'contents': [}",
       Lower);
   EXPECT_EQ(nullptr, FS.get());
TEST_F(VFSFromYAMLTest, IllegalVFSFile) {
   FS = getFromYAMLRawString("{ 'version':-1, 'roots':[] }", Lower);
   EXPECT_EQ(nullptr, FS.get());
   FS = getFromYAMLRawString("{ 'version':100000, 'roots':[] }", Lower);
   EXPECT_EQ(nullptr, FS.get());
   EXPECT_EQ(24, NumDiagnostics);
 }
 
 TEST_F(VFSFromYAMLTest, UseExternalName) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addRegularFile("//root/external/file");
 
-  IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
+  std::shared_ptr<vfs::FileSystem> FS = getFromYAMLString(
       "{ 'roots': [\n"
       "  { 'type': 'file', 'name': '//root/A',\n"
       "    'external-contents': '//root/external/file'\n"
       "  },\n"
       "  { 'type': 'file', 'name': '//root/B',\n"
       "    'use-external-name': true,\n"
       "    'external-contents': '//root/external/file'\n"
       "  },\n"
TEST_F(VFSFromYAMLTest, UseExternalName) {
   // default
   EXPECT_EQ("//root/A", FS->status("//root/A")->getName());
   // explicit
   EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
   EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
 }
 
 TEST_F(VFSFromYAMLTest, MultiComponentPath) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addRegularFile("//root/other");
 
   // file in roots
-  IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
+  std::shared_ptr<vfs::FileSystem> FS = getFromYAMLString(
       "{ 'roots': [\n"
       "  { 'type': 'file', 'name': '//root/path/to/file',\n"
       "    'external-contents': '//root/other' }]\n"
       "}", Lower);
   ASSERT_TRUE(nullptr != FS.get());
   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
   EXPECT_FALSE(FS->status("//root/path/to").getError());
   EXPECT_FALSE(FS->status("//root/path").getError());
TEST_F(VFSFromYAMLTest, MultiComponentPath) {
   ASSERT_TRUE(nullptr != FS.get());
   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
   EXPECT_FALSE(FS->status("//root/path/to").getError());
   EXPECT_FALSE(FS->status("//root/path").getError());
   EXPECT_FALSE(FS->status("//root/").getError());
 }
 
 TEST_F(VFSFromYAMLTest, TrailingSlashes) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addRegularFile("//root/other");
 
   // file in roots
-  IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
+  std::shared_ptr<vfs::FileSystem> FS = getFromYAMLString(
       "{ 'roots': [\n"
       "  { 'type': 'directory', 'name': '//root/path/to////',\n"
       "    'contents': [ { 'type': 'file', 'name': 'file',\n"
       "                    'external-contents': '//root/other' }]}]\n"
       "}", Lower);
   ASSERT_TRUE(nullptr != FS.get());
   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
   EXPECT_FALSE(FS->status("//root/path/to").getError());
   EXPECT_FALSE(FS->status("//root/path").getError());
   EXPECT_FALSE(FS->status("//root/").getError());
 }
 
 TEST_F(VFSFromYAMLTest, DirectoryIteration) {
-  IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+  std::shared_ptr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addDirectory("//root/");
   Lower->addDirectory("//root/foo");
   Lower->addDirectory("//root/foo/bar");
   Lower->addRegularFile("//root/foo/bar/a");
   Lower->addRegularFile("//root/foo/bar/b");
   Lower->addRegularFile("//root/file3");
-  IntrusiveRefCntPtr<vfs::FileSystem> FS =
+  std::shared_ptr<vfs::FileSystem> FS =
   getFromYAMLString("{ 'use-external-names': false,\n"
                     "  'roots': [\n"
                     "{\n"
                     "  'type': 'directory',\n"
                     "  'name': '//root/',\n"
                     "  'contents': [ {\n"
                     "                  'type': 'file',\n"
                     "                  'name': 'file1',\n"
                     "                  'external-contents': '//root/foo/bar/a'\n"
                     "                },\n"
                     "                {\n"
                     "                  'type': 'file',\n"
                     "                  'name': 'file2',\n"
                     "                  'external-contents': '//root/foo/bar/b'\n"
                     "                }\n"
                     "              ]\n"
                     "}\n"
                     "]\n"
                     "}",
                     Lower);
   ASSERT_TRUE(FS.get() != nullptr);
 
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+  std::shared_ptr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   std::error_code EC;
   checkContents(O->dir_begin("//root/", EC),
                 {"//root/file1", "//root/file2", "//root/file3", "//root/foo"});
 
   checkContents(O->dir_begin("//root/foo/bar", EC),
                 {"//root/foo/bar/a", "//root/foo/bar/b"});
 }

unittests/Driver/ToolChainTest.cpp

 namespace {
 
 TEST(ToolChainTest, VFSGCCInstallation) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags,
                    InMemoryFileSystem);
 
   const char *EmptyFiles[] = {
       "foo.cpp",
       "/bin/clang",
       "/usr/lib/gcc/arm-linux-gnueabi/4.6.1/crtbegin.o",

 }
 
 TEST(ToolChainTest, VFSGCCInstallationRelativeDir) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   Driver TheDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
                    InMemoryFileSystem);
 
   const char *EmptyFiles[] = {
       "foo.cpp", "/home/test/lib/gcc/arm-linux-gnueabi/4.6.1/crtbegin.o",
       "/home/test/include/arm-linux-gnueabi/.keep"};
 

unittests/Lex/PPCallbacksTest.cpp

PPCallbacksTest()
         FileMgr(FileSystemOptions(), InMemoryFileSystem),
         DiagID(new DiagnosticIDs()), DiagOpts(new DiagnosticOptions()),
         Diags(DiagID, DiagOpts.get(), new IgnoringDiagConsumer()),
         SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions()) {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
     Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
   }
 
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem;
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem;
   FileManager FileMgr;
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   DiagnosticsEngine Diags;
   SourceManager SourceMgr;
   LangOptions LangOpts;
   std::shared_ptr<TargetOptions> TargetOpts;
   IntrusiveRefCntPtr<TargetInfo> Target;

unittests/Tooling/RewriterTestContext.h

std::string getFileContentFromDisk(StringRef Name) {
     // reopen the file.
     auto FileBuffer = Files.getBufferForFile(Path);
     return (*FileBuffer)->getBuffer();
   }
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   DiagnosticsEngine Diagnostics;
   TextDiagnosticPrinter DiagnosticPrinter;
-  IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem;
-  IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem;
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem;
+  std::shared_ptr<vfs::OverlayFileSystem> OverlayFileSystem;
   FileManager Files;
   SourceManager Sources;
   LangOptions Options;
   Rewriter Rewrite;
 
   // Will be set once on disk files are generated.
   llvm::StringMap<std::string> TemporaryFiles;
 };
 
 } // end namespace clang
 
 #endif

unittests/Tooling/ToolingTest.cpp

TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) {
   IndependentFrontendActionCreator Creator;
   std::unique_ptr<FrontendActionFactory> Factory(
       newFrontendActionFactory(&Creator));
   std::unique_ptr<FrontendAction> Action(Factory->create());
   EXPECT_TRUE(Action.get() != nullptr);
 }
 
 TEST(ToolInvocation, TestMapVirtualFile) {
-  llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
+  std::shared_ptr<vfs::OverlayFileSystem> OverlayFileSystem(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
-  llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   std::vector<std::string> Args;
   Args.push_back("tool-executable");
   Args.push_back("-Idef");
   Args.push_back("-fsyntax-only");
   Args.push_back("test.cpp");
   clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction,
                                             Files.get());
   InMemoryFileSystem->addFile(
       "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
   InMemoryFileSystem->addFile("def/abc", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
   EXPECT_TRUE(Invocation.run());
 }
 
 TEST(ToolInvocation, TestVirtualModulesCompilation) {
   // FIXME: Currently, this only tests that we don't exit with an error if a
   // mapped module.map is found on the include path. In the future, expand this
   // test to run a full modules enabled compilation, so we make sure we can
   // rerun modules compilations with a virtual file system.
-  llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> OverlayFileSystem(
+  std::shared_ptr<vfs::OverlayFileSystem> OverlayFileSystem(
       new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
-  llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
+  std::shared_ptr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   std::vector<std::string> Args;
   Args.push_back("tool-executable");
   Args.push_back("-Idef");
   Args.push_back("-fsyntax-only");