Create canonical_path class

Using std::string everywhere is a bit sloppy. Eventually, I want
to use a std::wstring on Windows instead of a std::string. Create a
canonical_path class to encapsulate the std::string.

This commit should not change behavior.

Author: strager

src/configuration-loader.cpp

@@ -32,7 +32,7 @@ configuration* configuration_loader::load_config_file(const char* config_path) {
   }
 
   if (configuration* config =
-          this->get_loaded_config(canonical_config_path.c_str())) {
+          this->get_loaded_config(canonical_config_path.canonical())) {
     return config;
   }
   read_file_result config_json = read_file(canonical_config_path.c_str());
@@ -42,7 +42,7 @@ configuration* configuration_loader::load_config_file(const char* config_path) {
   }
   auto [config_it, inserted] = this->loaded_config_files_.emplace(
       std::piecewise_construct,
-      std::forward_as_tuple(canonical_config_path.path()),
+      std::forward_as_tuple(canonical_config_path.canonical()),
       std::forward_as_tuple());
   QLJS_ASSERT(inserted);
   configuration* config = &config_it->second;
@@ -83,14 +83,18 @@ configuration* configuration_loader::find_and_load_config_file(
       QLJS_ASSERT(config_path == parent_directory);
       config_path.append(suffix);
 
-      if (configuration* config =
-              this->get_loaded_config(config_path.c_str())) {
+      if (configuration* config = this->get_loaded_config(config_path)) {
         return config;
       }
 
       read_file_result config_json = read_file(config_path.c_str());
       if (config_json.ok()) {
-        configuration* config = &this->loaded_config_files_[config_path];
+        auto [config_it, inserted] = this->loaded_config_files_.emplace(
+            std::piecewise_construct,
+            std::forward_as_tuple(canonical_path(std::string(config_path))),
+            std::forward_as_tuple());
+        QLJS_ASSERT(inserted);
+        configuration* config = &config_it->second;
         config->set_config_file_path(std::move(config_path));
         config->load_from_json(&config_json.content);
         return config;
@@ -119,7 +123,20 @@ configuration* configuration_loader::find_and_load_config_file(
 QLJS_WARNING_POP
 
 configuration* configuration_loader::get_loaded_config(
-    const char* path) noexcept {
+    const std::string& path) noexcept {
+#if QLJS_HAVE_STD_TRANSPARENT_KEYS
+  auto existing_config_it = this->loaded_config_files_.find(path);
+#else
+  auto existing_config_it =
+      this->loaded_config_files_.find(canonical_path(std::string(path)));
+#endif
+  return existing_config_it == this->loaded_config_files_.end()
+             ? nullptr
+             : &existing_config_it->second;
+}
+
+configuration* configuration_loader::get_loaded_config(
+    const canonical_path& path) noexcept {
   auto existing_config_it = this->loaded_config_files_.find(path);
   return existing_config_it == this->loaded_config_files_.end()
              ? nullptr

src/file-canonical.cpp

@@ -58,6 +58,42 @@ std::string string_for_error_message(std::wstring_view);
 #endif
 }
 
+canonical_path::canonical_path(std::string &&path) : path_(std::move(path)) {}
+
+std::string_view canonical_path::path() const &noexcept { return this->path_; }
+
+std::string &&canonical_path::path() && noexcept {
+  return std::move(this->path_);
+}
+
+const char *canonical_path::c_str() const noexcept {
+  return this->path_.c_str();
+}
+
+bool operator==(const canonical_path &lhs, const canonical_path &rhs) noexcept {
+  return lhs.path() == rhs.path();
+}
+
+bool operator!=(const canonical_path &lhs, const canonical_path &rhs) noexcept {
+  return !(lhs == rhs);
+}
+
+bool operator==(std::string_view lhs, const canonical_path &rhs) noexcept {
+  return lhs == rhs.path();
+}
+
+bool operator!=(std::string_view lhs, const canonical_path &rhs) noexcept {
+  return !(lhs == rhs);
+}
+
+bool operator==(const canonical_path &lhs, std::string_view rhs) noexcept {
+  return lhs.path() == rhs;
+}
+
+bool operator!=(const canonical_path &lhs, std::string_view rhs) noexcept {
+  return !(lhs == rhs);
+}
+
 canonical_path_result::canonical_path_result() {}
 
 canonical_path_result::canonical_path_result(std::string &&path)
@@ -67,17 +103,27 @@ canonical_path_result::canonical_path_result(const char *path) : path_(path) {}
 
 std::string_view canonical_path_result::path() const &noexcept {
   QLJS_ASSERT(this->ok());
-  return this->path_;
+  return this->path_->path();
 }
 
 std::string &&canonical_path_result::path() && noexcept {
   QLJS_ASSERT(this->ok());
-  return std::move(this->path_);
+  return std::move(*this->path_).path();
 }
 
 const char *canonical_path_result::c_str() const noexcept {
   QLJS_ASSERT(this->ok());
-  return this->path_.c_str();
+  return this->path_->c_str();
+}
+
+const canonical_path &canonical_path_result::canonical() const &noexcept {
+  QLJS_ASSERT(this->ok());
+  return *this->path_;
+}
+
+canonical_path &&canonical_path_result::canonical() && noexcept {
+  QLJS_ASSERT(this->ok());
+  return std::move(*this->path_);
 }
 
 std::string &&canonical_path_result::error() && noexcept {

src/quick-lint-js/configuration-loader.h

@@ -5,6 +5,7 @@
 #define QUICK_LINT_JS_CONFIGURATION_LOADER_H
 
 #include <quick-lint-js/configuration.h>
+#include <quick-lint-js/file-canonical.h>
 #include <string>
 #include <unordered_map>
 
@@ -21,10 +22,11 @@ class configuration_loader {
   configuration* load_config_file(const char* config_path);
   configuration* find_and_load_config_file(const char* input_path);
 
-  configuration* get_loaded_config(const char* path) noexcept;
+  configuration* get_loaded_config(const std::string& path) noexcept;
+  configuration* get_loaded_config(const canonical_path& path) noexcept;
 
   configuration default_config_;
-  std::unordered_map<std::string, configuration> loaded_config_files_;
+  std::unordered_map<canonical_path, configuration> loaded_config_files_;
   std::string last_error_;
 };
 }

src/quick-lint-js/file-canonical.h

@@ -4,9 +4,45 @@
 #ifndef QUICK_LINT_JS_FILE_CANONICAL_H
 #define QUICK_LINT_JS_FILE_CANONICAL_H
 
+#include <cstddef>
+#include <functional>
+#include <optional>
 #include <string>
+#include <string_view>
 
 namespace quick_lint_js {
+// A filesystem path.
+//
+// * The path is absolute (i.e. not relative to the current working directory or
+//   current drive). (The path is relative to the current chroot/jail/namespace,
+//   though.)
+// * The path has no '.' or '..' components.
+// * The path has no redundant component separators (\ or /, depending on the
+//   operating system).
+// * No subpath refers to a symlink, assuming no changes to the filesystem since
+//   creation of the canonical_path.
+class canonical_path {
+ public:
+  // Does not check the validity of the path.
+  explicit canonical_path(std::string &&path);
+
+  std::string_view path() const &noexcept;
+  std::string &&path() && noexcept;
+  const char *c_str() const noexcept;
+
+  friend bool operator==(const canonical_path &,
+                         const canonical_path &) noexcept;
+  friend bool operator!=(const canonical_path &,
+                         const canonical_path &) noexcept;
+  friend bool operator==(std::string_view, const canonical_path &) noexcept;
+  friend bool operator!=(std::string_view, const canonical_path &) noexcept;
+  friend bool operator==(const canonical_path &, std::string_view) noexcept;
+  friend bool operator!=(const canonical_path &, std::string_view) noexcept;
+
+ private:
+  std::string path_;
+};
+
 class canonical_path_result {
  public:
   explicit canonical_path_result(std::string &&path);
@@ -16,6 +52,9 @@ class canonical_path_result {
   std::string &&path() && noexcept;
   const char *c_str() const noexcept;
 
+  const canonical_path &canonical() const &noexcept;
+  canonical_path &&canonical() && noexcept;
+
   std::string &&error() && noexcept;
 
   bool ok() const noexcept { return this->error_.empty(); }
@@ -25,14 +64,30 @@ class canonical_path_result {
  private:
   explicit canonical_path_result();
 
-  std::string path_;
+  std::optional<canonical_path> path_;
   std::string error_;
 };
 
 canonical_path_result canonicalize_path(const char *path);
 canonical_path_result canonicalize_path(const std::string &path);
 }
 
+namespace std {
+template <>
+struct hash<quick_lint_js::canonical_path> {
+  using is_transparent = void;
+
+  std::size_t operator()(const quick_lint_js::canonical_path &path) const
+      noexcept {
+    return std::hash<std::string_view>()(path.path());
+  }
+
+  std::size_t operator()(std::string_view path) const noexcept {
+    return std::hash<std::string_view>()(path);
+  }
+};
+}
+
 #endif
 
 // quick-lint-js finds bugs in JavaScript programs.

src/quick-lint-js/have.h

@@ -313,6 +313,12 @@
 #define QLJS_HAVE_SETJMP 0
 #endif
 
+#if !defined(QLJS_HAVE_STD_TRANSPARENT_KEYS)
+// TODO(strager): Set this to 1 if is_transparent is supported by
+// std::unordered_map::find (C++20).
+#define QLJS_HAVE_STD_TRANSPARENT_KEYS 0
+#endif
+
 #endif
 
 // quick-lint-js finds bugs in JavaScript programs.