[clangd] Support offsets for parameters in signatureHelp

[ilya-biryukov]

Summary

Added to LSP in version 3.14

[ilya-biryukov]

• Fix compilation when assertions are enabled

[ilya-biryukov]

• Fix parsing of a client capability, add a test for a capability

[hokein]

nice, looks good

[uabelho]

clang-tools-extra/trunk/clangd/CodeComplete.cpp

925 ↗

(On Diff #202884)

Hi!

gcc (7.4) warns on this code:

error: parameter 'Signal' set but not used [-Werror=unused-but-set-parameter]
                              SignatureQualitySignals Signal) const {
                                                      ^~~~~~

Should Signal be a reference? Or is it specifically not a reference right now due to the FIXME?

[ilya-biryukov]

clang-tools-extra/trunk/clangd/CodeComplete.cpp

925 ↗

(On Diff #202884)

Should be a reference, thanks for bringing that up! I'll send a fix.

[ilya-biryukov]

clang-tools-extra/trunk/clangd/CodeComplete.cpp

925 ↗

(On Diff #202884)

Removed this flag altogether in r362686, it is not used and has we have no tests for it.

[uabelho]

clang-tools-extra/trunk/clangd/CodeComplete.cpp

925 ↗

(On Diff #202884)

Thanks!

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   /// The supported completion item kinds of the client.
   CompletionItemKindBitset SupportedCompletionItemKinds;
   /// Whether the client supports CodeAction response objects.
   bool SupportsCodeAction = false;
   /// From capabilities of textDocument/documentSymbol.
   bool SupportsHierarchicalDocumentSymbol = false;
   /// Whether the client supports showing file status.
   bool SupportFileStatus = false;
+  /// Whether the client supports offsets for parameter info labels.
+  bool SupportsOffsetsInSignatureHelp = false;
   // Store of the current versions of the open documents.
   DraftStore DraftMgr;
 
   // The CDB is created by the "initialize" LSP method.
   bool UseDirBasedCDB;                     // FIXME: make this a capability.
   llvm::Optional<Path> CompileCommandsDir; // FIXME: merge with capability?
   std::unique_ptr<GlobalCompilationDatabase> BaseCDB;
   // CDB is BaseCDB plus any comands overridden via LSP extensions.

clang-tools-extra/clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   if (Params.capabilities.WorkspaceSymbolKinds)
     SupportedSymbolKinds |= *Params.capabilities.WorkspaceSymbolKinds;
   if (Params.capabilities.CompletionItemKinds)
     SupportedCompletionItemKinds |= *Params.capabilities.CompletionItemKinds;
   SupportsCodeAction = Params.capabilities.CodeActionStructure;
   SupportsHierarchicalDocumentSymbol =
       Params.capabilities.HierarchicalDocumentSymbol;
   SupportFileStatus = Params.initializationOptions.FileStatus;
+  SupportsOffsetsInSignatureHelp = Params.capabilities.OffsetsInSignatureHelp;
   llvm::json::Object Result{
       {{"capabilities",
         llvm::json::Object{
             {"textDocumentSync", (int)TextDocumentSyncKind::Incremental},
             {"documentFormattingProvider", true},
             {"documentRangeFormattingProvider", true},
             {"documentOnTypeFormattingProvider",
              llvm::json::Object{
Server->codeComplete(Params.textDocument.uri.file(), Params.position, CCOpts,
                              return Reply(std::move(LSPList));
                            },
                            std::move(Reply)));
 }
 
 void ClangdLSPServer::onSignatureHelp(const TextDocumentPositionParams &Params,
                                       Callback<SignatureHelp> Reply) {
   Server->signatureHelp(Params.textDocument.uri.file(), Params.position,
-                        std::move(Reply));
+                        Bind(
+                            [this](decltype(Reply) Reply,
+                                   llvm::Expected<SignatureHelp> Signature) {
+                              if (!Signature)
+                                return Reply(Signature.takeError());
+                              if (SupportsOffsetsInSignatureHelp)
+                                return Reply(std::move(*Signature));
+                              // Strip out the offsets from signature help for
+                              // clients that only support string labels.
+                              for (auto &Signature : Signature->signatures) {
+                                for (auto &Param : Signature.parameters)
+                                  Param.labelOffsets.reset();
+                              }
+                              return Reply(std::move(*Signature));
+                            },
+                            std::move(Reply)));
 }
 
 // Go to definition has a toggle function: if def and decl are distinct, then
 // the first press gives you the def, the second gives you the matching def.
 // getToggle() returns the counterpart location that under the cursor.
 //
 // We return the toggled location alone (ignoring other symbols) to encourage
 // editors to "bounce" quickly between locations, without showing a menu.

clang-tools-extra/clangd/CodeComplete.cpp

 #include "CodeCompletionStrings.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
 #include "ExpectedTypes.h"
 #include "FileDistance.h"
 #include "FuzzyMatch.h"
 #include "Headers.h"
 #include "Logger.h"
+#include "Protocol.h"
 #include "Quality.h"
 #include "SourceCode.h"
 #include "TUScheduler.h"
 #include "Trace.h"
 #include "URI.h"
 #include "index/Index.h"
 #include "index/Symbol.h"
 #include "index/SymbolOrigin.h"

 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <algorithm>
 #include <iterator>
 
case CodeCompletionResult::RK_Macro:
     return CompletionItemKind::Text; // unfortunately, there's no 'Macro'
                                      // completion items in LSP.
   case CodeCompletionResult::RK_Pattern:
     return CompletionItemKind::Snippet;
   }
   llvm_unreachable("Unhandled CodeCompletionResult::ResultKind.");
 }
 
-/// Get the optional chunk as a string. This function is possibly recursive.
-///
-/// The parameter info for each parameter is appended to the Parameters.
-std::string getOptionalParameters(const CodeCompletionString &CCS,
-                                  std::vector<ParameterInformation> &Parameters,
-                                  SignatureQualitySignals &Signal) {
-  std::string Result;
-  for (const auto &Chunk : CCS) {
-    switch (Chunk.Kind) {
-    case CodeCompletionString::CK_Optional:
-      assert(Chunk.Optional &&
-             "Expected the optional code completion string to be non-null.");
-      Result += getOptionalParameters(*Chunk.Optional, Parameters, Signal);
-      break;
-    case CodeCompletionString::CK_VerticalSpace:
-      break;
-    case CodeCompletionString::CK_Placeholder:
-      // A string that acts as a placeholder for, e.g., a function call
-      // argument.
-      // Intentional fallthrough here.
-    case CodeCompletionString::CK_CurrentParameter: {
-      // A piece of text that describes the parameter that corresponds to
-      // the code-completion location within a function call, message send,
-      // macro invocation, etc.
-      Result += Chunk.Text;
-      ParameterInformation Info;
-      Info.label = Chunk.Text;
-      Parameters.push_back(std::move(Info));
-      Signal.ContainsActiveParameter = true;
-      Signal.NumberOfOptionalParameters++;
-      break;
-    }
-    default:
-      Result += Chunk.Text;
-      break;
-    }
-  }
-  return Result;
-}
-
 // Identifier code completion result.
 struct RawIdentifier {
   llvm::StringRef Name;
   unsigned References; // # of usages in file.
 };
 
 /// A code completion result, in clang-native form.
 /// It may be promoted to a CompletionItem if it's among the top-ranked results.
struct ScoredSignature {
   SignatureInformation Signature;
   SignatureQualitySignals Quality;
 };
 
 class SignatureHelpCollector final : public CodeCompleteConsumer {
 public:
   SignatureHelpCollector(const clang::CodeCompleteOptions &CodeCompleteOpts,
                          const SymbolIndex *Index, SignatureHelp &SigHelp)
-      : CodeCompleteConsumer(CodeCompleteOpts),
-        SigHelp(SigHelp),
+      : CodeCompleteConsumer(CodeCompleteOpts), SigHelp(SigHelp),
         Allocator(std::make_shared<clang::GlobalCodeCompletionAllocator>()),
         CCTUInfo(Allocator), Index(Index) {}
 
   void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
                                  OverloadCandidate *Candidates,
                                  unsigned NumCandidates,
                                  SourceLocation OpenParLoc) override {
     assert(!OpenParLoc.isInvalid());
void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
     }
   }
 
   GlobalCodeCompletionAllocator &getAllocator() override { return *Allocator; }
 
   CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
 
 private:
+  void processParameterChunk(llvm::StringRef ChunkText,
+                             SignatureInformation &Signature,
+                             SignatureQualitySignals Signal) const {
+    // (!) this is O(n), should still be fast compared to building ASTs.
+    unsigned ParamStartOffset = lspLength(Signature.label);
+    unsigned ParamEndOffset = ParamStartOffset + lspLength(ChunkText);
+    // A piece of text that describes the parameter that corresponds to
+    // the code-completion location within a function call, message send,
+    // macro invocation, etc.
+    Signature.label += ChunkText;
+    ParameterInformation Info;
+    Info.labelOffsets.emplace(ParamStartOffset, ParamEndOffset);
+    // FIXME: only set 'labelOffsets' when all clients migrate out of it.
+    Info.labelString = ChunkText;
+
+    Signature.parameters.push_back(std::move(Info));
+    // FIXME: this should only be set on CK_CurrentParameter.
+    Signal.ContainsActiveParameter = true;
+  }
+
+  void processOptionalChunk(const CodeCompletionString &CCS,
+                            SignatureInformation &Signature,
+                            SignatureQualitySignals &Signal) const {
+    for (const auto &Chunk : CCS) {
+      switch (Chunk.Kind) {
+      case CodeCompletionString::CK_Optional:
+        assert(Chunk.Optional &&
+               "Expected the optional code completion string to be non-null.");
+        processOptionalChunk(*Chunk.Optional, Signature, Signal);
+        break;
+      case CodeCompletionString::CK_VerticalSpace:
+        break;
+      case CodeCompletionString::CK_CurrentParameter:
+      case CodeCompletionString::CK_Placeholder:
+        processParameterChunk(Chunk.Text, Signature, Signal);
+        Signal.NumberOfOptionalParameters++;
+        break;
+      default:
+        Signature.label += Chunk.Text;
+        break;
+      }
+    }
+  }
+
   // FIXME(ioeric): consider moving CodeCompletionString logic here to
   // CompletionString.h.
   ScoredSignature processOverloadCandidate(const OverloadCandidate &Candidate,
                                            const CodeCompletionString &CCS,
                                            llvm::StringRef DocComment) const {
     SignatureInformation Signature;
     SignatureQualitySignals Signal;
     const char *ReturnType = nullptr;
 
     Signature.documentation = formatDocumentation(CCS, DocComment);
     Signal.Kind = Candidate.getKind();
 
     for (const auto &Chunk : CCS) {
       switch (Chunk.Kind) {
       case CodeCompletionString::CK_ResultType:
         // A piece of text that describes the type of an entity or,
         // for functions and methods, the return type.
         assert(!ReturnType && "Unexpected CK_ResultType");
         ReturnType = Chunk.Text;
         break;
+      case CodeCompletionString::CK_CurrentParameter:
       case CodeCompletionString::CK_Placeholder:
-        // A string that acts as a placeholder for, e.g., a function call
-        // argument.
-        // Intentional fallthrough here.
-      case CodeCompletionString::CK_CurrentParameter: {
-        // A piece of text that describes the parameter that corresponds to
-        // the code-completion location within a function call, message send,
-        // macro invocation, etc.
-        Signature.label += Chunk.Text;
-        ParameterInformation Info;
-        Info.label = Chunk.Text;
-        Signature.parameters.push_back(std::move(Info));
+        processParameterChunk(Chunk.Text, Signature, Signal);
         Signal.NumberOfParameters++;
-        Signal.ContainsActiveParameter = true;
         break;
-      }
       case CodeCompletionString::CK_Optional: {
         // The rest of the parameters are defaulted/optional.
         assert(Chunk.Optional &&
                "Expected the optional code completion string to be non-null.");
-        Signature.label += getOptionalParameters(*Chunk.Optional,
-                                                 Signature.parameters, Signal);
+        processOptionalChunk(*Chunk.Optional, Signature, Signal);
         break;
       }
       case CodeCompletionString::CK_VerticalSpace:
         break;
       default:
         Signature.label += Chunk.Text;
         break;
       }
void loadMainFilePreambleMacros(const Preprocessor &PP,
   // but this includes transitively included files, so may deserialize a lot.
   ExternalPreprocessorSource *PreambleMacros = PP.getExternalSource();
   // As we have the names of the macros, we can look up their IdentifierInfo
   // and then use this to load just the macros we want.
   IdentifierInfoLookup *PreambleIdentifiers =
       PP.getIdentifierTable().getExternalIdentifierLookup();
   if (!PreambleIdentifiers || !PreambleMacros)
     return;
-  for (const auto& MacroName : Preamble.MainFileMacros)
+  for (const auto &MacroName : Preamble.MainFileMacros)
     if (auto *II = PreambleIdentifiers->get(MacroName))
       if (II->isOutOfDate())
         PreambleMacros->updateOutOfDateIdentifier(*II);
 }
 
 // Invokes Sema code completion on a file.
 // If \p Includes is set, it will be updated based on the compiler invocation.
 bool semaCodeComplete(std::unique_ptr<CodeCompleteConsumer> Consumer,
class CodeCompleteFlow {
 
   // Sema takes ownership of Recorder. Recorder is valid until Sema cleanup.
   CompletionRecorder *Recorder = nullptr;
   CodeCompletionContext::Kind CCContextKind = CodeCompletionContext::CCC_Other;
   // Counters for logging.
   int NSema = 0, NIndex = 0, NSemaAndIndex = 0, NIdent = 0;
   bool Incomplete = false; // Would more be available with a higher limit?
   CompletionPrefix HeuristicPrefix;
-  llvm::Optional<FuzzyMatcher> Filter;  // Initialized once Sema runs.
+  llvm::Optional<FuzzyMatcher> Filter; // Initialized once Sema runs.
   Range ReplacedRange;
   std::vector<std::string> QueryScopes; // Initialized once Sema runs.
   // Initialized once QueryScopes is initialized, if there are scopes.
   llvm::Optional<ScopeDistance> ScopeProximity;
   llvm::Optional<OpaqueType> PreferredType; // Initialized once Sema runs.
   // Whether to query symbols from any scope. Initialized once Sema runs.
   bool AllScopes = false;
   llvm::StringSet<> ContextWords;
clang::CodeCompleteOptions CodeCompleteOptions::getClangCompleteOpts() const {
   // the index can provide results from the preamble.
   // Tell Sema not to deserialize the preamble to look for results.
   Result.LoadExternal = !Index;
   Result.IncludeFixIts = IncludeFixIts;
 
   return Result;
 }
 
-CompletionPrefix
-guessCompletionPrefix(llvm::StringRef Content, unsigned Offset) {
+CompletionPrefix guessCompletionPrefix(llvm::StringRef Content,
+                                       unsigned Offset) {
   assert(Offset <= Content.size());
   StringRef Rest = Content.take_front(Offset);
   CompletionPrefix Result;
 
   // Consume the unqualified name. We only handle ASCII characters.
   // isIdentifierBody will let us match "0invalid", but we don't mind.
   while (!Rest.empty() && isIdentifierBody(Rest.back()))
     Rest = Rest.drop_back();

clang-tools-extra/clangd/Protocol.h

struct ClientCapabilities {
 
   /// Client supports snippets as insert text.
   /// textDocument.completion.completionItem.snippetSupport
   bool CompletionSnippets = false;
 
   /// Client supports hierarchical document symbols.
   bool HierarchicalDocumentSymbol = false;
 
+  /// Client supports processing label offsets instead of a simple label string.
+  bool OffsetsInSignatureHelp = false;
+
   /// The supported set of CompletionItemKinds for textDocument/completion.
   /// textDocument.completion.completionItemKind.valueSet
   llvm::Optional<CompletionItemKindBitset> CompletionItemKinds;
 
   /// Client supports CodeAction return value for textDocument/codeAction.
   /// textDocument.codeAction.codeActionLiteralSupport.
   bool CodeActionStructure = false;
 
struct CompletionList {
   /// The completion items.
   std::vector<CompletionItem> items;
 };
 llvm::json::Value toJSON(const CompletionList &);
 
 /// A single parameter of a particular signature.
 struct ParameterInformation {
 
-  /// The label of this parameter. Mandatory.
-  std::string label;
+  /// The label of this parameter. Ignored when labelOffsets is set.
+  std::string labelString;
+
+  /// Inclusive start and exclusive end offsets withing the containing signature
+  /// label.
+  /// Offsets are computed by lspLength(), which counts UTF-16 code units by
+  /// default but that can be overriden, see its documentation for details.
+  llvm::Optional<std::pair<unsigned, unsigned>> labelOffsets;
 
   /// The documentation of this parameter. Optional.
   std::string documentation;
 };
 llvm::json::Value toJSON(const ParameterInformation &);
 
 /// Represents the signature of something callable.
 struct SignatureInformation {

clang-tools-extra/clangd/Protocol.cpp

if (auto *CodeAction = TextDocument->getObject("codeAction")) {
       if (CodeAction->getObject("codeActionLiteralSupport"))
         R.CodeActionStructure = true;
     }
     if (auto *DocumentSymbol = TextDocument->getObject("documentSymbol")) {
       if (auto HierarchicalSupport =
               DocumentSymbol->getBoolean("hierarchicalDocumentSymbolSupport"))
         R.HierarchicalDocumentSymbol = *HierarchicalSupport;
     }
+    if (auto *Help = TextDocument->getObject("signatureHelp")) {
+      if (auto *Info = Help->getObject("signatureInformation")) {
+        if (auto *Parameter = Info->getObject("parameterInformation")) {
+          if (auto OffsetSupport = Parameter->getBoolean("labelOffsetSupport"))
+            R.OffsetsInSignatureHelp = *OffsetSupport;
+        }
+      }
+    }
   }
   if (auto *Workspace = O->getObject("workspace")) {
     if (auto *Symbol = Workspace->getObject("symbol")) {
       if (auto *SymbolKind = Symbol->getObject("symbolKind")) {
         if (auto *ValueSet = SymbolKind->get("valueSet")) {
           R.WorkspaceSymbolKinds.emplace();
           if (!fromJSON(*ValueSet, *R.WorkspaceSymbolKinds))
             return false;

 llvm::json::Value toJSON(const CompletionList &L) {
   return llvm::json::Object{
       {"isIncomplete", L.isIncomplete},
       {"items", llvm::json::Array(L.items)},
   };
 }
 
 llvm::json::Value toJSON(const ParameterInformation &PI) {
-  assert(!PI.label.empty() && "parameter information label is required");
-  llvm::json::Object Result{{"label", PI.label}};
+  assert(PI.labelOffsets.hasValue() ||
+         !PI.labelString.empty() && "parameter information label is required");
+  llvm::json::Object Result;
+  if (PI.labelOffsets)
+    Result["label"] =
+        llvm::json::Array({PI.labelOffsets->first, PI.labelOffsets->second});
+  else
+    Result["label"] = PI.labelString;
   if (!PI.documentation.empty())
     Result["documentation"] = PI.documentation;
   return std::move(Result);
 }
 
 llvm::json::Value toJSON(const SignatureInformation &SI) {
   assert(!SI.label.empty() && "signature information label is required");
   llvm::json::Object Result{

clang-tools-extra/clangd/test/signature-help-with-offsets.test

+# RUN: clangd -lit-test < %s | FileCheck -strict-whitespace %s
+# Start a session.
+{
+  "jsonrpc": "2.0",
+  "id": 0,
+  "method": "initialize",
+  "params": {
+    "processId": 123,
+    "rootPath": "clangd",
+    "capabilities": {
+      "textDocument": {
+        "signatureHelp": {
+          "signatureInformation": {
+            "parameterInformation": {
+              "labelOffsetSupport": true
+            }
+          }
+        }
+      }
+    },
+    "trace": "off"
+  }
+}
+---
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"test:///main.cpp","languageId":"cpp","version":1,"text":"void x(int);\nint main(){\nx("}}}
+---
+{"jsonrpc":"2.0","id":1,"method":"textDocument/signatureHelp","params":{"textDocument":{"uri":"test:///main.cpp"},"position":{"line":2,"character":2}}}
+#      CHECK: "id": 1,
+# CHECK-NEXT: "jsonrpc": "2.0",
+# CHECK-NEXT: "result": {
+# CHECK-NEXT:   "activeParameter": 0,
+# CHECK-NEXT:   "activeSignature": 0,
+# CHECK-NEXT:   "signatures": [
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "label": "x(int) -> void",
+# CHECK-NEXT:       "parameters": [
+# CHECK-NEXT:         {
+# CHECK-NEXT:           "label": [
+# CHECK-NEXT:                     2,
+# CHECK-NEXT:                     5
+# CHECK-NEXT:                    ]
+# CHECK-NEXT:         }
+# CHECK-NEXT:       ]
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]
+# CHECK-NEXT: }
+---
+{"jsonrpc":"2.0","id":100000,"method":"shutdown"}
+---
+{"jsonrpc":"2.0","method":"exit"}

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

 }
 
 SignatureHelp signatures(llvm::StringRef Text,
                          std::vector<Symbol> IndexSymbols = {}) {
   Annotations Test(Text);
   return signatures(Test.code(), Test.point(), std::move(IndexSymbols));
 }
 
+struct ExpectedParameter {
+  std::string Text;
+  std::pair<unsigned, unsigned> Offsets;
+};
 MATCHER_P(ParamsAre, P, "") {
   if (P.size() != arg.parameters.size())
     return false;
-  for (unsigned I = 0; I < P.size(); ++I)
-    if (P[I] != arg.parameters[I].label)
+  for (unsigned I = 0; I < P.size(); ++I) {
+    if (P[I].Text != arg.parameters[I].labelString ||
+        P[I].Offsets != arg.parameters[I].labelOffsets)
       return false;
+  }
   return true;
 }
 MATCHER_P(SigDoc, Doc, "") { return arg.documentation == Doc; }
 
-Matcher<SignatureInformation> Sig(std::string Label,
-                                  std::vector<std::string> Params) {
-  return AllOf(SigHelpLabeled(Label), ParamsAre(Params));
+/// \p AnnotatedLabel is a signature label with ranges marking parameters, e.g.
+///    foo([[int p1]], [[double p2]]) -> void
+Matcher<SignatureInformation> Sig(llvm::StringRef AnnotatedLabel) {
+  llvm::Annotations A(AnnotatedLabel);
+  std::string Label = A.code();
+  std::vector<ExpectedParameter> Parameters;
+  for (auto Range : A.ranges()) {
+    Parameters.emplace_back();
+
+    ExpectedParameter &P = Parameters.back();
+    P.Text = Label.substr(Range.Begin, Range.End - Range.Begin);
+    P.Offsets.first = lspLength(llvm::StringRef(Label).substr(0, Range.Begin));
+    P.Offsets.second = lspLength(llvm::StringRef(Label).substr(1, Range.End));
+  }
+  return AllOf(SigHelpLabeled(Label), ParamsAre(Parameters));
 }
 
 TEST(SignatureHelpTest, Overloads) {
   auto Results = signatures(R"cpp(
     void foo(int x, int y);
     void foo(int x, float y);
     void foo(float x, int y);
     void foo(float x, float y);
     void bar(int x, int y = 0);
     int main() { foo(^); }
   )cpp");
   EXPECT_THAT(Results.signatures,
-              UnorderedElementsAre(
-                  Sig("foo(float x, float y) -> void", {"float x", "float y"}),
-                  Sig("foo(float x, int y) -> void", {"float x", "int y"}),
-                  Sig("foo(int x, float y) -> void", {"int x", "float y"}),
-                  Sig("foo(int x, int y) -> void", {"int x", "int y"})));
+              UnorderedElementsAre(Sig("foo([[float x]], [[float y]]) -> void"),
+                                   Sig("foo([[float x]], [[int y]]) -> void"),
+                                   Sig("foo([[int x]], [[float y]]) -> void"),
+                                   Sig("foo([[int x]], [[int y]]) -> void")));
   // We always prefer the first signature.
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, DefaultArgs) {
   auto Results = signatures(R"cpp(
     void bar(int x, int y = 0);
     void bar(float x = 0, int y = 42);
     int main() { bar(^
   )cpp");
   EXPECT_THAT(Results.signatures,
               UnorderedElementsAre(
-                  Sig("bar(int x, int y = 0) -> void", {"int x", "int y = 0"}),
-                  Sig("bar(float x = 0, int y = 42) -> void",
-                      {"float x = 0", "int y = 42"})));
+                  Sig("bar([[int x]], [[int y = 0]]) -> void"),
+                  Sig("bar([[float x = 0]], [[int y = 42]]) -> void")));
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, ActiveArg) {
   auto Results = signatures(R"cpp(
     int baz(int a, int b, int c);
     int main() { baz(baz(1,2,3), ^); }
   )cpp");
   EXPECT_THAT(Results.signatures,
-              ElementsAre(Sig("baz(int a, int b, int c) -> int",
-                              {"int a", "int b", "int c"})));
+              ElementsAre(Sig("baz([[int a]], [[int b]], [[int c]]) -> int")));
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(1, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, OpeningParen) {
   llvm::StringLiteral Tests[] = {// Recursive function call.
                                  R"cpp(
     int foo(int a, int b, int c);
TEST(SignatureHelpTest, OverloadsOrdering) {
   const auto Results = signatures(R"cpp(
     void foo(int x);
     void foo(int x, float y);
     void foo(float x, int y);
     void foo(float x, float y);
     void foo(int x, int y = 0);
     int main() { foo(^); }
   )cpp");
-  EXPECT_THAT(
-      Results.signatures,
-      ElementsAre(
-          Sig("foo(int x) -> void", {"int x"}),
-          Sig("foo(int x, int y = 0) -> void", {"int x", "int y = 0"}),
-          Sig("foo(float x, int y) -> void", {"float x", "int y"}),
-          Sig("foo(int x, float y) -> void", {"int x", "float y"}),
-          Sig("foo(float x, float y) -> void", {"float x", "float y"})));
+  EXPECT_THAT(Results.signatures,
+              ElementsAre(Sig("foo([[int x]]) -> void"),
+                          Sig("foo([[int x]], [[int y = 0]]) -> void"),
+                          Sig("foo([[float x]], [[int y]]) -> void"),
+                          Sig("foo([[int x]], [[float y]]) -> void"),
+                          Sig("foo([[float x]], [[float y]]) -> void")));
   // We always prefer the first signature.
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, InstantiatedSignatures) {
   StringRef Sig0 = R"cpp(
     template <class T>
     void foo(T, T, T);
 
     int main() {
       foo<int>(^);
     }
   )cpp";
 
   EXPECT_THAT(signatures(Sig0).signatures,
-              ElementsAre(Sig("foo(T, T, T) -> void", {"T", "T", "T"})));
+              ElementsAre(Sig("foo([[T]], [[T]], [[T]]) -> void")));
 
   StringRef Sig1 = R"cpp(
     template <class T>
     void foo(T, T, T);
 
     int main() {
       foo(10, ^);
     })cpp";
 
   EXPECT_THAT(signatures(Sig1).signatures,
-              ElementsAre(Sig("foo(T, T, T) -> void", {"T", "T", "T"})));
+              ElementsAre(Sig("foo([[T]], [[T]], [[T]]) -> void")));
 
   StringRef Sig2 = R"cpp(
     template <class ...T>
     void foo(T...);
 
     int main() {
       foo<int>(^);
     }
   )cpp";
 
   EXPECT_THAT(signatures(Sig2).signatures,
-              ElementsAre(Sig("foo(T...) -> void", {"T..."})));
+              ElementsAre(Sig("foo([[T...]]) -> void")));
 
   // It is debatable whether we should substitute the outer template parameter
   // ('T') in that case. Currently we don't substitute it in signature help, but
   // do substitute in code complete.
   // FIXME: make code complete and signature help consistent, figure out which
   // way is better.
   StringRef Sig3 = R"cpp(
     template <class T>
     struct X {
       template <class U>
       void foo(T, U);
     };
 
     int main() {
       X<int>().foo<double>(^)
     }
   )cpp";
 
   EXPECT_THAT(signatures(Sig3).signatures,
-              ElementsAre(Sig("foo(T, U) -> void", {"T", "U"})));
+              ElementsAre(Sig("foo([[T]], [[U]]) -> void")));
 }
 
 TEST(SignatureHelpTest, IndexDocumentation) {
   Symbol Foo0 = sym("foo", index::SymbolKind::Function, "@F@\\0#");
   Foo0.Documentation = "Doc from the index";
   Symbol Foo1 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#");
   Foo1.Documentation = "Doc from the index";
   Symbol Foo2 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#I#");
 
   StringRef Sig0 = R"cpp(
     int foo();
     int foo(double);
 
     void test() {
       foo(^);
     }
   )cpp";
 
   EXPECT_THAT(
       signatures(Sig0, {Foo0}).signatures,
-      ElementsAre(AllOf(Sig("foo() -> int", {}), SigDoc("Doc from the index")),
-                  AllOf(Sig("foo(double) -> int", {"double"}), SigDoc(""))));
+      ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")),
+                  AllOf(Sig("foo([[double]]) -> int"), SigDoc(""))));
 
   StringRef Sig1 = R"cpp(
     int foo();
     // Overriden doc from sema
     int foo(int);
     // Doc from sema
     int foo(int, int);
 
     void test() {
       foo(^);
     }
   )cpp";
 
   EXPECT_THAT(
       signatures(Sig1, {Foo0, Foo1, Foo2}).signatures,
-      ElementsAre(AllOf(Sig("foo() -> int", {}), SigDoc("Doc from the index")),
-                  AllOf(Sig("foo(int) -> int", {"int"}),
-                        SigDoc("Overriden doc from sema")),
-                  AllOf(Sig("foo(int, int) -> int", {"int", "int"}),
-                        SigDoc("Doc from sema"))));
+      ElementsAre(
+          AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")),
+          AllOf(Sig("foo([[int]]) -> int"), SigDoc("Overriden doc from sema")),
+          AllOf(Sig("foo([[int]], [[int]]) -> int"), SigDoc("Doc from sema"))));
 }
 
 TEST(SignatureHelpTest, DynamicIndexDocumentation) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
TEST(SignatureHelpTest, DynamicIndexDocumentation) {
   )cpp");
   auto File = testPath("test.cpp");
   Server.addDocument(File, FileContent.code());
   // Wait for the dynamic index being built.
   ASSERT_TRUE(Server.blockUntilIdleForTest());
   EXPECT_THAT(
       llvm::cantFail(runSignatureHelp(Server, File, FileContent.point()))
           .signatures,
-      ElementsAre(AllOf(Sig("foo() -> int", {}), SigDoc("Member doc"))));
+      ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Member doc"))));
 }
 
 TEST(CompletionTest, CompletionFunctionArgsDisabled) {
   CodeCompleteOptions Opts;
   Opts.EnableSnippets = true;
   Opts.EnableFunctionArgSnippets = false;
 
   {

 
 TEST(SignatureHelpTest, InsideArgument) {
   {
     const auto Results = signatures(R"cpp(
       void foo(int x);
       void foo(int x, int y);
       int main() { foo(1+^); }
     )cpp");
-    EXPECT_THAT(
-        Results.signatures,
-        ElementsAre(Sig("foo(int x) -> void", {"int x"}),
-                    Sig("foo(int x, int y) -> void", {"int x", "int y"})));
+    EXPECT_THAT(Results.signatures,
+                ElementsAre(Sig("foo([[int x]]) -> void"),
+                            Sig("foo([[int x]], [[int y]]) -> void")));
     EXPECT_EQ(0, Results.activeParameter);
   }
   {
     const auto Results = signatures(R"cpp(
       void foo(int x);
       void foo(int x, int y);
       int main() { foo(1^); }
     )cpp");
-    EXPECT_THAT(
-        Results.signatures,
-        ElementsAre(Sig("foo(int x) -> void", {"int x"}),
-                    Sig("foo(int x, int y) -> void", {"int x", "int y"})));
+    EXPECT_THAT(Results.signatures,
+                ElementsAre(Sig("foo([[int x]]) -> void"),
+                            Sig("foo([[int x]], [[int y]]) -> void")));
     EXPECT_EQ(0, Results.activeParameter);
   }
   {
     const auto Results = signatures(R"cpp(
       void foo(int x);
       void foo(int x, int y);
       int main() { foo(1^0); }
     )cpp");
-    EXPECT_THAT(
-        Results.signatures,
-        ElementsAre(Sig("foo(int x) -> void", {"int x"}),
-                    Sig("foo(int x, int y) -> void", {"int x", "int y"})));
+    EXPECT_THAT(Results.signatures,
+                ElementsAre(Sig("foo([[int x]]) -> void"),
+                            Sig("foo([[int x]], [[int y]]) -> void")));
     EXPECT_EQ(0, Results.activeParameter);
   }
   {
     const auto Results = signatures(R"cpp(
       void foo(int x);
       void foo(int x, int y);
       int bar(int x, int y);
       int main() { bar(foo(2, 3^)); }
     )cpp");
-    EXPECT_THAT(Results.signatures, ElementsAre(Sig("foo(int x, int y) -> void",
-                                                    {"int x", "int y"})));
+    EXPECT_THAT(Results.signatures,
+                ElementsAre(Sig("foo([[int x]], [[int y]]) -> void")));
     EXPECT_EQ(1, Results.activeParameter);
   }
 }
 
 TEST(SignatureHelpTest, ConstructorInitializeFields) {
   {
     const auto Results = signatures(R"cpp(
       struct A {
         A(int);
       };
       struct B {
         B() : a_elem(^) {}
         A a_elem;
       };
     )cpp");
     EXPECT_THAT(Results.signatures,
-                UnorderedElementsAre(Sig("A(int)", {"int"}),
-                                     Sig("A(A &&)", {"A &&"}),
-                                     Sig("A(const A &)", {"const A &"})));
+                UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"),
+                                     Sig("A([[const A &]])")));
   }
   {
     const auto Results = signatures(R"cpp(
       struct A {
         A(int);
       };
       struct C {
         C(int);
         C(A);
       };
       struct B {
         B() : c_elem(A(1^)) {}
         C c_elem;
       };
     )cpp");
     EXPECT_THAT(Results.signatures,
-                UnorderedElementsAre(Sig("A(int)", {"int"}),
-                                     Sig("A(A &&)", {"A &&"}),
-                                     Sig("A(const A &)", {"const A &"})));
+                UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"),
+                                     Sig("A([[const A &]])")));
   }
 }
 
 TEST(CompletionTest, IncludedCompletionKinds) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   std::string Subdir = testPath("sub");
   std::string SearchDirArg = (Twine("-I") + Subdir).str();