[NFC] Use LLVM naming conventions within FileDistance

[sammccall]

clang-tools-extra/clangd/FileDistance.cpp

56 ↗

(On Diff #163468)

I think this is required - are you sure it's never ODR-used?
(Even if not, it's public, so it's not really possible to guarantee that)

clangd/FileDistance.h

struct SourceParams {
   // Limits the number of upwards traversals allowed from this source.
   unsigned MaxUpTraversals = std::numeric_limits<unsigned>::max();
 };
 
 // Supports lookups to find the minimum distance to a file from any source.
 // This object should be reused, it memoizes intermediate computations.
 class FileDistance {
 public:
-  static constexpr unsigned kUnreachable = std::numeric_limits<unsigned>::max();
+  static constexpr unsigned Unreachable = std::numeric_limits<unsigned>::max();
 
   FileDistance(llvm::StringMap<SourceParams> Sources,
                const FileDistanceOptions &Opts = {});
 
   // Computes the minimum distance from any source to the file path.
   unsigned distance(llvm::StringRef Path);
 
 private:

clangd/FileDistance.cpp

FileDistance::FileDistance(StringMap<SourceParams> Sources,
   // BFS ensures we propagate down chains (must visit parents before children).
   std::queue<hash_code> Next;
   for (auto Child : DownEdges.lookup(hash_value(llvm::StringRef(""))))
     Next.push(Child);
   while (!Next.empty()) {
     auto ParentCost = Cache.lookup(Next.front());
     for (auto Child : DownEdges.lookup(Next.front())) {
       auto &ChildCost =
-          Cache.try_emplace(Child, kUnreachable).first->getSecond();
+          Cache.try_emplace(Child, Unreachable).first->getSecond();
       if (ParentCost + Opts.DownCost < ChildCost)
         ChildCost = ParentCost + Opts.DownCost;
       Next.push(Child);
     }
     Next.pop();
   }
 }
 
 unsigned FileDistance::distance(StringRef Path) {
   auto Canonical = canonicalize(Path);
-  unsigned Cost = kUnreachable;
+  unsigned Cost = Unreachable;
   SmallVector<hash_code, 16> Ancestors;
   // Walk up ancestors until we find a path we know the distance for.
   for (StringRef Rest = Canonical; !Rest.empty();
        Rest = parent_path(Rest, sys::path::Style::posix)) {
     auto Hash = hash_value(Rest);
     auto It = Cache.find(Hash);
     if (It != Cache.end()) {
       Cost = It->second;
       break;
     }
     Ancestors.push_back(Hash);
   }
   // Now we know the costs for (known node, queried node].
   // Fill these in, walking down the directory tree.
   for (hash_code Hash : reverse(Ancestors)) {
-    if (Cost != kUnreachable)
+    if (Cost != Unreachable)
       Cost += Opts.DownCost;
     Cache.try_emplace(Hash, Cost);
   }
   dlog("distance({0} = {1})", Path, Cost);
   return Cost;
 }
 
 unsigned URIDistance::distance(llvm::StringRef URI) {
-  auto R = Cache.try_emplace(llvm::hash_value(URI), FileDistance::kUnreachable);
+  auto R = Cache.try_emplace(llvm::hash_value(URI), FileDistance::Unreachable);
   if (!R.second)
     return R.first->getSecond();
   if (auto U = clangd::URI::parse(URI)) {
     dlog("distance({0} = {1})", URI, U->body());
     R.first->second = forScheme(U->scheme()).distance(U->body());
   } else {
     log("URIDistance::distance() of unparseable {0}: {1}", URI, U.takeError());
   }