[clangd] Bump timeouts for LSPServerTests

[kadircet]

Summary

We seem to be hitting limits in some windows build bots, see
https://github.com/clangd/clangd/issues/1712#issuecomment-1686478931.

So bumping the timeouts to 60 seconds and completely dropping them for sync
requests. As mentioned in the comment above, this should improve things,
considering even the tests that don't touch any complicated scheduler is
failing.

[sammccall]

clang-tools-extra/clangd/unittests/LSPClient.cpp

27

I think we're better of just increasing the number, unless there's some reason to think that different timeouts are appropriate for different tests.

218

Unless this is actually broken, it doesn't seem worth adding complexity for, though.

[kadircet]

• Just bump the timeouts

[sammccall]

clang-tools-extra/clangd/unittests/LSPClient.cpp

46

nit: 60 here too

clang-tools-extra/clangd/unittests/LSPClient.h

37–38

revert comment?

clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp

 //===-- ClangdLSPServerTests.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Annotations.h"
 #include "ClangdLSPServer.h"
+#include "ClangdServer.h"
+#include "ConfigProvider.h"
+#include "Diagnostics.h"
+#include "FeatureModule.h"
+#include "LSPBinder.h"
 #include "LSPClient.h"
-#include "Protocol.h"
 #include "TestFS.h"
+#include "support/Function.h"
 #include "support/Logger.h"
 #include "support/TestTracer.h"
+#include "support/Threading.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/LLVM.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JSON.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Testing/Support/Error.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include <cassert>
+#include <condition_variable>
+#include <cstddef>
+#include <deque>
+#include <memory>
+#include <mutex>
 #include <optional>
+#include <thread>
+#include <utility>
 
 namespace clang {
 namespace clangd {
 namespace {
 using llvm::Succeeded;
 using testing::ElementsAre;
 
 MATCHER_P(diagMessage, M, "") {
TEST_F(LSPTest, FeatureModulesThreadingTest) {
   };
 
   FeatureModules.add(std::make_unique<AsyncCounter>());
   auto &Client = start();
 
   Client.notify("increment", nullptr);
   Client.notify("increment", nullptr);
   Client.notify("increment", nullptr);
-  EXPECT_THAT_EXPECTED(Client.call("sync", nullptr).take(), Succeeded());
+  Client.sync();
   EXPECT_EQ(3, FeatureModules.get<AsyncCounter>()->getSync());
   // Throw some work on the queue to make sure shutdown blocks on it.
   Client.notify("increment", nullptr);
   Client.notify("increment", nullptr);
   Client.notify("increment", nullptr);
   // And immediately shut down. FeatureModule destructor verifies we blocked.
 }
 

clang-tools-extra/clangd/unittests/LSPClient.h

 //===-- LSPClient.h - Helper for ClangdLSPServer tests ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_LSPCLIENT_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_LSPCLIENT_H
 
+#include "llvm/ADT/StringRef.h"
+#include <condition_variable>
 #include <llvm/Support/Error.h>
 #include <llvm/Support/JSON.h>
-#include <condition_variable>
-#include <deque>
+#include <memory>
 #include <mutex>
 #include <optional>
+#include <vector>
 
 namespace clang {
 namespace clangd {
 class Transport;
 
 // A client library for talking to ClangdLSPServer in tests.
 // Manages serialization of messages, pairing requests/repsonses, and implements
 // the Transport abstraction.
 class LSPClient {
   class TransportImpl;
   std::unique_ptr<TransportImpl> T;
 
 public:
   // Represents the result of an LSP call: a promise for a result or error.
   class CallResult {
   public:
     ~CallResult();
-    // Blocks up to 10 seconds for the result to be ready.
+    // Blocks up to \p TimeoutSeconds seconds for the result to be ready. If \p
+    // TimeoutSeconds is zero, blocks indefinitely.
     // Records a test failure if there was no reply.
-    llvm::Expected<llvm::json::Value> take();
+    llvm::Expected<llvm::json::Value> take(float TimeoutSeconds = 60);
     // Like take(), but records a test failure if the result was an error.
-    llvm::json::Value takeValue();
+    llvm::json::Value takeValue(float TimeoutSeconds = 60);
 
   private:
     // Should be called once to provide the value.
     void set(llvm::Expected<llvm::json::Value> V);
 
     std::optional<llvm::Expected<llvm::json::Value>> Value;
     std::mutex Mu;
     std::condition_variable CV;

clang-tools-extra/clangd/unittests/LSPClient.cpp

 //===-- LSPClient.cpp - Helper for ClangdLSPServer tests ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "LSPClient.h"
 #include "Protocol.h"
 #include "TestFS.h"
 #include "Transport.h"
 #include "support/Logger.h"
 #include "support/Threading.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 #include <condition_variable>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <memory>
+#include <mutex>
 #include <optional>
 #include <queue>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace clang {
 namespace clangd {
 
-llvm::Expected<llvm::json::Value> clang::clangd::LSPClient::CallResult::take() {
+llvm::Expected<llvm::json::Value>
+clang::clangd::LSPClient::CallResult::take(float TimeoutSeconds) {
   std::unique_lock<std::mutex> Lock(Mu);
-  if (!clangd::wait(Lock, CV, timeoutSeconds(10),
+  if (!clangd::wait(Lock, CV,
+                    timeoutSeconds(TimeoutSeconds
+                                       ? std::optional<float>(TimeoutSeconds)
+                                       : std::nullopt),
                     [this] { return Value.has_value(); })) {
     ADD_FAILURE() << "No result from call after 10 seconds!";
     return llvm::json::Value(nullptr);
   }
   auto Res = std::move(*Value);
   Value.reset();
   return Res;
 }
 
-llvm::json::Value LSPClient::CallResult::takeValue() {
-  auto ExpValue = take();
+llvm::json::Value LSPClient::CallResult::takeValue(float TimeoutSeconds) {
+  auto ExpValue = take(TimeoutSeconds);
   if (!ExpValue) {
     ADD_FAILURE() << "takeValue(): " << llvm::toString(ExpValue.takeError());
     return llvm::json::Value(nullptr);
   }
   return std::move(*ExpValue);
 }
 
 void LSPClient::CallResult::set(llvm::Expected<llvm::json::Value> V) {
void LSPClient::didChange(llvm::StringRef Path, llvm::StringRef Content) {
   notify("textDocument/didChange",
          Obj{{"textDocument", documentID(Path)},
              {"contentChanges", llvm::json::Array{Obj{{"text", Content}}}}});
 }
 void LSPClient::didClose(llvm::StringRef Path) {
   notify("textDocument/didClose", Obj{{"textDocument", documentID(Path)}});
 }
 
-void LSPClient::sync() { call("sync", nullptr).takeValue(); }
+void LSPClient::sync() {
+  // Sync should already be implemented with a timeout, so don't timeout.
+  call("sync", nullptr).takeValue(0);
+}
 
 std::optional<std::vector<llvm::json::Value>>
 LSPClient::diagnostics(llvm::StringRef Path) {
   sync();
   auto Notifications = takeNotifications("textDocument/publishDiagnostics");
   for (const auto &Notification : llvm::reverse(Notifications)) {
     if (const auto *PubDiagsParams = Notification.getAsObject()) {
       auto U = PubDiagsParams->getString("uri");