[WIP][FileCollector] isCaseSensitivePath

[JDevlieghere]

llvm/lib/Support/FileCollector.cpp

29

Yes, optimally we should compare the realpath of Path.lower() with the realpath of Path.u[per(), but realpath is an expensive operation, so this seems like a reasonable enough heuristic.

182

I'm not sure I fully understand your point so apologies if my answer doesn't actually address your question. The case-sensitivity is used by the RedirectingFileSystem for lookups. It ensures that /foo/bar and /foo/Bar resolve to the same file as would be the case on the real file system. You need the deduplication in the mapping because if you are traversing the directory with a recursive directory iterator, you want both /foo/Bar/baz and /foo/bar/quux to show up under /foo/bar and /foo/Bar.

[jkorous]

I got convinced in an offline discussion that the rewards aren't greater than risks here.

llvm/lib/Support/FileCollector.cpp

static bool isCaseSensitivePath(StringRef Path) {
   if (!sys::fs::real_path(Path, TmpDest))
     return true; // Current default value in vfs.yaml
   Path = TmpDest;
 
   // Change path to all upper case and ask for its real path, if the latter
   // exists and is equal to path, it's not case sensitive. Default to case
   // sensitive in the absence of real_path, since this is the YAMLVFSWriter
   // default.
+  // FIXME: Path could've already been ALL CAPS so we should also use lower().
   UpperDest = Path.upper();
   if (sys::fs::real_path(UpperDest, RealDest) && Path.equals(RealDest))
     return false;
   return true;
 }
 
 FileCollector::FileCollector(std::string Root, std::string OverlayRoot)
     : Root(std::move(Root)), OverlayRoot(std::move(OverlayRoot)) {
std::error_code FileCollector::copyFiles(bool StopOnError) {
   }
   return {};
 }
 
 std::error_code FileCollector::writeMapping(StringRef mapping_file) {
   std::lock_guard<std::mutex> lock(Mutex);
 
   VFSWriter.setOverlayDir(OverlayRoot);
+  // FIXME: Technically even on a case-insensitive file system programs can have
+  // their own quirks in path handling. Is there actually much to gain by not
+  // storing paths exactly as requested? IIUC this would lead only to 
+  // deduplication in the mapping as case-insensitive file system would 
+  // "deduplicate" clashing paths automatically.
   VFSWriter.setCaseSensitivity(isCaseSensitivePath(OverlayRoot));
   VFSWriter.setUseExternalNames(false);
 
   std::error_code EC;
   raw_fd_ostream os(mapping_file, EC, sys::fs::OF_Text);
   if (EC)
     return EC;