[lldb] WIP: idea for keeping filenames in raw form when coming from DWARF

[kwk]

Summary

PLEASE DO NOT REVIEW YET. This is for brainstorming an idea with @labath

[kwk]

I abandon this revision because @labath mentioned that in the past we must have had something similar: two file specs where one was normalized and one doesn't and then the behavior was not very predictable. I hope this recaptures our conversation on IRC well enough.

lldb/include/lldb/Utility/FileSpec.h

public:
   /// FileSpec::SetFile (const char *path).
   ///
   /// \param[in] path
   ///     The full or partial path to a file.
   ///
   /// \param[in] style
   ///     The style of the path
   ///
+  /// \param[in] normalize
+  ///     Whether or not to cleanup the filepath or not.
+  ///
   /// \see FileSpec::SetFile (const char *path)
-  explicit FileSpec(llvm::StringRef path, Style style = Style::native);
+  explicit FileSpec(llvm::StringRef path, Style style = Style::native,
+                    bool normalize = true);
 
   explicit FileSpec(llvm::StringRef path, const llvm::Triple &triple);
 
   bool DirectoryEquals(const FileSpec &other) const;
 
   bool FileEquals(const FileSpec &other) const;
 
   /// Equal to operator
public:
   /// split up into a directory and filename and stored as uniqued string
   /// values for quick comparison and efficient memory usage.
   ///
   /// \param[in] path
   ///     A full, partial, or relative path to a file.
   ///
   /// \param[in] style
   ///     The style for the given path.
-  void SetFile(llvm::StringRef path, Style style);
+  ///
+  /// \param[in] normalize
+  ///     Whether or not to cleanup the filepath or not.
+  void SetFile(llvm::StringRef path, Style style, bool normalize = true);
 
   /// Change the file specified with a new path.
   ///
   /// Update the contents of this object with a new path. The path will be
   /// split up into a directory and filename and stored as uniqued string
   /// values for quick comparison and efficient memory usage.
   ///
   /// \param[in] path
   ///     A full, partial, or relative path to a file.
   ///
   /// \param[in] triple
   ///     The triple which is used to set the Path style.
   void SetFile(llvm::StringRef path, const llvm::Triple &triple);
 
+  /// \returns \c true if the normalized FileSpec is the same as this; otherwise
+  /// \c false is returned.
+  bool IsNormalized() const;
+
   bool IsResolved() const { return m_is_resolved; }
 
   /// Set if the file path has been resolved or not.
   ///
   /// If you know a file path is already resolved and avoided passing a \b
   /// true parameter for any functions that take a "bool resolve_path"
   /// parameter, you can set the value manually using this call to make sure
   /// we don't try and resolve it later, or try and resolve a path that has

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

ParseSupportFilesFromPrologue(const lldb::ModuleSP &module,
   const size_t number_of_files = prologue.FileNames.size();
   for (size_t idx = first_file; idx <= number_of_files; ++idx) {
     std::string remapped_file;
     if (auto file_path = GetFileByIndex(prologue, idx, compile_dir, style))
       if (!module->RemapSourceFile(llvm::StringRef(*file_path), remapped_file))
         remapped_file = std::move(*file_path);
 
     // Unconditionally add an entry, so the indices match up.
-    support_files.EmplaceBack(remapped_file, style);
+    support_files.EmplaceBack(remapped_file, style, false);
   }
 
   return support_files;
 }
 
 void SymbolFileDWARF::Initialize() {
   LogChannelDWARF::Initialize();
   PluginManager::RegisterPlugin(GetPluginNameStatic(),

lldb/source/Utility/FileSpec.cpp

void Denormalize(llvm::SmallVectorImpl<char> &path, FileSpec::Style style) {
   std::replace(path.begin(), path.end(), '/', '\\');
 }
 
 } // end anonymous namespace
 
 FileSpec::FileSpec() : m_style(GetNativeStyle()) {}
 
 // Default constructor that can take an optional full path to a file on disk.
-FileSpec::FileSpec(llvm::StringRef path, Style style) : m_style(style) {
-  SetFile(path, style);
+FileSpec::FileSpec(llvm::StringRef path, Style style, bool normalize)
+    : m_style(style) {
+  SetFile(path, style, normalize);
 }
 
 FileSpec::FileSpec(llvm::StringRef path, const llvm::Triple &triple)
     : FileSpec{path, triple.isOSWindows() ? Style::windows : Style::posix} {}
 
 namespace {
 /// Safely get a character at the specified index.
 ///

 
 }
 
 void FileSpec::SetFile(llvm::StringRef pathname) { SetFile(pathname, m_style); }
 
 // Update the contents of this object with a new path. The path will be split
 // up into a directory and filename and stored as uniqued string values for
 // quick comparison and efficient memory usage.
-void FileSpec::SetFile(llvm::StringRef pathname, Style style) {
+void FileSpec::SetFile(llvm::StringRef pathname, Style style, bool normalize) {
   m_filename.Clear();
   m_directory.Clear();
   m_is_resolved = false;
   m_style = (style == Style::native) ? GetNativeStyle() : style;
 
   if (pathname.empty())
     return;
 
   llvm::SmallString<128> resolved(pathname);
 
   // Normalize the path by removing ".", ".." and other redundant components.
-  if (needsNormalization(resolved))
+  if (normalize && needsNormalization(resolved))
     llvm::sys::path::remove_dots(resolved, true, m_style);
 
   // Normalize back slashes to forward slashes
-  if (m_style == Style::windows)
+  if (normalize && m_style == Style::windows)
     std::replace(resolved.begin(), resolved.end(), '\\', '/');
 
   if (resolved.empty()) {
     // If we have no path after normalization set the path to the current
     // directory. This matches what python does and also a few other path
     // utilities.
     m_filename.SetString(".");
     return;
void FileSpec::SetFile(llvm::StringRef pathname, Style style, bool normalize) {
   if(!directory.empty())
     m_directory.SetString(directory);
 }
 
 void FileSpec::SetFile(llvm::StringRef path, const llvm::Triple &triple) {
   return SetFile(path, triple.isOSWindows() ? Style::windows : Style::posix);
 }
 
+bool FileSpec::IsNormalized() const {
+  return *this == FileSpec(GetPath(), m_style, true);
+}
+
 // Convert to pointer operator. This allows code to check any FileSpec objects
 // to see if they contain anything valid using code such as:
 //
 //  if (file_spec)
 //  {}
 FileSpec::operator bool() const { return m_filename || m_directory; }
 
 // Logical NOT operator. This allows code to check any FileSpec objects to see