[clang][cas] Fix dependency directive lookup for prefix-mapped paths

Currently we are failing to find dependency directives for prefix-mapped
paths in the scanner, such as -include options.

Match how ivfsoverlay marks remapped paths. We want to use the external
(remapped) path when we lookup directives; currently the way to do that
is getName() combined with ExposesExternalVFSPath; if in the future we
add explicit API for this we can drop the status flag.

Author: benlangmuir

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

@@ -650,7 +650,7 @@ bool ModuleDepCollector::isPrebuiltModule(const Module *M) {
   if (PrebuiltModuleFileIt == PrebuiltModuleFiles.end())
     return false;
   assert("Prebuilt module came from the expected AST file" &&
-         PrebuiltModuleFileIt->second == M->getASTFile()->getName());
+         PrebuiltModuleFileIt->second == M->getASTFile()->getNameAsRequested());
   return true;
 }
 

clang/test/ClangScanDeps/include-tree-prefix-mapping-pch-remap.c

@@ -0,0 +1,21 @@
+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed -e "s|DIR|%t|g" %t/cdb.json.template > %t/cdb.json
+
+// RUN: clang-scan-deps -compilation-database %t/cdb.json \
+// RUN:   -format experimental-include-tree-full -cas-path %t/cas \
+// RUN:   -prefix-map=%t=/^src -prefix-map-sdk=/^sdk -prefix-map-toolchain=/^tc > %t/deps.json
+
+//--- cdb.json.template
+[{
+  "file": "tu.c",
+  "directory": "DIR",
+  "command": "clang DIR/tu.c -fsyntax-only -include DIR/prefix.h"
+}]
+
+//--- prefix.h
+// Note: this is a bit hacky, but we rely on the fact that dep directives lexing
+// will not see #error during the scan.
+#error "failed to find dependency directives"
+
+//--- tu.c

llvm/include/llvm/Support/PrefixMapper.h

@@ -60,15 +60,24 @@ class PrefixMapper {
   /// Map \p Path, and saving the new (or existing) path in \p NewPath.
   ///
   /// \pre \p Path is not a reference into \p NewPath.
-  void map(StringRef Path, SmallVectorImpl<char> &NewPath);
-  void map(StringRef Path, std::string &NewPath);
+  /// \returns true if \c NewPath was mapped.
+  bool map(StringRef Path, SmallVectorImpl<char> &NewPath);
+  /// Map \p Path, and saving the new (or existing) path in \p NewPath.
+  ///
+  /// \pre \p Path is not a reference into \p NewPath.
+  /// \returns true if \c NewPath was mapped.
+  bool map(StringRef Path, std::string &NewPath);
 
   /// Map \p Path, returning \a std::string.
   std::string mapToString(StringRef Path);
 
   /// Map \p Path in place.
-  void mapInPlace(SmallVectorImpl<char> &Path);
-  void mapInPlace(std::string &Path);
+  /// \returns true if the path was modified.
+  bool mapInPlace(SmallVectorImpl<char> &Path);
+
+  /// Map \p Path in place.
+  /// \returns true if the path was modified.
+  bool mapInPlace(std::string &Path);
 
 protected:
   /// Map (or unmap) \p Path. On a match, fills \p Storage with the mapped path

llvm/lib/Support/PrefixMapper.cpp

@@ -117,18 +117,23 @@ std::optional<StringRef> PrefixMapper::mapImpl(StringRef Path,
   return std::nullopt;
 }
 
-void PrefixMapper::map(StringRef Path, SmallVectorImpl<char> &NewPath) {
+bool PrefixMapper::map(StringRef Path, SmallVectorImpl<char> &NewPath) {
   NewPath.clear();
   std::optional<StringRef> Mapped = mapImpl(Path, NewPath);
   if (!NewPath.empty())
-    return;
+    return true;
+  bool Modified = Mapped.has_value();
   if (!Mapped)
     Mapped = Path;
   NewPath.assign(Mapped->begin(), Mapped->end());
+  return Modified;
 }
 
-void PrefixMapper::map(StringRef Path, std::string &NewPath) {
-  NewPath = mapToString(Path);
+bool PrefixMapper::map(StringRef Path, std::string &NewPath) {
+  SmallString<256> Storage;
+  std::optional<StringRef> Mapped = mapImpl(Path, Storage);
+  NewPath = Mapped ? Mapped->str() : Path.str();
+  return Mapped.has_value();
 }
 
 std::string PrefixMapper::mapToString(StringRef Path) {
@@ -137,24 +142,26 @@ std::string PrefixMapper::mapToString(StringRef Path) {
   return Mapped ? Mapped->str() : Path.str();
 }
 
-void PrefixMapper::mapInPlace(SmallVectorImpl<char> &Path) {
+bool PrefixMapper::mapInPlace(SmallVectorImpl<char> &Path) {
   SmallString<256> Storage;
   std::optional<StringRef> Mapped =
       mapImpl(StringRef(Path.begin(), Path.size()), Storage);
   if (!Mapped)
-    return;
+    return false;
   if (Storage.empty())
     Path.assign(Mapped->begin(), Mapped->end());
   else
     Storage.swap(Path);
+  return true;
 }
 
-void PrefixMapper::mapInPlace(std::string &Path) {
+bool PrefixMapper::mapInPlace(std::string &Path) {
   SmallString<256> Storage;
   std::optional<StringRef> Mapped = mapImpl(Path, Storage);
   if (!Mapped)
-    return;
+    return false;
   Path.assign(Mapped->begin(), Mapped->size());
+  return true;
 }
 
 void PrefixMapper::sort() {

llvm/lib/Support/PrefixMappingFileSystem.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/PrefixMappingFileSystem.h"
+#include "llvm/CAS/CASReference.h"
 #include "llvm/Support/PrefixMapper.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
@@ -15,6 +16,31 @@ using namespace llvm::vfs;
 
 namespace {
 
+class PrefixMappingFile : public vfs::File {
+  std::unique_ptr<vfs::File> Underlying;
+
+public:
+  PrefixMappingFile(std::unique_ptr<vfs::File> F) : Underlying(std::move(F)) {}
+
+  llvm::ErrorOr<Status> status() final {
+    auto S = Underlying->status();
+    if (S)
+      S->ExposesExternalVFSPath = true;
+    return S;
+  }
+  llvm::ErrorOr<std::string> getName() final { return Underlying->getName(); }
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+  getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
+            bool IsVolatile) final {
+    return Underlying->getBuffer(Name, FileSize, RequiresNullTerminator,
+                                 IsVolatile);
+  }
+  llvm::ErrorOr<std::optional<cas::ObjectRef>> getObjectRefForContent() final {
+    return Underlying->getObjectRefForContent();
+  }
+  std::error_code close() final { return Underlying->close(); }
+};
+
 class PrefixMappingFileSystem final : public ProxyFileSystem {
   mutable PrefixMapper Mapper;
 
@@ -26,17 +52,26 @@ class PrefixMappingFileSystem final : public ProxyFileSystem {
 #define PREFIX_MAP_PATH(Old, New)                                              \
   SmallString<256> New;                                                        \
   Old.toVector(New);                                                           \
-  Mapper.mapInPlace(New);
+  bool DidMap = Mapper.mapInPlace(New);                                        \
+  (void)DidMap; // Prevent unused variable warnings.
 
   llvm::ErrorOr<Status> status(const Twine &Path) override {
     PREFIX_MAP_PATH(Path, MappedPath)
-    return ProxyFileSystem::status(MappedPath);
+    auto S = ProxyFileSystem::status(MappedPath);
+    // If we remapped the path, indicate the external path.
+    if (DidMap && S)
+      S->ExposesExternalVFSPath = true;
+    return S;
   }
 
   llvm::ErrorOr<std::unique_ptr<File>>
   openFileForRead(const Twine &Path) override {
     PREFIX_MAP_PATH(Path, MappedPath)
-    return ProxyFileSystem::openFileForRead(MappedPath);
+    auto F = ProxyFileSystem::openFileForRead(MappedPath);
+    // If we remapped the path, indicate the external path.
+    if (DidMap && F)
+      F = std::make_unique<PrefixMappingFile>(std::move(F.get()));
+    return F;
   }
 
   directory_iterator dir_begin(const Twine &Path,