[clangd] Add platform triple (host & target) to version info

[sammccall]

Summary

Useful in logs to understand issues around some platforms we don't have much
experience with (e.g. m1, mingw)

[kadircet]

thanks! only printing the target when they differ makes a lot of sense! LGTM

clang-tools-extra/clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   for (llvm::StringRef Command : Handlers.CommandHandlers.keys())
     Commands.push_back(Command);
   llvm::sort(Commands);
   ServerCaps["executeCommandProvider"] =
       llvm::json::Object{{"commands", Commands}};
 
   llvm::json::Object Result{
       {{"serverInfo",
-        llvm::json::Object{{"name", "clangd"},
-                           {"version", llvm::formatv("{0} {1}", versionString(),
-                                                     featureString())}}},
+        llvm::json::Object{
+            {"name", "clangd"},
+            {"version", llvm::formatv("{0} {1} {2}", versionString(),
+                                      featureString(), platformString())}}},
        {"capabilities", std::move(ServerCaps)}}};
   if (Opts.Encoding)
     Result["offsetEncoding"] = *Opts.Encoding;
   Reply(std::move(Result));
 }
 
 void ClangdLSPServer::onInitialized(const InitializedParams &Params) {}
 

clang-tools-extra/clangd/Features.h

 #include "Features.inc"
 
 namespace clang {
 namespace clangd {
 
 // Returns a version string for clangd, e.g. "clangd 10.0.0"
 std::string versionString();
 
+// Returns the platform triple for clangd, e.g. "x86_64-pc-linux-gnu"
+// May include both the host and target triple if they differ.
+std::string platformString();
+
 // Returns a string describing the compile-time configuration.
 // e.g. mac+debug+asan+grpc
 std::string featureString();
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/Features.cpp

 //===--- Features.cpp - Compile-time configuration ------------------------===//
 //
 // 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 "Features.h"
 #include "clang/Basic/Version.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Host.h"
 
 namespace clang {
 namespace clangd {
 
 std::string versionString() { return clang::getClangToolFullVersion("clangd"); }
 
+std::string platformString() {
+  static std::string PlatformString = []() {
+    std::string Host = llvm::sys::getProcessTriple();
+    std::string Target = llvm::sys::getDefaultTargetTriple();
+    if (Host != Target) {
+      Host += "; target=";
+      Host += Target;
+    }
+    return Host;
+  }();
+  return PlatformString;
+}
+
 std::string featureString() {
   return
 #if defined(_WIN32)
       "windows"
 #elif defined(__APPLE__)
       "mac"
 #elif defined(__linux__)
       "linux"

clang-tools-extra/clangd/index/remote/Client.cpp

bool streamRPC(ClangdRequestT Request,
     // stream, but we couldn't get to them.
     bool HasMore = true;
     trace::Span Tracer(RequestT::descriptor()->name());
     const auto RPCRequest = ProtobufMarshaller->toProtobuf(Request);
     SPAN_ATTACH(Tracer, "Request", RPCRequest.DebugString());
     grpc::ClientContext Context;
     Context.AddMetadata("version", versionString());
     Context.AddMetadata("features", featureString());
+    Context.AddMetadata("platform", platformString());
     std::chrono::system_clock::time_point StartTime =
         std::chrono::system_clock::now();
     auto Deadline = StartTime + DeadlineWaitingTime;
     Context.set_deadline(Deadline);
     auto Reader = (Stub.get()->*RPCCall)(&Context, RPCRequest);
     dlog("Sending {0}: {1}", RequestT::descriptor()->name(),
          RPCRequest.DebugString());
     ReplyT Reply;

clang-tools-extra/clangd/tool/ClangdMain.cpp

int main(int argc, char *argv[]) {
   using namespace clang;
   using namespace clang::clangd;
 
   llvm::InitializeAllTargetInfos();
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
   llvm::sys::SetInterruptFunction(&requestShutdown);
   llvm::cl::SetVersionPrinter([](llvm::raw_ostream &OS) {
     OS << versionString() << "\n"
-       << "Features: " << featureString() << "\n";
+       << "Features: " << featureString() << "\n"
+       << "Platform: " << platformString() << "\n";
   });
   const char *FlagsEnvVar = "CLANGD_FLAGS";
   const char *Overview =
       R"(clangd is a language server that provides IDE-like features to editors.
 
 It should be used via an editor plugin rather than invoked directly. For more information, see:
   https://clangd.llvm.org/
   https://microsoft.github.io/language-server-protocol/