Revert "[circt-lsp-server] Make time source injectable"

This reverts commit 7eb08b1.

Author: Moritz Scherer

lib/Tools/circt-verilog-lsp-server/Utils/PendingChanges.cpp

@@ -48,7 +48,9 @@ void PendingChangesMap::debounceAndUpdate(
 
 void PendingChangesMap::enqueueChange(
     const llvm::lsp::DidChangeTextDocumentParams &params) {
-  const auto now = nowFn();
+  // Key by normalized LSP file path. If your pipeline allows multiple
+  // spellings (symlinks/case), normalize upstream or canonicalize here.
+  const auto now = std::chrono::steady_clock::now();
   const std::string key = params.textDocument.uri.file().str();
 
   std::scoped_lock lock(mu);
@@ -69,7 +71,7 @@ void PendingChangesMap::debounceAndThen(
     DebounceOptions options,
     std::function<void(std::unique_ptr<PendingChanges>)> cb) {
   const std::string key = params.textDocument.uri.file().str();
-  const auto scheduleTime = nowFn();
+  const auto scheduleTime = std::chrono::steady_clock::now();
 
   // If debounce is disabled, run on main thread
   if (options.disableDebounce) {
@@ -85,7 +87,8 @@ void PendingChangesMap::debounceAndThen(
     // Simple timer: sleep min-quiet before checking. We rely on the fact
     // that newer edits can arrive while we sleep, updating lastChangeTime.
     if (options.debounceMinMs > 0)
-      waitForMinMs(options.debounceMinMs, scheduleTime);
+      std::this_thread::sleep_for(
+          std::chrono::milliseconds(options.debounceMinMs));
 
     std::unique_ptr<PendingChanges>
         result; // decided under lock, callback after
@@ -95,7 +98,7 @@ void PendingChangesMap::debounceAndThen(
       auto it = pending.find(key);
       if (it != pending.end()) {
         PendingChanges &pc = it->second;
-        const auto now = nowFn();
+        const auto now = std::chrono::steady_clock::now();
 
         // quietSinceSchedule: if no newer edits arrived after we scheduled
         // this task, then we consider the burst "quiet" and flush now.
@@ -139,20 +142,5 @@ PendingChangesMap::takeAndErase(llvm::StringMap<PendingChanges>::iterator it) {
   return out;
 }
 
-void PendingChangesMap::waitForMinMs(uint64_t ms,
-                                     SteadyClock::time_point start) {
-  if (!ms)
-    return;
-  if (!useManualClock) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
-    return;
-  }
-  // Manual clock: busy-wait with yields until now() reaches start + ms.
-  const auto target = start + std::chrono::milliseconds(ms);
-  while (nowFn() < target) {
-    std::this_thread::yield();
-  }
-}
-
 } // namespace lsp
 } // namespace circt

lib/Tools/circt-verilog-lsp-server/Utils/PendingChanges.h

@@ -17,17 +17,13 @@
 
 #include <chrono>
 #include <cstdint>
-#include <functional>
 #include <mutex>
 #include <thread>
 #include <vector>
 
 namespace circt {
 namespace lsp {
 
-using SteadyClock = std::chrono::steady_clock;
-using NowFn = std::function<SteadyClock::time_point()>;
-
 /// Build a pool strategy with a sensible minimum.
 static llvm::ThreadPoolStrategy makeStrategy(unsigned maxThreads) {
   llvm::ThreadPoolStrategy s = llvm::hardware_concurrency();
@@ -60,16 +56,7 @@ class PendingChangesMap {
 public:
   explicit PendingChangesMap(
       unsigned maxThreads = std::thread::hardware_concurrency())
-      : pool(makeStrategy(maxThreads)), tasks(pool),
-        nowFn([] { return SteadyClock::now(); }), useManualClock(false) {}
-
-  // Test-only path: provide a manual clock source.
-  explicit PendingChangesMap(unsigned maxThreads, NowFn now)
-      : pool(makeStrategy(maxThreads)), tasks(pool), nowFn(std::move(now)),
-        useManualClock(true) {}
-
-  /// Destructor ensures all pending work is cleared.
-  ~PendingChangesMap() { abort(); }
+      : pool(makeStrategy(maxThreads)), tasks(pool) {}
 
   /// Call during server shutdown; Erase all file changes, then clear file map.
   /// Thread-safe.
@@ -119,13 +106,6 @@ class PendingChangesMap {
   /// Internal concurrency used for sleeps + checks.
   llvm::StdThreadPool pool;
   llvm::ThreadPoolTaskGroup tasks;
-
-  /// Injectable time source for unit testing
-  NowFn nowFn;
-  bool useManualClock;
-
-  /// Test wrapper around a thread timeout
-  void waitForMinMs(uint64_t ms, SteadyClock::time_point start);
 };
 
 } // namespace lsp