Refactor EXPECT_SAME_FILE: don't rely on canonicalize_path

canonicalize_path might be buggy, so we shouldn't rely on it in our
assertions. Reimplement EXPECT_SAME_FILE using more reliable primitives.

Author: strager

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

@@ -4,29 +4,63 @@
 #ifndef QUICK_LINT_JS_FILE_MATCHER_H
 #define QUICK_LINT_JS_FILE_MATCHER_H
 
+#include <cerrno>
+#include <cstring>
 #include <gtest/gtest.h>
 #include <quick-lint-js/file.h>
+#include <quick-lint-js/have.h>
+
+#if QLJS_HAVE_STD_FILESYSTEM
+#include <filesystem>
+#endif
+
+#if QLJS_HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
 
 #define EXPECT_SAME_FILE(path_a, path_b) \
   EXPECT_PRED_FORMAT2(::quick_lint_js::assert_same_file, path_a, path_b)
 
 namespace quick_lint_js {
-template <class String>
-::testing::AssertionResult assert_same_file(const char *lhs_expr,
-                                            const char *rhs_expr,
-                                            String lhs_path, String rhs_path) {
-  canonical_path_result lhs_canonical = canonicalize_path(lhs_path);
-  EXPECT_TRUE(lhs_canonical.ok()) << std::move(lhs_canonical).error();
-  canonical_path_result rhs_canonical = canonicalize_path(rhs_path);
-  EXPECT_TRUE(rhs_canonical.ok()) << std::move(rhs_canonical).error();
-  if (lhs_canonical.path() == rhs_canonical.path()) {
+inline ::testing::AssertionResult assert_same_file(const char* lhs_expr,
+                                                   const char* rhs_expr,
+                                                   const char* lhs_path,
+                                                   const char* rhs_path) {
+  bool same;
+#if QLJS_HAVE_STD_FILESYSTEM
+  // TODO(strager): std::filesystem::equivalent treats differnt symlinks
+  // pointing to the same file as equivalent. This behavior differs from our
+  // lstat-based implementation below.
+  same = std::filesystem::equivalent(lhs_path, rhs_path);
+#elif QLJS_HAVE_SYS_STAT_H
+  {
+    struct stat lhs_stat = {};
+    EXPECT_EQ(::lstat(lhs_path, &lhs_stat), 0) << std::strerror(errno);
+
+    struct stat rhs_stat = {};
+    EXPECT_EQ(::lstat(rhs_path, &rhs_stat), 0) << std::strerror(errno);
+
+    same = lhs_stat.st_dev == rhs_stat.st_dev &&
+           lhs_stat.st_ino == rhs_stat.st_ino;
+  }
+#else
+#error "Unsupported platform"
+#endif
+  if (same) {
     return ::testing::AssertionSuccess();
   } else {
     return ::testing::AssertionFailure()
            << lhs_expr << " (" << lhs_path << ") is not the same file as "
            << rhs_expr << " (" << rhs_path << ')';
   }
 }
+
+inline ::testing::AssertionResult assert_same_file(
+    const char* lhs_expr, const char* rhs_expr, const std::string& lhs_path,
+    const std::string& rhs_path) {
+  return assert_same_file(lhs_expr, rhs_expr, lhs_path.c_str(),
+                          rhs_path.c_str());
+}
 }
 
 #endif