Encapsulate canonical_path_result

I want to change canonical_path_result's representation, but its guts
are exposed everywhere. Encapsulate canonical_path_result by hiding its
private variables and exposing accessor functions.

This commit should not change behavior.

Author: strager

src/configuration-loader.cpp

@@ -10,6 +10,7 @@
 #include <quick-lint-js/warning.h>
 #include <string_view>
 #include <unordered_map>
+#include <utility>
 
 using namespace std::literals::string_view_literals;
 
@@ -25,7 +26,7 @@ configuration* configuration_loader::load_for_file(const file_to_lint& file) {
 configuration* configuration_loader::load_config_file(const char* config_path) {
   canonical_path_result canonical_config_path = canonicalize_path(config_path);
   if (!canonical_config_path.ok()) {
-    this->last_error_ = std::move(canonical_config_path.error);
+    this->last_error_ = std::move(canonical_config_path).error();
     return nullptr;
   }
 
@@ -38,8 +39,12 @@ configuration* configuration_loader::load_config_file(const char* config_path) {
     this->last_error_ = std::move(config_json.error);
     return nullptr;
   }
-  configuration* config =
-      &this->loaded_config_files_[canonical_config_path.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());
+  QLJS_ASSERT(inserted);
+  configuration* config = &config_it->second;
   config->set_config_file_path(canonical_config_path.c_str());
   config->load_from_json(&config_json.content);
   return config;
@@ -53,13 +58,13 @@ configuration* configuration_loader::find_and_load_config_file(
   canonical_path_result canonical_input_path =
       canonicalize_path(input_path ? input_path : ".");
   if (!canonical_input_path.ok()) {
-    this->last_error_ = std::move(canonical_input_path.error);
+    this->last_error_ = std::move(canonical_input_path).error();
     return nullptr;
   }
 
   std::string parent_directory =
-      input_path ? parent_path(std::move(canonical_input_path.path))
-                 : std::move(canonical_input_path.path);
+      input_path ? parent_path(std::move(canonical_input_path).path())
+                 : std::move(canonical_input_path).path();
 
   // TODO(strager): Directory -> config to reduce lookups in cases like the
   // following:

src/file.cpp

@@ -277,14 +277,33 @@ void write_file(const char *path, string8_view content) {
   std::fclose(file);
 }
 
+canonical_path_result::canonical_path_result() {}
+
+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_;
+}
+
+std::string &&canonical_path_result::path() && noexcept {
+  QLJS_ASSERT(this->ok());
+  return std::move(this->path_);
+}
+
 const char *canonical_path_result::c_str() const noexcept {
   QLJS_ASSERT(this->ok());
-  return this->path.c_str();
+  return this->path_.c_str();
+}
+
+std::string &&canonical_path_result::error() && noexcept {
+  QLJS_ASSERT(!this->ok());
+  return std::move(this->error_);
 }
 
 canonical_path_result canonical_path_result::failure(std::string &&error) {
   canonical_path_result result;
-  result.error = std::move(error);
+  result.error_ = std::move(error);
   QLJS_ASSERT(!result.ok());
   return result;
 }
@@ -298,18 +317,15 @@ canonical_path_result canonicalize_path(const char *path) {
         std::string("failed to canonicalize path ") + path + ": " +
         error.message());
   }
-  canonical_path_result result;
-  result.path = canonical.string();
-  return result;
+  return canonical_path_result(canonical.string().c_str());
 #elif QLJS_HAVE_REALPATH
   char *allocated_canonical = ::realpath(path, nullptr);
   if (!allocated_canonical) {
     return canonical_path_result::failure(
         std::string("failed to canonicalize path ") + path + ": " +
         std::strerror(errno));
   }
-  canonical_path_result result;
-  result.path = allocated_canonical;
+  canonical_path_result result(allocated_canonical);
   std::free(allocated_canonical);
   return result;
 #else

src/quick-lint-js/file.h

@@ -30,15 +30,25 @@ read_file_result read_stdin(void);
 void write_file(const std::string &path, string8_view content);
 void write_file(const char *path, string8_view content);
 
-struct canonical_path_result {
-  std::string path;
-  std::string error;
-
-  bool ok() const noexcept { return this->error.empty(); }
+class canonical_path_result {
+ public:
+  explicit canonical_path_result(const char *path);
 
+  std::string_view path() const &noexcept;
+  std::string &&path() && noexcept;
   const char *c_str() const noexcept;
 
+  std::string &&error() && noexcept;
+
+  bool ok() const noexcept { return this->error_.empty(); }
+
   static canonical_path_result failure(std::string &&error);
+
+ private:
+  explicit canonical_path_result();
+
+  std::string path_;
+  std::string error_;
 };
 
 canonical_path_result canonicalize_path(const char *path);

test/test-configuration-loader.cpp

@@ -33,10 +33,12 @@ QLJS_WARNING_IGNORE_GCC("-Wmissing-field-initializers")
 #define EXPECT_SAME_FILE(path_a, path_b)                                   \
   do {                                                                     \
     canonical_path_result path_a_canonical_ = canonicalize_path((path_a)); \
-    ASSERT_TRUE(path_a_canonical_.ok()) << path_a_canonical_.error;        \
+    ASSERT_TRUE(path_a_canonical_.ok())                                    \
+        << std::move(path_a_canonical_).error();                           \
     canonical_path_result path_b_canonical_ = canonicalize_path((path_b)); \
-    ASSERT_TRUE(path_b_canonical_.ok()) << path_b_canonical_.error;        \
-    EXPECT_EQ(path_a_canonical_.path, path_b_canonical_.path)              \
+    ASSERT_TRUE(path_b_canonical_.ok())                                    \
+        << std::move(path_b_canonical_).error();                           \
+    EXPECT_EQ(path_a_canonical_.path(), path_b_canonical_.path())          \
         << (path_a) << " should be the same file as " << (path_b);         \
   } while (false)
 
@@ -208,7 +210,8 @@ TEST_F(test_configuration_loader, quick_lint_js_config_directory_fails) {
     });
 
     EXPECT_FALSE(config);
-    EXPECT_THAT(loader.error(), HasSubstr(canonicalize_path(config_file).path));
+    EXPECT_THAT(loader.error(),
+                HasSubstr(canonicalize_path(config_file).c_str()));
     EXPECT_THAT(
         loader.error(),
         AnyOf(HasSubstr("Is a directory"),

test/test-file.cpp

@@ -206,7 +206,7 @@ TEST_F(test_file, canonical_path_to_regular_file) {
   write_file(temp_file_path, u8"hello\nworld!\n");
 
   canonical_path_result canonical = canonicalize_path(temp_file_path);
-  ASSERT_TRUE(canonical.ok()) << canonical.error;
+  ASSERT_TRUE(canonical.ok()) << std::move(canonical).error();
 
   read_file_result file_content = read_file(canonical.c_str());
   ASSERT_TRUE(file_content.ok()) << file_content.error;
@@ -219,8 +219,9 @@ TEST_F(test_file, canonical_path_to_non_existing_file) {
 
   canonical_path_result canonical = canonicalize_path(temp_file_path);
   EXPECT_FALSE(canonical.ok());
-  EXPECT_THAT(canonical.error, HasSubstr("does-not-exist.js"));
-  EXPECT_THAT(canonical.error,
+  std::string error = std::move(canonical).error();
+  EXPECT_THAT(error, HasSubstr("does-not-exist.js"));
+  EXPECT_THAT(error,
               AnyOf(HasSubstr("No such file"), HasSubstr("cannot find")));
 }
 }