Move path computation into SourceManager

Author: Sirraide

clang/include/clang/Basic/SourceManager.h

@@ -820,6 +820,12 @@ class SourceManager : public RefCountedBase<SourceManager> {
 
   mutable std::unique_ptr<SrcMgr::SLocEntry> FakeSLocEntryForRecovery;
 
+  /// Cache for filenames used in diagnostics. See 'getNameForDiagnostic()'.
+  mutable llvm::StringMap<StringRef> DiagNames;
+
+  /// Allocator for absolute/short names.
+  mutable llvm::BumpPtrAllocator DiagNameAlloc;
+
   /// Lazily computed map of macro argument chunks to their expanded
   /// source location.
   using MacroArgsMap = std::map<unsigned, SourceLocation>;
@@ -1847,6 +1853,9 @@ class SourceManager : public RefCountedBase<SourceManager> {
   /// \return Location of the top-level macro caller.
   SourceLocation getTopMacroCallerLoc(SourceLocation Loc) const;
 
+  /// Retrieve the name of a file suitable for diagnostics.
+  StringRef getNameForDiagnostic(StringRef Filename) const;
+
 private:
   friend class ASTReader;
   friend class ASTWriter;

clang/lib/Basic/SourceManager.cpp

@@ -2403,3 +2403,58 @@ SourceManagerForFile::SourceManagerForFile(StringRef FileName,
   assert(ID.isValid());
   SourceMgr->setMainFileID(ID);
 }
+
+StringRef SourceManager::getNameForDiagnostic(StringRef Filename) const {
+  OptionalFileEntryRef File = getFileManager().getOptionalFileRef(Filename);
+  if (!File)
+    return Filename;
+
+  // Try to simplify paths that contain '..' in any case since paths to
+  // standard library headers especially tend to get quite long otherwise.
+  // Only do that for local filesystems though to avoid slowing down
+  // compilation too much.
+  bool Absolute = Diag.getDiagnosticOptions().AbsolutePath;
+  bool AlwaysSimplify = File->getName().contains("..") &&
+                        llvm::sys::fs::is_local(File->getName());
+  if (!Absolute && !AlwaysSimplify)
+    return Filename;
+
+  // This may involve computing canonical names, so cache the result.
+  StringRef &CacheEntry = DiagNames[Filename];
+  if (!CacheEntry.empty())
+    return CacheEntry;
+
+  // We want to print a simplified absolute path, i. e. without "dots".
+  //
+  // The hardest part here are the paths like "<part1>/<link>/../<part2>".
+  // On Unix-like systems, we cannot just collapse "<link>/..", because
+  // paths are resolved sequentially, and, thereby, the path
+  // "<part1>/<part2>" may point to a different location. That is why
+  // we use FileManager::getCanonicalName(), which expands all indirections
+  // with llvm::sys::fs::real_path() and caches the result.
+  //
+  // On the other hand, it would be better to preserve as much of the
+  // original path as possible, because that helps a user to recognize it.
+  // real_path() expands all links, which sometimes too much. Luckily,
+  // on Windows we can just use llvm::sys::path::remove_dots(), because,
+  // on that system, both aforementioned paths point to the same place.
+  SmallString<256> TempBuf;
+#ifdef _WIN32
+  TempBuf = File->getName();
+  llvm::sys::fs::make_absolute(TempBuf);
+  llvm::sys::path::native(TempBuf);
+  llvm::sys::path::remove_dots(TempBuf, /* remove_dot_dot */ true);
+#else
+  TempBuf = getFileManager().getCanonicalName(*File);
+#endif
+
+  // In some cases, the resolved path may actually end up being longer (e.g.
+  // if it was originally a relative path), so just retain whichever one
+  // ends up being shorter.
+  if (!Absolute && TempBuf.size() > Filename.size())
+    CacheEntry = Filename;
+  else
+    CacheEntry = TempBuf.str().copy(DiagNameAlloc);
+
+  return CacheEntry;
+}

clang/lib/Frontend/SARIFDiagnostic.cpp

@@ -163,36 +163,7 @@ SARIFDiagnostic::addDiagnosticLevelToRule(SarifRule Rule,
 
 llvm::StringRef SARIFDiagnostic::emitFilename(StringRef Filename,
                                               const SourceManager &SM) {
-  if (DiagOpts.AbsolutePath) {
-    auto File = SM.getFileManager().getOptionalFileRef(Filename);
-    if (File) {
-      // We want to print a simplified absolute path, i. e. without "dots".
-      //
-      // The hardest part here are the paths like "<part1>/<link>/../<part2>".
-      // On Unix-like systems, we cannot just collapse "<link>/..", because
-      // paths are resolved sequentially, and, thereby, the path
-      // "<part1>/<part2>" may point to a different location. That is why
-      // we use FileManager::getCanonicalName(), which expands all indirections
-      // with llvm::sys::fs::real_path() and caches the result.
-      //
-      // On the other hand, it would be better to preserve as much of the
-      // original path as possible, because that helps a user to recognize it.
-      // real_path() expands all links, which is sometimes too much. Luckily,
-      // on Windows we can just use llvm::sys::path::remove_dots(), because,
-      // on that system, both aforementioned paths point to the same place.
-#ifdef _WIN32
-      SmallString<256> TmpFilename = File->getName();
-      llvm::sys::fs::make_absolute(TmpFilename);
-      llvm::sys::path::native(TmpFilename);
-      llvm::sys::path::remove_dots(TmpFilename, /* remove_dot_dot */ true);
-      Filename = StringRef(TmpFilename.data(), TmpFilename.size());
-#else
-      Filename = SM.getFileManager().getCanonicalName(*File);
-#endif
-    }
-  }
-
-  return Filename;
+  return SM.getNameForDiagnostic(Filename);
 }
 
 /// Print out the file/line/column information and include trace.

clang/lib/Frontend/TextDiagnostic.cpp

@@ -738,53 +738,7 @@ void TextDiagnostic::printDiagnosticMessage(raw_ostream &OS,
 }
 
 void TextDiagnostic::emitFilename(StringRef Filename, const SourceManager &SM) {
-  auto File = SM.getFileManager().getOptionalFileRef(Filename);
-
-  // Try to simplify paths that contain '..' in any case since paths to
-  // standard library headers especially tend to get quite long otherwise.
-  // Only do that for local filesystems though to avoid slowing down
-  // compilation too much.
-  auto AlwaysSimplify = [&] {
-    return File->getName().contains("..") &&
-           llvm::sys::fs::is_local(File->getName());
-  };
-
-  if (File && (DiagOpts.AbsolutePath || AlwaysSimplify())) {
-    SmallString<128> &CacheEntry = SimplifiedFileNameCache[Filename];
-    if (CacheEntry.empty()) {
-      // We want to print a simplified absolute path, i. e. without "dots".
-      //
-      // The hardest part here are the paths like "<part1>/<link>/../<part2>".
-      // On Unix-like systems, we cannot just collapse "<link>/..", because
-      // paths are resolved sequentially, and, thereby, the path
-      // "<part1>/<part2>" may point to a different location. That is why
-      // we use FileManager::getCanonicalName(), which expands all indirections
-      // with llvm::sys::fs::real_path() and caches the result.
-      //
-      // On the other hand, it would be better to preserve as much of the
-      // original path as possible, because that helps a user to recognize it.
-      // real_path() expands all links, which sometimes too much. Luckily,
-      // on Windows we can just use llvm::sys::path::remove_dots(), because,
-      // on that system, both aforementioned paths point to the same place.
-#ifdef _WIN32
-      CacheEntry = File->getName();
-      llvm::sys::fs::make_absolute(CacheEntry);
-      llvm::sys::path::native(CacheEntry);
-      llvm::sys::path::remove_dots(CacheEntry, /* remove_dot_dot */ true);
-#else
-      CacheEntry = SM.getFileManager().getCanonicalName(*File);
-#endif
-
-      // In some cases, the resolved path may actually end up being longer (e.g.
-      // if it was originally a relative path), so just retain whichever one
-      // ends up being shorter.
-      if (!DiagOpts.AbsolutePath && CacheEntry.size() > Filename.size())
-        CacheEntry = Filename;
-    }
-    Filename = CacheEntry;
-  }
-
-  OS << Filename;
+  OS << SM.getNameForDiagnostic(Filename);
 }
 
 /// Print out the file/line/column information and include trace.