nfc: Add new path handling functions (#339)

Author: varungandhi-src

indexer/Path.cc

@@ -55,6 +55,44 @@ std::optional<std::string_view> AbsolutePathRef::fileName() const {
   return ::fileName(this->asStringView());
 }
 
+bool AbsolutePathRef::isNormalized() const {
+  auto start = llvm::sys::path::begin(this->value);
+  auto end = llvm::sys::path::end(this->value);
+  for (auto it = start; it != end; ++it) {
+    if (it->equals(".") || it->equals("..")) {
+      return false;
+    }
+  }
+  if (this->value.find("//") != std::string::npos) {
+    return false;
+  }
+
+#ifdef _WIN32
+  auto ix = this->value.find_last_of("\\");
+  // Absolute paths on Windows can begin with double backslash
+  if (ix != std::string::npos && ix != 0) {
+    return false;
+  }
+#endif
+
+  return true;
+}
+
+void AbsolutePathRef::normalize(llvm::SmallVectorImpl<char> &newStorage) {
+  newStorage.clear();
+  newStorage.append(this->asStringView().begin(), this->asStringView().end());
+  llvm::sys::path::remove_dots(newStorage);
+  *this =
+      AbsolutePathRef(std::string_view(newStorage.data(), newStorage.size()));
+}
+
+std::optional<AbsolutePathRef> AbsolutePathRef::prefix() const {
+  // NOTE(def: no-trailing-slash-for-dirs): The parent_path function omits
+  // any trailing separators for directories, so we should make sure that other
+  // places relying on path matching do the same.
+  return AbsolutePathRef::tryFrom(llvm::sys::path::parent_path(this->value));
+}
+
 AbsolutePathRef AbsolutePath::asRef() const {
   auto sv = std::string_view(this->value.data(), this->value.size());
   auto optRef = AbsolutePathRef::tryFrom(sv);
@@ -152,4 +190,4 @@ AbsolutePath RootPath::makeAbsoluteAllowKindMismatch(
   return AbsolutePath(fmt::format("{}{}{}", absPath, nativeSeparator, relPath));
 }
 
-} // namespace scip_clang
+} // namespace scip_clang

indexer/Path.h

@@ -2,12 +2,14 @@
 #define SCIP_CLANG_PATH_H
 
 #include <compare>
+#include <iterator>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator.h"
 #include "llvm/Support/JSON.h"
 
 #include "indexer/Comparison.h"
@@ -16,6 +18,34 @@
 
 namespace scip_clang {
 
+template <typename T>
+class PathPrefixIterator
+    : llvm::iterator_facade_base<PathPrefixIterator<T>, std::input_iterator_tag,
+                                 const T> {
+  std::optional<T> data;
+
+  using Self = PathPrefixIterator<T>;
+  using Base =
+      llvm::iterator_facade_base<Self, std::input_iterator_tag, const T>;
+
+public:
+  explicit PathPrefixIterator<T>(std::optional<T> data) : data(data) {}
+  bool operator==(const Self &other) const {
+    return this->data == other.data;
+  }
+
+  typename Base::reference operator*() const {
+    return this->data.value();
+  }
+
+  friend T;
+
+  Self &operator++() {
+    this->data = this->data->prefix();
+    return *this;
+  }
+};
+
 class AbsolutePathRef {
   std::string_view value; // is non-empty
 
@@ -44,6 +74,20 @@ class AbsolutePathRef {
   /// Try to get the file name by slicing off the prefix till the last
   /// path separator.
   std::optional<std::string_view> fileName() const;
+
+  bool isNormalized() const;
+
+  void normalize(llvm::SmallVectorImpl<char> &newStorage);
+
+  PathPrefixIterator<AbsolutePathRef> prefixesBegin() const {
+    return PathPrefixIterator<AbsolutePathRef>{*this};
+  }
+  PathPrefixIterator<AbsolutePathRef> prefixesEnd() const {
+    return PathPrefixIterator<AbsolutePathRef>{std::nullopt};
+  }
+
+  // Generally this should be avoided in favor
+  std::optional<AbsolutePathRef> prefix() const;
 };
 
 /// Typically used when referring to paths for files which may or may not
@@ -174,4 +218,4 @@ class RootPath final {
 
 } // namespace scip_clang
 
-#endif // SCIP_CLANG_PATH_H
+#endif // SCIP_CLANG_PATH_H

test/test_main.cc

@@ -107,6 +107,50 @@ TEST_CASE("UNIT_TESTS") {
                                 shouldntMatch));
     }
   }
+
+  {
+    struct PathNormalizationTestCase {
+      std::string path;
+      bool isNormalized;
+    };
+    std::vector<PathNormalizationTestCase> testCases{
+        {"/a/b/c", true},
+        {"/a/./c", false},
+        {"/a/../b", false},
+        {"/a///b", false},
+    };
+    for (auto &testCase : testCases) {
+      auto path = AbsolutePath(std::string(testCase.path));
+      CHECK_MESSAGE(path.asRef().isNormalized() == testCase.isNormalized,
+                    fmt::format("expected {} to be {}normalized", testCase.path,
+                                testCase.isNormalized ? "" : "non-"));
+    }
+  }
+
+  {
+    struct PathPrefixesTestCase {
+      std::string path;
+      std::vector<std::string> prefixes;
+    };
+    std::vector<PathPrefixesTestCase> testCases{
+        {"/a/b", {"/", "/a", "/a/b"}},
+    };
+    for (auto &testCase : testCases) {
+      auto &expectedPrefixes = testCase.prefixes;
+      auto path = AbsolutePath(std::string(testCase.path));
+      auto start = path.asRef().prefixesBegin();
+      auto end = path.asRef().prefixesEnd();
+      std::vector<std::string> gotPrefixes;
+      for (auto it = start; it != end; ++it) {
+        gotPrefixes.push_back(std::string((*it).asStringView()));
+      }
+      absl::c_reverse(gotPrefixes);
+      CHECK_MESSAGE(absl::c_equal(expectedPrefixes, gotPrefixes),
+                    fmt::format("expected prefixes: {}\n  actual prefixes: {}",
+                                fmt::join(expectedPrefixes, ", "),
+                                fmt::join(gotPrefixes, ", ")));
+    }
+  }
 };
 
 TEST_CASE("COMPDB_PARSING") {