Allow finding config even if file doesn't exist

To support editors which allow editing new, not-created, unsaved files,
we need to search for config files even if the file (or its parent
directory) doesn't exist. Add smarts to canonicalize_path to succeed
even if the file doesn't exist.

Author: strager

src/configuration-loader.cpp

@@ -63,8 +63,13 @@ configuration* configuration_loader::find_and_load_config_file(
     return nullptr;
   }
 
+  bool should_drop_file_name = input_path != nullptr;
+  if (canonical_input_path.have_missing_components()) {
+    canonical_input_path.drop_missing_components();
+    should_drop_file_name = false;
+  }
   canonical_path parent_directory = std::move(canonical_input_path).canonical();
-  if (input_path) {
+  if (should_drop_file_name) {
     parent_directory.parent();
   }
 

src/file-canonical.cpp

@@ -171,10 +171,9 @@ bool canonical_path::parent() {
 
 canonical_path_result::canonical_path_result() {}
 
-canonical_path_result::canonical_path_result(std::string &&path)
-    : path_(std::move(path)) {}
-
-canonical_path_result::canonical_path_result(const char *path) : path_(path) {}
+canonical_path_result::canonical_path_result(std::string &&path,
+                                             std::size_t existing_path_length)
+    : path_(std::move(path)), existing_path_length_(existing_path_length) {}
 
 std::string_view canonical_path_result::path() const &noexcept {
   QLJS_ASSERT(this->ok());
@@ -206,6 +205,16 @@ std::string &&canonical_path_result::error() && noexcept {
   return std::move(this->error_);
 }
 
+bool canonical_path_result::have_missing_components() const noexcept {
+  QLJS_ASSERT(this->ok());
+  return this->existing_path_length_ != this->path_->path_.size();
+}
+
+void canonical_path_result::drop_missing_components() {
+  QLJS_ASSERT(this->ok());
+  this->path_->path_.resize(this->existing_path_length_);
+}
+
 canonical_path_result canonical_path_result::failure(std::string &&error) {
   canonical_path_result result;
   result.error_ = std::move(error);
@@ -224,9 +233,13 @@ class path_canonicalizer {
     }
 #if QLJS_PATHS_WIN32
     // HACK(strager): Convert UTF-16 to UTF-8.
-    return canonical_path_result(std::filesystem::path(canonical_).string());
+    // TODO(strager): existing_path_length_ is in UTF-16 code units, but it's
+    // interpreted as UTF-8 code units! Fix by storing a std::wstring in
+    // canonical_path.
+    return canonical_path_result(std::filesystem::path(canonical_).string(),
+                                 existing_path_length_);
 #else
-    return canonical_path_result(std::move(canonical_));
+    return canonical_path_result(std::move(canonical_), existing_path_length_);
 #endif
   }
 
@@ -251,13 +264,18 @@ class path_canonicalizer {
 #endif
       canonical_ += preferred_component_separator;
     }
+
+    if (existing_path_length_ == 0) {
+      existing_path_length_ = canonical_.size();
+    }
   }
 
  private:
   enum class file_type {
     error,
 
     directory,
+    does_not_exist,
     other,
     symlink,
   };
@@ -358,19 +376,41 @@ class path_canonicalizer {
     if (component == dot) {
       skip_to_next_component();
     } else if (component == dot_dot) {
-      parent();
+      if (existing_path_length_ == 0) {
+        parent();
+      } else {
+        QLJS_ASSERT(!canonical_.empty());
+        canonical_ += preferred_component_separator;
+        canonical_ += component;
+      }
       skip_to_next_component();
     } else {
+      std::size_t canonical_length_without_component = canonical_.size();
+
       canonical_ += preferred_component_separator;
       canonical_ += component;
       need_root_slash_ = false;
 
+      if (existing_path_length_ != 0) {
+        // A parent path did not exist, so this path certainly does not exist.
+        // Don't bother checking.
+        skip_to_next_component();
+        return;
+      }
+
       file_type type = get_file_type(canonical_);
       switch (type) {
       case file_type::error:
         QLJS_ASSERT(!error_.empty());
         return;
 
+      case file_type::does_not_exist:
+        if (existing_path_length_ == 0) {
+          existing_path_length_ = canonical_length_without_component;
+        }
+        skip_to_next_component();
+        break;
+
       case file_type::directory:
         skip_to_next_component();
         break;
@@ -448,10 +488,14 @@ class path_canonicalizer {
 #if defined(_WIN32)
     DWORD attributes = ::GetFileAttributesW(file_path.c_str());
     if (attributes == INVALID_FILE_ATTRIBUTES) {
+      DWORD error = ::GetLastError();
+      if (error == ERROR_FILE_NOT_FOUND) {
+        return file_type::does_not_exist;
+      }
       error_ = std::string("failed to canonicalize path ") +
                string_for_error_message(original_path_) + ": " +
                string_for_error_message(canonical_) + ": " +
-               windows_error_message(::GetLastError());
+               windows_error_message(error);
       return file_type::error;
     }
     if (attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
@@ -465,6 +509,9 @@ class path_canonicalizer {
     struct stat s;
     int lstat_rc = ::lstat(file_path.c_str(), &s);
     if (lstat_rc == -1) {
+      if (errno == ENOENT) {
+        return file_type::does_not_exist;
+      }
       error_ = std::string("failed to canonicalize path ") +
                string_for_error_message(original_path_) + ": " +
                string_for_error_message(canonical_) + ": " +
@@ -540,6 +587,13 @@ class path_canonicalizer {
   path_string canonical_;
   bool need_root_slash_;
 
+  // During canonicalization, if existing_path_length_ is 0, then we have not
+  // found a non-existing path.
+  //
+  // During canonicalization, if existing_path_length_ is not 0, then we have
+  // found a non-existing path. '..' should be preserved.
+  std::size_t existing_path_length_ = 0;
+
   path_string readlink_buffers_[2];
   int used_readlink_buffer_ = 0;  // Index into readlink_buffers_.
 

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

@@ -11,16 +11,24 @@
 #include <string_view>
 
 namespace quick_lint_js {
+class canonical_path_result;
+
 // 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 '.' components.
+// * The path has no '..' components, unless the exception mentioned below
+//   applies.
 // * 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.
+//
+// Exception to the above rules: A canonical_path can contain one or more '..'
+// components before canonical_path_result::drop_missing_components has been
+// called.
 class canonical_path {
  public:
   // Does not check the validity of the path.
@@ -57,12 +65,14 @@ class canonical_path {
 
  private:
   std::string path_;
+
+  friend canonical_path_result;
 };
 
 class canonical_path_result {
  public:
-  explicit canonical_path_result(std::string &&path);
-  explicit canonical_path_result(const char *path);
+  explicit canonical_path_result(std::string &&path,
+                                 std::size_t existing_path_length);
 
   std::string_view path() const &noexcept;
   std::string &&path() && noexcept;
@@ -75,13 +85,17 @@ class canonical_path_result {
 
   bool ok() const noexcept { return this->error_.empty(); }
 
+  bool have_missing_components() const noexcept;
+  void drop_missing_components();
+
   static canonical_path_result failure(std::string &&error);
 
  private:
   explicit canonical_path_result();
 
   std::optional<canonical_path> path_;
   std::string error_;
+  std::size_t existing_path_length_;
 };
 
 canonical_path_result canonicalize_path(const char *path);

test/quick-lint-js/file-matcher.h

@@ -37,10 +37,12 @@ inline ::testing::AssertionResult assert_same_file(const char* lhs_expr,
 #elif QLJS_HAVE_SYS_STAT_H
   {
     struct stat lhs_stat = {};
-    EXPECT_EQ(::lstat(lhs_path, &lhs_stat), 0) << std::strerror(errno);
+    EXPECT_EQ(::lstat(lhs_path, &lhs_stat), 0)
+        << lhs_path << ": " << std::strerror(errno);
 
     struct stat rhs_stat = {};
-    EXPECT_EQ(::lstat(rhs_path, &rhs_stat), 0) << std::strerror(errno);
+    EXPECT_EQ(::lstat(rhs_path, &rhs_stat), 0)
+        << rhs_path << ": " << std::strerror(errno);
 
     same = lhs_stat.st_dev == rhs_stat.st_dev &&
            lhs_stat.st_ino == rhs_stat.st_ino;

test/test-configuration-loader.cpp

@@ -10,6 +10,7 @@
 #include <quick-lint-js/configuration.h>
 #include <quick-lint-js/file-canonical.h>
 #include <quick-lint-js/file-matcher.h>
+#include <quick-lint-js/file-path.h>
 #include <quick-lint-js/file.h>
 #include <quick-lint-js/options.h>
 #include <quick-lint-js/temporary-directory.h>
@@ -414,7 +415,9 @@ TEST_F(test_configuration_loader, missing_config_file_fails) {
   });
 
   EXPECT_FALSE(config);
-  EXPECT_THAT(loader.error(), HasSubstr(config_file));
+  EXPECT_THAT(loader.error(),
+              HasSubstr(temp_dir + QLJS_PREFERRED_PATH_DIRECTORY_SEPARATOR +
+                        "config.json"));
   EXPECT_THAT(loader.error(),
               AnyOf(HasSubstr("No such file"), HasSubstr("cannot find")));
 }
@@ -559,7 +562,8 @@ TEST_F(
   }
 }
 
-TEST_F(test_configuration_loader, finding_config_fails_if_file_is_missing) {
+TEST_F(test_configuration_loader,
+       finding_config_succeeds_even_if_file_is_missing) {
   std::string temp_dir = this->make_temporary_directory();
   std::string config_file = temp_dir + "/quick-lint-js.config";
   write_file(config_file, u8R"({})"sv);
@@ -571,10 +575,25 @@ TEST_F(test_configuration_loader, finding_config_fails_if_file_is_missing) {
       .config_file = nullptr,
   });
 
-  EXPECT_FALSE(config);
-  EXPECT_THAT(loader.error(), HasSubstr(js_file));
-  EXPECT_THAT(loader.error(),
-              AnyOf(HasSubstr("No such file"), HasSubstr("cannot find")));
+  EXPECT_TRUE(config);
+  EXPECT_SAME_FILE(config->config_file_path(), config_file);
+}
+
+TEST_F(test_configuration_loader,
+       finding_config_succeeds_even_if_directory_is_missing) {
+  std::string temp_dir = this->make_temporary_directory();
+  std::string config_file = temp_dir + "/quick-lint-js.config";
+  write_file(config_file, u8R"({})"sv);
+
+  std::string js_file = temp_dir + "/dir/hello.js";
+  configuration_loader loader;
+  configuration* config = loader.load_for_file(file_to_lint{
+      .path = js_file.c_str(),
+      .config_file = nullptr,
+  });
+
+  EXPECT_TRUE(config);
+  EXPECT_SAME_FILE(config->config_file_path(), config_file);
 }
 }
 }