clang-tools-extra/clangd/FS.cpp

   1 //===--- FS.cpp - File system related utils ----------------------*- C++-*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "FS.h"
  10 #include "clang/Basic/LLVM.h"
  11 #include "llvm/ADT/None.h"
  12 #include "llvm/Support/Path.h"
  13 #include "llvm/Support/VirtualFileSystem.h"
  14
  15 namespace clang {
  16 namespace clangd {
  17
  18 PreambleFileStatusCache::PreambleFileStatusCache(llvm::StringRef MainFilePath){
  19   assert(llvm::sys::path::is_absolute(MainFilePath));
  20   llvm::SmallString<256> MainFileCanonical(MainFilePath);
  21   llvm::sys::path::remove_dots(MainFileCanonical, /*remove_dot_dot=*/true);
  22   this->MainFilePath = std::string(MainFileCanonical.str());
  23 }
  24
  25 void PreambleFileStatusCache::update(const llvm::vfs::FileSystem &FS,
  26                                      llvm::vfs::Status S) {
  27   // Canonicalize path for later lookup, which is usually by absolute path.
  28   llvm::SmallString<32> PathStore(S.getName());
  29   if (FS.makeAbsolute(PathStore))
  30     return;
  31   llvm::sys::path::remove_dots(PathStore, /*remove_dot_dot=*/true);
  32   // Do not cache status for the main file.
  33   if (PathStore == MainFilePath)
  34     return;
  35   // Stores the latest status in cache as it can change in a preamble build.
  36   StatCache.insert({PathStore, std::move(S)});
  37 }
  38
  39 llvm::Optional<llvm::vfs::Status>
  40 PreambleFileStatusCache::lookup(llvm::StringRef File) const {
  41   // Canonicalize to match the cached form.
  42   // Lookup tends to be first by absolute path, so no need to make absolute.
  43   llvm::SmallString<256> PathLookup(File);
  44   llvm::sys::path::remove_dots(PathLookup, /*remove_dot_dot=*/true);
  45
  46   auto I = StatCache.find(PathLookup);
  47   if (I != StatCache.end())
  48     // Returned Status name should always match the requested File.
  49     return llvm::vfs::Status::copyWithNewName(I->getValue(), File);
  50   return None;
  51 }
  52
  53 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>
  54 PreambleFileStatusCache::getProducingFS(
  55     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS) {
  56   // This invalidates old status in cache if files are re-`open()`ed or
  57   // re-`stat()`ed in case file status has changed during preamble build.
  58   class CollectFS : public llvm::vfs::ProxyFileSystem {
  59   public:
  60     CollectFS(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
  61               PreambleFileStatusCache &StatCache)
  62         : ProxyFileSystem(std::move(FS)), StatCache(StatCache) {}
  63
  64     llvm::ErrorOr<std::unique_ptr<llvm::vfs::File>>
  65     openFileForRead(const llvm::Twine &Path) override {
  66       auto File = getUnderlyingFS().openFileForRead(Path);
  67       if (!File || !*File)
  68         return File;
  69       // Eagerly stat opened file, as the followup `status` call on the file
  70       // doesn't necessarily go through this FS. This puts some extra work on
  71       // preamble build, but it should be worth it as preamble can be reused
  72       // many times (e.g. code completion) and the repeated status call is
  73       // likely to be cached in the underlying file system anyway.
  74       if (auto S = File->get()->status())
  75         StatCache.update(getUnderlyingFS(), std::move(*S));
  76       return File;
  77     }
  78
  79     llvm::ErrorOr<llvm::vfs::Status> status(const llvm::Twine &Path) override {
  80       auto S = getUnderlyingFS().status(Path);
  81       if (S)
  82         StatCache.update(getUnderlyingFS(), *S);
  83       return S;
  84     }
  85
  86   private:
  87     PreambleFileStatusCache &StatCache;
  88   };
  89   return llvm::IntrusiveRefCntPtr<CollectFS>(
  90       new CollectFS(std::move(FS), *this));
  91 }
  92
  93 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>
  94 PreambleFileStatusCache::getConsumingFS(
  95     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS) const {
  96   class CacheVFS : public llvm::vfs::ProxyFileSystem {
  97   public:
  98     CacheVFS(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
  99              const PreambleFileStatusCache &StatCache)
 100         : ProxyFileSystem(std::move(FS)), StatCache(StatCache) {}
 101
 102     llvm::ErrorOr<llvm::vfs::Status> status(const llvm::Twine &Path) override {
 103       if (auto S = StatCache.lookup(Path.str()))
 104         return *S;
 105       return getUnderlyingFS().status(Path);
 106     }
 107
 108   private:
 109     const PreambleFileStatusCache &StatCache;
 110   };
 111   return llvm::IntrusiveRefCntPtr<CacheVFS>(new CacheVFS(std::move(FS), *this));
 112 }
 113
 114 Path removeDots(PathRef File) {
 115   llvm::SmallString<128> CanonPath(File);
 116   llvm::sys::path::remove_dots(CanonPath, /*remove_dot_dot=*/true);
 117   return CanonPath.str().str();
 118 }
 119
 120 } // namespace clangd
 121 } // namespace clang