[circt-lsp-server] Make time source injectable

Introduce an injectable clock and test-only wait shim to remove real sleeps
from `PendingChanges` logic in tests, while preserving production behavior.

- Add an **injectable time source**:
  - `using SteadyClock = std::chrono::steady_clock;`
  - `using NowFn = std::function<SteadyClock::time_point()>;`
  - Store `NowFn nowFn` and a `bool useManualClock` in `PendingChangesMap`.
- Replace direct calls to `std::chrono::steady_clock::now()` with `nowFn()`.
- Add `waitForMinMs(uint64_t ms, SteadyClock::time_point start)`:
  - **Prod path**: `std::this_thread::sleep_for(ms)`.
  - **Test path** (`useManualClock`): busy-wait with `std::this_thread::yield()` until `nowFn()` reaches target.
- New ctor overload for tests:
  - `PendingChangesMap(unsigned maxThreads, NowFn now)` -> enables manual clock mode.
- Dtor now calls `abort()` to ensure all pending work is cleared on teardown.
- Replace sleep in debounce worker:
  - `sleep_for(ms)` -> `waitForMinMs(ms, scheduleTime)`.

- Add `ManualClock` with manual advancement (`advanceMs`) and `now()` accessor.
- Utility `advanceTestTime(clock, ms)` that advances test time and yields.
- `CallbackCapture::waitFor()` now uses a tight fixed 100ms window (no per-call timeout arg).
- Refactor tests to:
  - Construct `PendingChangesMap` with manual clock (`PendingChangesMap(2, [&]{ return clock.now(); })`).
  - Advance time deterministically instead of sleeping.
  - Validate debounce min/obsolete/max-cap behaviors without flakiness.
- Adjust debounce cap in `MaxCapForcesFlushDuringContinuousTyping` to 1ms to tighten assertions.
- Sprinkle end-of-test large time advances to flush any queued workers.

Author: Moritz Scherer

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

@@ -48,9 +48,7 @@ void PendingChangesMap::debounceAndUpdate(
 
 void PendingChangesMap::enqueueChange(
     const llvm::lsp::DidChangeTextDocumentParams &params) {
-  // 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 auto now = nowFn();
   const std::string key = params.textDocument.uri.file().str();
 
   std::scoped_lock lock(mu);
@@ -71,7 +69,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 = std::chrono::steady_clock::now();
+  const auto scheduleTime = nowFn();
 
   // If debounce is disabled, run on main thread
   if (options.disableDebounce) {
@@ -87,8 +85,7 @@ 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)
-      std::this_thread::sleep_for(
-          std::chrono::milliseconds(options.debounceMinMs));
+      waitForMinMs(options.debounceMinMs, scheduleTime);
 
     std::unique_ptr<PendingChanges>
         result; // decided under lock, callback after
@@ -98,7 +95,7 @@ void PendingChangesMap::debounceAndThen(
       auto it = pending.find(key);
       if (it != pending.end()) {
         PendingChanges &pc = it->second;
-        const auto now = std::chrono::steady_clock::now();
+        const auto now = nowFn();
 
         // quietSinceSchedule: if no newer edits arrived after we scheduled
         // this task, then we consider the burst "quiet" and flush now.
@@ -142,5 +139,20 @@ 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,13 +17,17 @@
 
 #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();
@@ -56,7 +60,16 @@ class PendingChangesMap {
 public:
   explicit PendingChangesMap(
       unsigned maxThreads = std::thread::hardware_concurrency())
-      : pool(makeStrategy(maxThreads)), tasks(pool) {}
+      : 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(); }
 
   /// Call during server shutdown; Erase all file changes, then clear file map.
   /// Thread-safe.
@@ -106,6 +119,13 @@ 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