[clangd] Support for standard inlayHint protocol

[kadircet]

Summary

• Make clangd's internal representation more aligned with the standard. We keep range and extra inlayhint kinds around, but don't serialize them on standard version.
• Have custom serialization for extension (ugly, but going to go away).
• Support both versions until clangd-17.
• Don't advertise extension if client has support for standard implementation.
• Log a warning at startup about extension being deprecated, if client doesn't have support.

[kadircet]

• Add lit test

[kadircet]

• Mention range as an extension field.

[sammccall]

This looks like the right approach to me, thanks for doing this!

What do you want to do about paddingLeft/paddingRight?
IIUC where we're currently sending label="foo: " we need to send label="foo:", paddingRight=true.
But updating these strings might have a blast radius in the tests, so it might be best to do it in a separate patch?

clang-tools-extra/clangd/ClangdLSPServer.cpp

589

I still feel a little uncomfortable with this because it cuts against the design of capabilities, and it's not clear what concrete problem it solves.

Most likely it won't cause nor solve any problems. But it might lead to a lot of confusion.
(e.g. in nvim and some others, base capabilities are provided but customized by extensions/users. If one extension sets the standard capability and another tries to use clangd hints, or the user sets the wrong capability at first out of confusion, it seems hard to debug)

However it's up to you, I promise this is my last comment about it :-)

1216

link to https://clangd.llvm.org/extensions#inlay-hints ?

1226

Defining the extension JSON representation as a delta of the standard JSON representation seems brittle and it's hard to tell what the result is.
It doesn't seem like much code to encode Hint explicitly?

clang-tools-extra/clangd/Protocol.cpp

1321–1322

this can now be inlined into operator<< again, it's not being called anywhere else

1338

We can't serialize our extension kinds, a new version of the protocol might come out that says 3 means nullability hints or something and existing versions of clangd are sending incorrect kinds.

(probably the most regular thing to do is define json::Value toJSON(InlayHintKind) that returns int | null, but up to you)

clang-tools-extra/clangd/Protocol.h

497

nit: inlayHint, not hints (mostly confusing because arity differs between the two versions, and this is the wrong one)

1530–1531

we almost always use the comments from LSP in this file.
they're very often borderline useless, but there's some value in consistency.

(And in the case of InlayHint, some of the differences are meaningful)

1567–1568

this is an (unserialized) clangd extension

1575–1576

this is no longer correct: whitespace should no longer be included and paddingLeft/paddingRight should be set instead.

[kadircet]

• Get rid of warning and not advertising when client has capability.
• Introduce paddingLeft/paddingRight, get rid of leading/trailing spaces in label, but re-introduce them when serializing for extension.
• Update documentation to reflect LSP docs.

clang-tools-extra/clangd/ClangdLSPServer.cpp

589

because it cuts against the design of capabilities

agreed, i thought this was more of a capability when i was proposing it. but noticed that it wasn't while going into the details and rubbed me the wrong way as well. so dropping it.

[kadircet]

• Advertise inlayHintProvider

[sammccall]

Great! If you didn't already, can you check with VSCode before landing?
This might catch protocol bits we missed, but also will make sure that the disablement of the legacy protocol in vscode-clangd is working as we expect.

clang-tools-extra/clangd/Protocol.cpp

1339

I think "kind": null is formally invalid per spec, it needs to be omitted entirely (the difference between kind?: InlayHintKind and kind: InlayHintKind|null).

I suspect it'll work fine in practice, but if you want to be really rigorous probably better add it conditionally

clang-tools-extra/clangd/Protocol.h

1579

nit: = false to avoid accidentally uninitialized members

[kadircet]

• Default initialize paddingLeft/Right
• Don't serialize kind when its null
• Run in vscode, seems to be working.

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   void onPrepareCallHierarchy(const CallHierarchyPrepareParams &,
                               Callback<std::vector<CallHierarchyItem>>);
   void onCallHierarchyIncomingCalls(
       const CallHierarchyIncomingCallsParams &,
       Callback<std::vector<CallHierarchyIncomingCall>>);
   void onCallHierarchyOutgoingCalls(
       const CallHierarchyOutgoingCallsParams &,
       Callback<std::vector<CallHierarchyOutgoingCall>>);
-  void onInlayHints(const InlayHintsParams &, Callback<std::vector<InlayHint>>);
+  void onClangdInlayHints(const InlayHintsParams &,
+                          Callback<llvm::json::Value>);
+  void onInlayHint(const InlayHintsParams &, Callback<std::vector<InlayHint>>);
   void onChangeConfiguration(const DidChangeConfigurationParams &);
   void onSymbolInfo(const TextDocumentPositionParams &,
                     Callback<std::vector<SymbolDetails>>);
   void onSelectionRange(const SelectionRangeParams &,
                         Callback<std::vector<SelectionRange>>);
   void onDocumentLink(const DocumentLinkParams &,
                       Callback<std::vector<DocumentLink>>);
   void onSemanticTokens(const SemanticTokensParams &, Callback<SemanticTokens>);

clang-tools-extra/clangd/ClangdLSPServer.cpp

 #include "support/Context.h"
 #include "support/MemoryTree.h"
 #include "support/Trace.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <chrono>
llvm::json::Object ServerCaps{
       {"referencesProvider", true},
       {"astProvider", true}, // clangd extension
       {"typeHierarchyProvider", true},
       {"memoryUsageProvider", true}, // clangd extension
       {"compilationDatabase",        // clangd extension
        llvm::json::Object{{"automaticReload", true}}},
       {"callHierarchyProvider", true},
       {"clangdInlayHintsProvider", true},
+      {"inlayHintProvider", true},
   };
 
   {
     LSPBinder Binder(Handlers, *this);
     bindMethods(Binder, Params.capabilities);
     if (Opts.FeatureModules)
       for (auto &Mod : *Opts.FeatureModules)
         Mod.initializeLSP(Binder, Params.rawCapabilities, ServerCaps);
   }
 
   // Per LSP, renameProvider can be either boolean or RenameOptions.
   // RenameOptions will be specified if the client states it supports prepare.
   ServerCaps["renameProvider"] =
       Params.capabilities.RenamePrepareSupport
           ? llvm::json::Object{{"prepareProvider", true}}
           : llvm::json::Value(true);
 
   // Per LSP, codeActionProvider can be either boolean or CodeActionOptions.
   // CodeActionOptions is only valid if the client supports action literal

 }
 
 void ClangdLSPServer::onCallHierarchyIncomingCalls(
     const CallHierarchyIncomingCallsParams &Params,
     Callback<std::vector<CallHierarchyIncomingCall>> Reply) {
   Server->incomingCalls(Params.item, std::move(Reply));
 }
 
-void ClangdLSPServer::onInlayHints(const InlayHintsParams &Params,
-                                   Callback<std::vector<InlayHint>> Reply) {
+void ClangdLSPServer::onClangdInlayHints(const InlayHintsParams &Params,
+                                         Callback<llvm::json::Value> Reply) {
+  // Our extension has a different representation on the wire than the standard.
+  // We have a "range" property and "kind" is represented as a string, not as an
+  // enum value.
+  // https://clangd.llvm.org/extensions#inlay-hints
+  auto Serialize = [Reply = std::move(Reply)](
+                       llvm::Expected<std::vector<InlayHint>> Hints) mutable {
+    if (!Hints) {
+      Reply(Hints.takeError());
+      return;
+    }
+    llvm::json::Array Result;
+    Result.reserve(Hints->size());
+    for (auto &Hint : *Hints) {
+      Result.emplace_back(llvm::json::Object{
+          {"kind", llvm::to_string(Hint.kind)},
+          {"range", Hint.range},
+          {"position", Hint.position},
+          // Extension doesn't have paddingLeft/Right so adjust the label
+          // accordingly.
+          {"label",
+           ((Hint.paddingLeft ? " " : "") + llvm::StringRef(Hint.label) +
+            (Hint.paddingRight ? " " : ""))
+               .str()},
+      });
+    }
+    Reply(std::move(Result));
+  };
+  Server->inlayHints(Params.textDocument.uri.file(), Params.range,
+                     std::move(Serialize));
+}
+
+void ClangdLSPServer::onInlayHint(const InlayHintsParams &Params,
   Server->inlayHints(Params.textDocument.uri.file(), Params.range,
                      std::move(Reply));
 }
 
 void ClangdLSPServer::applyConfiguration(
     const ConfigurationSettings &Settings) {
   // Per-file update to the compilation database.
   llvm::StringSet<> ModifiedFiles;
void ClangdLSPServer::bindMethods(LSPBinder &Bind,
   Bind.method("textDocument/typeHierarchy", this, &ClangdLSPServer::onTypeHierarchy);
   Bind.method("typeHierarchy/resolve", this, &ClangdLSPServer::onResolveTypeHierarchy);
   Bind.method("textDocument/prepareCallHierarchy", this, &ClangdLSPServer::onPrepareCallHierarchy);
   Bind.method("callHierarchy/incomingCalls", this, &ClangdLSPServer::onCallHierarchyIncomingCalls);
   Bind.method("textDocument/selectionRange", this, &ClangdLSPServer::onSelectionRange);
   Bind.method("textDocument/documentLink", this, &ClangdLSPServer::onDocumentLink);
   Bind.method("textDocument/semanticTokens/full", this, &ClangdLSPServer::onSemanticTokens);
   Bind.method("textDocument/semanticTokens/full/delta", this, &ClangdLSPServer::onSemanticTokensDelta);
-  Bind.method("clangd/inlayHints", this, &ClangdLSPServer::onInlayHints);
+  Bind.method("clangd/inlayHints", this, &ClangdLSPServer::onClangdInlayHints);
+  Bind.method("textDocument/inlayHint", this, &ClangdLSPServer::onInlayHint);
   Bind.method("$/memoryUsage", this, &ClangdLSPServer::onMemoryUsage);
   if (Opts.FoldingRanges)
     Bind.method("textDocument/foldingRange", this, &ClangdLSPServer::onFoldingRange);
   Bind.command(ApplyFixCommand, this, &ClangdLSPServer::onCommandApplyEdit);
   Bind.command(ApplyTweakCommand, this, &ClangdLSPServer::onCommandApplyTweak);
 
   ApplyWorkspaceEdit = Bind.outgoingMethod("workspace/applyEdit");
   PublishDiagnostics = Bind.outgoingNotification("textDocument/publishDiagnostics");

clang-tools-extra/clangd/InlayHints.cpp

void processCall(SourceLocation Anchor, const FunctionDecl *Callee,
 
     for (size_t I = 0; I < ArgCount; ++I) {
       StringRef Name = ParameterNames[I];
       bool NameHint = shouldHintName(Args[I], Name);
       bool ReferenceHint = shouldHintReference(Params[I]);
 
       if (NameHint || ReferenceHint) {
         addInlayHint(Args[I]->getSourceRange(), HintSide::Left,
-                     InlayHintKind::ParameterHint, ReferenceHint ? "&" : "",
+                     InlayHintKind::Parameter, ReferenceHint ? "&" : "",
                      NameHint ? Name : "", ": ");
       }
     }
   }
 
   static bool isSetter(const FunctionDecl *Callee, const NameVec &ParamNames) {
     if (ParamNames.size() != 1)
       return false;
void addInlayHint(SourceRange R, HintSide Side, InlayHintKind Kind,
     switch (Kind) {
 #define CHECK_KIND(Enumerator, ConfigProperty)                                 \
   case InlayHintKind::Enumerator:                                              \
     assert(Cfg.InlayHints.ConfigProperty &&                                    \
            "Shouldn't get here if kind is disabled!");                         \
     if (!Cfg.InlayHints.ConfigProperty)                                        \
       return;                                                                  \
     break
-      CHECK_KIND(ParameterHint, Parameters);
-      CHECK_KIND(TypeHint, DeducedTypes);
-      CHECK_KIND(DesignatorHint, Designators);
+      CHECK_KIND(Parameter, Parameters);
+      CHECK_KIND(Type, DeducedTypes);
+      CHECK_KIND(Designator, Designators);
 #undef CHECK_KIND
     }
 
     auto FileRange =
         toHalfOpenFileRange(AST.getSourceManager(), AST.getLangOpts(), R);
     if (!FileRange)
       return;
     Range LSPRange{
         sourceLocToPosition(AST.getSourceManager(), FileRange->getBegin()),
         sourceLocToPosition(AST.getSourceManager(), FileRange->getEnd())};
     Position LSPPos = Side == HintSide::Left ? LSPRange.start : LSPRange.end;
     if (RestrictRange &&
         (LSPPos < RestrictRange->start || !(LSPPos < RestrictRange->end)))
       return;
     // The hint may be in a file other than the main file (for example, a header
     // file that was included after the preamble), do not show in that case.
     if (!AST.getSourceManager().isWrittenInMainFile(FileRange->getBegin()))
       return;
-    Results.push_back(
-        InlayHint{LSPPos, LSPRange, Kind, (Prefix + Label + Suffix).str()});
+    bool PadLeft = Prefix.consume_front(" ");
+    bool PadRight = Suffix.consume_back(" ");
+    Results.push_back(InlayHint{LSPPos, (Prefix + Label + Suffix).str(), Kind,
+                                PadLeft, PadRight, LSPRange});
   }
 
   void addTypeHint(SourceRange R, QualType T, llvm::StringRef Prefix) {
     addTypeHint(R, T, Prefix, TypeHintPolicy);
   }
 
   void addTypeHint(SourceRange R, QualType T, llvm::StringRef Prefix,
                    const PrintingPolicy &Policy) {
     if (!Cfg.InlayHints.DeducedTypes || T.isNull())
       return;
 
     std::string TypeName = T.getAsString(Policy);
     if (TypeName.length() < TypeNameLimit)
-      addInlayHint(R, HintSide::Right, InlayHintKind::TypeHint, Prefix,
-                   TypeName, /*Suffix=*/"");
+      addInlayHint(R, HintSide::Right, InlayHintKind::Type, Prefix, TypeName,
+                   /*Suffix=*/"");
   }
 
   void addDesignatorHint(SourceRange R, llvm::StringRef Text) {
-    addInlayHint(R, HintSide::Left, InlayHintKind::DesignatorHint,
+    addInlayHint(R, HintSide::Left, InlayHintKind::Designator,
                  /*Prefix=*/"", Text, /*Suffix=*/"=");
   }
 
   std::vector<InlayHint> &Results;
   ASTContext &AST;
   const Config &Cfg;
   llvm::Optional<Range> RestrictRange;
   FileID MainFileID;

clang-tools-extra/clangd/Protocol.h

struct ClientCapabilities {
   /// Whether the client claims to cancel stale requests.
   /// general.staleRequestSupport.cancel
   bool CancelsStaleRequests = false;
 
   /// Whether the client implementation supports a refresh request sent from the
   /// server to the client.
   bool SemanticTokenRefreshSupport = false;
 };
 bool fromJSON(const llvm::json::Value &, ClientCapabilities &,
               llvm::json::Path);
 
 /// Clangd extension that's used in the 'compilationDatabaseChanges' in
 /// workspace/didChangeConfiguration to record updates to the in-memory
 /// compilation database.
 struct ClangdCompileCommand {
   std::string workingDirectory;
   std::vector<std::string> compilationCommand;
struct CallHierarchyOutgoingCall {
   CallHierarchyItem to;
 
   /// The range at which this item is called.
   /// This is the range relative to the caller, and not `To`.
   std::vector<Range> fromRanges;
 };
 llvm::json::Value toJSON(const CallHierarchyOutgoingCall &);
 
-/// The parameter of a `clangd/inlayHints` request.
-///
-/// This is a clangd extension.
+/// A parameter literal used in inlay hint requests.
 struct InlayHintsParams {
-  /// The text document for which inlay hints are requested.
+  /// The text document.
   TextDocumentIdentifier textDocument;
 
-  /// If set, requests inlay hints for only part of the document.
+  /// The visible document range for which inlay hints should be computed.
+  ///
+  /// None is a clangd extension, which hints for computing hints on the whole
+  /// file.
   llvm::Optional<Range> range;
 };
 bool fromJSON(const llvm::json::Value &, InlayHintsParams &, llvm::json::Path);
 
-/// A set of predefined hint kinds.
+/// Inlay hint kinds.
 enum class InlayHintKind {
-  /// The hint corresponds to parameter information.
-  /// An example of a parameter hint is a hint in this position:
-  ///    func(^arg);
-  /// which shows the name of the corresponding parameter.
-  ParameterHint,
-
-  /// The hint corresponds to information about a deduced type.
+  /// An inlay hint that for a type annotation.
+  ///
   /// An example of a type hint is a hint in this position:
   ///    auto var ^ = expr;
   /// which shows the deduced type of the variable.
-  TypeHint,
+  Type = 1,
+
+  /// An inlay hint that is for a parameter.
+  ///
+  /// An example of a parameter hint is a hint in this position:
+  ///    func(^arg);
+  /// which shows the name of the corresponding parameter.
+  Parameter = 2,
 
   /// A hint before an element of an aggregate braced initializer list,
   /// indicating what it is initializing.
   ///   Pair{^1, ^2};
   /// Uses designator syntax, e.g. `.first:`.
-  DesignatorHint,
+  /// This is a clangd extension.
+  Designator = 3,
 
   /// Other ideas for hints that are not currently implemented:
   ///
   /// * Chaining hints, showing the types of intermediate expressions
   ///   in a chain of function calls.
   /// * Hints indicating implicit conversions or implicit constructor calls.
 };
-llvm::json::Value toJSON(InlayHintKind);
+llvm::json::Value toJSON(const InlayHintKind &);
 
-/// An annotation to be displayed inline next to a range of source code.
-///
-/// This is a clangd extension.
+/// Inlay hint information.
 struct InlayHint {
-  /// The position between two characters where the hint should be displayed.
-  ///
-  /// For example, n parameter hint may be positioned before an argument.
+  /// The position of this hint.
   Position position;
 
-  /// The range of source code to which the hint applies.
+  /// The label of this hint. A human readable string or an array of
+  /// InlayHintLabelPart label parts.
   ///
-  /// For example, a parameter hint may have the argument as its range.
-  /// The range allows clients more flexibility of when/how to display the hint.
-  Range range;
+  /// *Note* that neither the string nor the label part can be empty.
+  std::string label;
 
-  /// The type of hint, such as a parameter hint.
+  /// The kind of this hint. Can be omitted in which case the client should fall
+  /// back to a reasonable default.
   InlayHintKind kind;
 
-  /// The label that is displayed in the editor, such as a parameter name.
+  /// Render padding before the hint.
   ///
-  /// The label may contain punctuation and/or whitespace to allow it to read
-  /// naturally when placed inline with the code.
-  std::string label;
+  /// Note: Padding should use the editor's background color, not the
+  /// background color of the hint itself. That means padding can be used
+  /// to visually align/separate an inlay hint.
+  bool paddingLeft;
+
+  /// Render padding after the hint.
+  ///
+  /// Note: Padding should use the editor's background color, not the
+  /// background color of the hint itself. That means padding can be used
+  /// to visually align/separate an inlay hint.
+  bool paddingRight;
+
+  /// The range of source code to which the hint applies.
+  ///
+  /// For example, a parameter hint may have the argument as its range.
+  /// The range allows clients more flexibility of when/how to display the hint.
+  /// This is an (unserialized) clangd extension.
+  Range range;
 };
 llvm::json::Value toJSON(const InlayHint &);
 bool operator==(const InlayHint &, const InlayHint &);
 bool operator<(const InlayHint &, const InlayHint &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, InlayHintKind);
 
 struct ReferenceContext {
   /// Include the declaration of the current symbol.

clang-tools-extra/clangd/Protocol.cpp

llvm::json::Value toJSON(const CallHierarchyOutgoingCall &C) {
   return llvm::json::Object{{"to", C.to}, {"fromRanges", C.fromRanges}};
 }
 
 bool fromJSON(const llvm::json::Value &Params, InlayHintsParams &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
 }
 
-static llvm::StringLiteral toString(InlayHintKind K) {
-  switch (K) {
-  case InlayHintKind::ParameterHint:
-    return "parameter";
-  case InlayHintKind::TypeHint:
-    return "type";
-  case InlayHintKind::DesignatorHint:
-    return "designator";
+llvm::json::Value toJSON(const InlayHintKind &Kind) {
+  switch (Kind) {
+  case InlayHintKind::Type:
+    return 1;
+  case InlayHintKind::Parameter:
+    return 2;
+  case InlayHintKind::Designator: // This is an extension, don't serialize.
+    return nullptr;
   }
   llvm_unreachable("Unknown clang.clangd.InlayHintKind");
 }
 
-llvm::json::Value toJSON(InlayHintKind K) { return toString(K); }
-
 llvm::json::Value toJSON(const InlayHint &H) {
   return llvm::json::Object{{"position", H.position},
-                            {"range", H.range},
-                            {"kind", H.kind},
-                            {"label", H.label}};
+                            {"label", H.label},
+                            {"paddingLeft", H.paddingLeft},
+                            {"paddingRight", H.paddingRight},
+                            {"kind", H.kind}};
 }
 bool operator==(const InlayHint &A, const InlayHint &B) {
   return std::tie(A.position, A.range, A.kind, A.label) ==
          std::tie(B.position, B.range, B.kind, B.label);
 }
 bool operator<(const InlayHint &A, const InlayHint &B) {
   return std::tie(A.position, A.range, A.kind, A.label) <
          std::tie(B.position, B.range, B.kind, B.label);
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, InlayHintKind Kind) {
-  return OS << toString(Kind);
+  auto ToString = [](InlayHintKind K) {
+    switch (K) {
+    case InlayHintKind::Parameter:
+      return "parameter";
+    case InlayHintKind::Type:
+      return "type";
+    case InlayHintKind::Designator:
+      return "designator";
+    }
+    llvm_unreachable("Unknown clang.clangd.InlayHintKind");
+  };
+  return OS << ToString(Kind);
 }
 
 static const char *toString(OffsetEncoding OE) {
   switch (OE) {
   case OffsetEncoding::UTF8:
     return "utf-8";
   case OffsetEncoding::UTF16:
     return "utf-16";

clang-tools-extra/clangd/test/initialize-params.test

 # CHECK-NEXT:      "executeCommandProvider": {
 # CHECK-NEXT:        "commands": [
 # CHECK-NEXT:          "clangd.applyFix",
 # CHECK-NEXT:          "clangd.applyTweak"
 # CHECK-NEXT:        ]
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "hoverProvider": true,
 # CHECK-NEXT:      "implementationProvider": true,
+# CHECK-NEXT:      "inlayHintProvider": true,
 # CHECK-NEXT:      "memoryUsageProvider": true,
 # CHECK-NEXT:      "referencesProvider": true,
 # CHECK-NEXT:      "renameProvider": true,
 # CHECK-NEXT:      "selectionRangeProvider": true,
 # CHECK-NEXT:      "semanticTokensProvider": {
 # CHECK-NEXT:        "full": {
 # CHECK-NEXT:          "delta": true
 # CHECK-NEXT:        },

clang-tools-extra/clangd/test/inlayHints.test

 # CHECK-NEXT:          "character": 12,
 # CHECK-NEXT:          "line": 1
 # CHECK-NEXT:        }
 # CHECK-NEXT:      }
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
 # CHECK-NEXT:}
 ---
+{"jsonrpc":"2.0","id":2,"method":"textDocument/inlayHint","params":{
+  "textDocument":{"uri":"test:///main.cpp"},
+  "range":{
+    "start": {"line":1,"character":0},
+    "end": {"line":2,"character":0}
+  }
+}}
+#      CHECK:  "id": 2,
+# CHECK-NEXT:  "jsonrpc": "2.0",
+# CHECK-NEXT:  "result": [
+# CHECK-NEXT:    {
+# CHECK-NEXT:      "kind": 2,
+# CHECK-NEXT:      "label": "bar:",
+# CHECK-NEXT:      "paddingLeft": false,
+# CHECK-NEXT:      "paddingRight": true,
+# CHECK-NEXT:      "position": {
+# CHECK-NEXT:        "character": 12,
+# CHECK-NEXT:        "line": 1
+# CHECK-NEXT:      }
+# CHECK-NEXT:    }
+# CHECK-NEXT:  ]
+# CHECK-NEXT:}
+---
 {"jsonrpc":"2.0","id":100,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}
 

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

 //===-- InlayHintTests.cpp  -------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 #include "Annotations.h"
 #include "Config.h"
 #include "InlayHints.h"
 #include "Protocol.h"
 #include "TestTU.h"
 #include "TestWorkspace.h"
 #include "XRefs.h"
 #include "support/Context.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &Stream,
struct ExpectedHint {
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &Stream,
                                        const ExpectedHint &Hint) {
     return Stream << Hint.Label << "@$" << Hint.RangeName;
   }
 };
 
 MATCHER_P2(HintMatcher, Expected, Code, llvm::to_string(Expected)) {
-  if (arg.label != Expected.Label) {
-    *result_listener << "label is " << arg.label;
+  llvm::StringRef ExpectedView(Expected.Label);
+  if (arg.label != ExpectedView.trim(" ") ||
+      arg.paddingLeft != ExpectedView.startswith(" ") ||
+      arg.paddingRight != ExpectedView.endswith(" ")) {
+    *result_listener << "label is '" << arg.label << "'";
     return false;
   }
   if (arg.range != Code.range(Expected.RangeName)) {
     *result_listener << "range is " << llvm::to_string(arg.range) << " but $"
                      << Expected.RangeName << " is "
                      << llvm::to_string(Code.range(Expected.RangeName));
     return false;
   }

 
 // Hack to allow expression-statements operating on parameter packs in C++14.
 template <typename... T> void ignore(T &&...) {}
 
 template <typename... ExpectedHints>
 void assertParameterHints(llvm::StringRef AnnotatedSource,
                           ExpectedHints... Expected) {
   ignore(Expected.Side = Left...);
-  assertHints(InlayHintKind::ParameterHint, AnnotatedSource, Expected...);
+  assertHints(InlayHintKind::Parameter, AnnotatedSource, Expected...);
 }
 
 template <typename... ExpectedHints>
 void assertTypeHints(llvm::StringRef AnnotatedSource,
                      ExpectedHints... Expected) {
   ignore(Expected.Side = Right...);
-  assertHints(InlayHintKind::TypeHint, AnnotatedSource, Expected...);
+  assertHints(InlayHintKind::Type, AnnotatedSource, Expected...);
 }
 
 template <typename... ExpectedHints>
 void assertDesignatorHints(llvm::StringRef AnnotatedSource,
                            ExpectedHints... Expected) {
   Config Cfg;
   Cfg.InlayHints.Designators = true;
   WithContextValue WithCfg(Config::Key, std::move(Cfg));
-  assertHints(InlayHintKind::DesignatorHint, AnnotatedSource, Expected...);
+  assertHints(InlayHintKind::Designator, AnnotatedSource, Expected...);
 }
 
 TEST(ParameterHints, Smoke) {
   assertParameterHints(R"cpp(
     void foo(int param);
     void bar() {
       foo($param[[42]]);
     }
TEST(ParameterHints, IncludeAtNonGlobalScope) {
   TestWorkspace Workspace;
   Workspace.addSource("foo.inc", FooInc.code());
   Workspace.addMainFile("foo.cc", FooCC.code());
 
   auto AST = Workspace.openFile("foo.cc");
   ASSERT_TRUE(bool(AST));
 
   // Ensure the hint for the call in foo.inc is NOT materialized in foo.cc.
-  EXPECT_EQ(hintsOfKind(*AST, InlayHintKind::ParameterHint).size(), 0u);
+  EXPECT_EQ(hintsOfKind(*AST, InlayHintKind::Parameter).size(), 0u);
 }
 
 TEST(TypeHints, Smoke) {
   assertTypeHints(R"cpp(
     auto $waldo[[waldo]] = 42;
   )cpp",
                   ExpectedHint{": int", "waldo"});
 }

 
 TEST(TypeHints, Aliased) {
   // Check that we don't crash for functions without a FunctionTypeLoc.
   // https://github.com/clangd/clangd/issues/1140
   TestTU TU = TestTU::withCode("void foo(void){} extern typeof(foo) foo;");
   TU.ExtraArgs.push_back("-xc");
   auto AST = TU.build();
 
-  EXPECT_THAT(hintsOfKind(AST, InlayHintKind::TypeHint), IsEmpty());
+  EXPECT_THAT(hintsOfKind(AST, InlayHintKind::Type), IsEmpty());
 }
 
 TEST(DesignatorHints, Basic) {
   assertDesignatorHints(R"cpp(
     struct S { int x, y, z; };
     S s {$x[[1]], $y[[2+2]]};
 
     int x[] = {$0[[0]], $1[[1]]};