[clangd] Polish clangd/inlayHints and expose them by default.

[sammccall]

Summary

This means it's a "real feature" in clangd 14, albeit one that requires special
client support.

• remove "preview" from the flag description
• expose the clangdInlayHints capability by default
• provide position as well as range
• support InlayHintsParams.range to restrict the range retrieved
• inlay hint list is in document order (sorted by position)

Still to come: control feature via config rather than flag.

Fixes https://github.com/clangd/clangd/issues/313
Protocol doc is in https://github.com/llvm/clangd-www/pull/56/files

[kadircet]

thanks this LGTM just a couple nits.
my biggest concern is old endpoint will vanish all of a sudden and it might create some confusion, especially for editors that turn on inlayhints without an explicit user interaction.
but i suppose plugin maintainers that implement the extension shouldn't have a hard time finding out the new endpoint and migrating to it. (and I don't think we've got (m)any plugins implementing the extension today.) So all should be fine.

clang-tools-extra/clangd/ClangdLSPServer.cpp

611

s/can/can be

clang-tools-extra/clangd/InlayHints.cpp

168

nit: parameter name comments for "" and ": " (same for other calls)

321–325

drop the last we

clang-tools-extra/clangd/InlayHints.h

26

nit: drop the empty line?

clang-tools-extra/clangd/Protocol.h

1555

s/an parameter/a parameter/

[sammccall]

In D116699#3227203, @kadircet wrote:

thanks this LGTM just a couple nits.
my biggest concern is old endpoint will vanish all of a sudden and it might create some confusion, especially for editors that turn on inlayhints without an explicit user interaction.
but i suppose plugin maintainers that implement the extension shouldn't have a hard time finding out the new endpoint and migrating to it. (and I don't think we've got (m)any plugins implementing the extension today.) So all should be fine.

Yes, transition pains.

To be clear, *this* change isn't breaking anyone: the protocol changes in this patch are backwards-compatible. So the number of plugins implementing today isn't super-relevant.
But we're adding a new API, and encouraging people to use it, and we'll remove it in future. The silver lining: we can choose how long to support the two in parallel, I'd be surprised if it was a significant burden (I expect *much* less than semantic highlights, which is a complicated protocol).

Anyway I don't want to gloss over the bumpiness, it's a tradeoff to get this in front of users.

clang-tools-extra/clangd/InlayHints.cpp

168

We have inlay hints now, who needs comments?!

clang-tools-extra/clangd/InlayHints.h

26

Done.
(FWIW I find comments a bit easier to read formatted like git commits: one line summary that stands alone, and a blank line before details. But this certainly isn't something we do consistently)

clang-tools-extra/clangd/ClangdLSPServer.h

struct Options : ClangdServer::Options {
     clangd::CodeCompleteOptions CodeComplete;
     MarkupKind SignatureHelpDocumentationFormat = MarkupKind::PlainText;
     clangd::RenameOptions Rename;
     /// Returns true if the tweak should be enabled.
     std::function<bool(const Tweak &)> TweakFilter = [](const Tweak &T) {
       return !T.hidden(); // only enable non-hidden tweaks.
     };
 
-    /// Enable preview of InlayHints feature.
-    bool InlayHints = false;
+    /// Enable InlayHints feature.
+    bool InlayHints = true;
 
     /// Limit the number of references returned (0 means no limit).
     size_t ReferencesLimit = 0;
   };
 
   ClangdLSPServer(Transport &Transp, const ThreadsafeFS &TFS,
                   const ClangdLSPServer::Options &Opts);
   /// The destructor blocks on any outstanding background tasks.

clang-tools-extra/clangd/ClangdLSPServer.cpp

ServerCaps["codeActionProvider"] =
                                 {CodeAction::QUICKFIX_KIND,
                                  CodeAction::REFACTOR_KIND,
                                  CodeAction::INFO_KIND}}}
           : llvm::json::Value(true);
 
   if (Opts.FoldingRanges)
     ServerCaps["foldingRangeProvider"] = true;
 
+  // FIXME: once inlayHints can be disabled in config, always advertise.
   if (Opts.InlayHints)
     ServerCaps["clangdInlayHintsProvider"] = true;
 
   std::vector<llvm::StringRef> Commands;
   for (llvm::StringRef Command : Handlers.CommandHandlers.keys())
     Commands.push_back(Command);
   llvm::sort(Commands);
   ServerCaps["executeCommandProvider"] =

 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) {
-  Server->inlayHints(Params.textDocument.uri.file(), std::move(Reply));
+  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;
   for (auto &Entry : Settings.compilationDatabaseChanges) {
     PathRef File = Entry.first;

clang-tools-extra/clangd/ClangdServer.h

public:
   void prepareCallHierarchy(PathRef File, Position Pos,
                             Callback<std::vector<CallHierarchyItem>> CB);
 
   /// Resolve incoming calls for a given call hierarchy item.
   void incomingCalls(const CallHierarchyItem &Item,
                      Callback<std::vector<CallHierarchyIncomingCall>>);
 
   /// Resolve inlay hints for a given document.
-  void inlayHints(PathRef File, Callback<std::vector<InlayHint>>);
+  void inlayHints(PathRef File, llvm::Optional<Range> RestrictRange,
+                  Callback<std::vector<InlayHint>>);
 
   /// Retrieve the top symbols from the workspace matching a query.
   void workspaceSymbols(StringRef Query, int Limit,
                         Callback<std::vector<SymbolInformation>> CB);
 
   /// Retrieve the symbols within the specified file.
   void documentSymbols(StringRef File,
                        Callback<std::vector<DocumentSymbol>> CB);

clang-tools-extra/clangd/ClangdServer.cpp

void ClangdServer::incomingCalls(
     const CallHierarchyItem &Item,
     Callback<std::vector<CallHierarchyIncomingCall>> CB) {
   WorkScheduler->run("Incoming Calls", "",
                      [CB = std::move(CB), Item, this]() mutable {
                        CB(clangd::incomingCalls(Item, Index));
                      });
 }
 
-void ClangdServer::inlayHints(PathRef File,
+void ClangdServer::inlayHints(PathRef File, llvm::Optional<Range> RestrictRange,
                               Callback<std::vector<InlayHint>> CB) {
-  auto Action = [CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable {
+  auto Action = [RestrictRange(std::move(RestrictRange)),
+                 CB = std::move(CB)](Expected<InputsAndAST> InpAST) mutable {
     if (!InpAST)
       return CB(InpAST.takeError());
-    CB(clangd::inlayHints(InpAST->AST));
+    CB(clangd::inlayHints(InpAST->AST, std::move(RestrictRange)));
   };
   WorkScheduler->runWithAST("InlayHints", File, std::move(Action));
 }
 
 void ClangdServer::onFileEvent(const DidChangeWatchedFilesParams &Params) {
   // FIXME: Do nothing for now. This will be used for indexing and potentially
   // invalidating other caches.
 }

clang-tools-extra/clangd/InlayHints.h

 
 #include "Protocol.h"
 #include <vector>
 
 namespace clang {
 namespace clangd {
 class ParsedAST;
 
-// Compute and return all inlay hints for a file.
-std::vector<InlayHint> inlayHints(ParsedAST &AST);
+/// Compute and return inlay hints for a file.
+/// If RestrictRange is set, return only hints whose location is in that range.
+std::vector<InlayHint> inlayHints(ParsedAST &AST,
+                                  llvm::Optional<Range> RestrictRange);
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INLAYHINTS_H

clang-tools-extra/clangd/InlayHints.cpp

 //===--- InlayHints.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 "InlayHints.h"
 #include "HeuristicResolver.h"
 #include "ParsedAST.h"
-#include "support/Logger.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/SourceManager.h"
-#include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace clangd {
+namespace {
+
+// For now, inlay hints are always anchored at the left or right of their range.
+enum class HintSide { Left, Right };
 
 class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
 public:
-  InlayHintVisitor(std::vector<InlayHint> &Results, ParsedAST &AST)
+  InlayHintVisitor(std::vector<InlayHint> &Results, ParsedAST &AST,
+                   llvm::Optional<Range> RestrictRange)
       : Results(Results), AST(AST.getASTContext()),
+        RestrictRange(std::move(RestrictRange)),
         MainFileID(AST.getSourceManager().getMainFileID()),
         Resolver(AST.getHeuristicResolver()),
         TypeHintPolicy(this->AST.getPrintingPolicy()),
         StructuredBindingPolicy(this->AST.getPrintingPolicy()) {
     bool Invalid = false;
     llvm::StringRef Buf =
         AST.getSourceManager().getBufferData(MainFileID, &Invalid);
     MainFileBuf = Invalid ? StringRef{} : Buf;
bool VisitCallExpr(CallExpr *E) {
     return true;
   }
 
   bool VisitFunctionDecl(FunctionDecl *D) {
     if (auto *AT = D->getReturnType()->getContainedAutoType()) {
       QualType Deduced = AT->getDeducedType();
       if (!Deduced.isNull()) {
         addTypeHint(D->getFunctionTypeLoc().getRParenLoc(), D->getReturnType(),
-                    "-> ");
+                    /*Prefix=*/"-> ");
       }
     }
 
     return true;
   }
 
   bool VisitVarDecl(VarDecl *D) {
     // Do not show hints for the aggregate in a structured binding,
     // but show hints for the individual bindings.
     if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
       for (auto *Binding : DD->bindings()) {
-        addTypeHint(Binding->getLocation(), Binding->getType(), ": ",
+        addTypeHint(Binding->getLocation(), Binding->getType(), /*Prefix=*/": ",
                     StructuredBindingPolicy);
       }
       return true;
     }
 
     if (D->getType()->getContainedAutoType()) {
       if (!D->getType()->isDependentType()) {
         // Our current approach is to place the hint on the variable
         // and accordingly print the full type
         // (e.g. for `const auto& x = 42`, print `const int&`).
         // Alternatively, we could place the hint on the `auto`
         // (and then just print the type deduced for the `auto`).
-        addTypeHint(D->getLocation(), D->getType(), ": ");
+        addTypeHint(D->getLocation(), D->getType(), /*Prefix=*/": ");
       }
     }
     return true;
   }
 
   // FIXME: Handle RecoveryExpr to try to hint some invalid calls.
 
 private:
void processCall(SourceLocation Anchor, const FunctionDecl *Callee,
     if (isSetter(Callee, ParameterNames))
       return;
 
     for (size_t I = 0; I < ArgCount; ++I) {
       StringRef Name = ParameterNames[I];
       if (!shouldHint(Args[I], Name))
         continue;
 
-      addInlayHint(Args[I]->getSourceRange(), InlayHintKind::ParameterHint,
-                   Name.str() + ": ");
+      addInlayHint(Args[I]->getSourceRange(), HintSide::Left,
+                   InlayHintKind::ParameterHint, /*Prefix=*/"", Name,
+                   /*Suffix=*/": ");
     }
   }
 
   static bool isSetter(const FunctionDecl *Callee, const NameVec &ParamNames) {
     if (ParamNames.size() != 1)
       return false;
 
     StringRef Name = getSimpleName(*Callee);
NameVec getParameterNamesForDecl(const FunctionDecl *Function,
     for (size_t I = 0; I < ArgCount; ++I) {
       const ParmVarDecl *Parm = Function->getParamDecl(I);
       assert(Parm);
       Result.emplace_back(getSimpleName(*Parm));
     }
     return Result;
   }
 
-  void addInlayHint(SourceRange R, InlayHintKind Kind, llvm::StringRef Label) {
+  // We pass HintSide rather than SourceLocation because we want to ensure 
+  // it is in the same file as the common file range.
+  void addInlayHint(SourceRange R, HintSide Side, InlayHintKind Kind,
+                    llvm::StringRef Prefix, llvm::StringRef Label,
+                    llvm::StringRef Suffix) {
     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{
-        Range{
-            sourceLocToPosition(AST.getSourceManager(), FileRange->getBegin()),
-            sourceLocToPosition(AST.getSourceManager(), FileRange->getEnd())},
-        Kind, Label.str()});
+    Results.push_back(
+        InlayHint{LSPPos, LSPRange, Kind, (Prefix + Label + Suffix).str()});
   }
 
   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) {
     // Do not print useless "NULL TYPE" hint.
     if (!T.getTypePtrOrNull())
       return;
 
     std::string TypeName = T.getAsString(Policy);
     if (TypeName.length() < TypeNameLimit)
-      addInlayHint(R, InlayHintKind::TypeHint, std::string(Prefix) + TypeName);
+      addInlayHint(R, HintSide::Right, InlayHintKind::TypeHint, Prefix,
+                   TypeName, /*Suffix=*/"");
   }
 
   std::vector<InlayHint> &Results;
   ASTContext &AST;
+  llvm::Optional<Range> RestrictRange;
   FileID MainFileID;
   StringRef MainFileBuf;
   const HeuristicResolver *Resolver;
   // We want to suppress default template arguments, but otherwise print
   // canonical types. Unfortunately, they're conflicting policies so we can't
   // have both. For regular types, suppressing template arguments is more
   // important, whereas printing canonical types is crucial for structured
   // bindings, so we use two separate policies. (See the constructor where
   // the policies are initialized for more details.)
   PrintingPolicy TypeHintPolicy;
   PrintingPolicy StructuredBindingPolicy;
 
   static const size_t TypeNameLimit = 32;
 };
 
-std::vector<InlayHint> inlayHints(ParsedAST &AST) {
+} // namespace
+
+std::vector<InlayHint> inlayHints(ParsedAST &AST,
+                                  llvm::Optional<Range> RestrictRange) {
   std::vector<InlayHint> Results;
-  InlayHintVisitor Visitor(Results, AST);
+  InlayHintVisitor Visitor(Results, AST, std::move(RestrictRange));
   Visitor.TraverseAST(AST.getASTContext());
 
   // De-duplicate hints. Duplicates can sometimes occur due to e.g. explicit
   // template instantiations.
   llvm::sort(Results);
   Results.erase(std::unique(Results.begin(), Results.end()), Results.end());
 
   return Results;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/Protocol.h

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 `textDocument/inlayHints` request.
+/// The parameter of a `clangd/inlayHints` request.
+///
+/// This is a clangd extension.
 struct InlayHintsParams {
   /// The text document for which inlay hints are requested.
   TextDocumentIdentifier textDocument;
+
+  /// If set, requests inlay hints for only part of the document.
+  llvm::Optional<Range> range;
 };
 bool fromJSON(const llvm::json::Value &, InlayHintsParams &, llvm::json::Path);
 
 /// A set of predefined 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);
enum class InlayHintKind {
   ///
   /// * 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);
 
 /// An annotation to be displayed inline next to a range of source code.
+///
+/// This is a clangd extension.
 struct InlayHint {
+  /// The position between two characters where the hint should be displayed.
+  ///
+  /// For example, n parameter hint may be positioned before an argument.
+  Position position;
+
   /// The range of source code to which the hint applies.
-  /// We provide the entire range, rather than just the endpoint
-  /// relevant to `position` (e.g. the start of the range for
-  /// InlayHintPosition::Before), to give clients the flexibility
-  /// to make choices like only displaying the hint while the cursor
-  /// is over the range, rather than displaying it all the time.
+  ///
+  /// 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;
 
-  /// The type of hint.
+  /// The type of hint, such as a parameter hint.
   InlayHintKind kind;
 
-  /// The label that is displayed in the editor.
+  /// The label that is displayed in the editor, such as a parameter name.
+  ///
+  /// The label may contain punctuation and/or whitespace to allow it to read
+  /// naturally when placed inline with the code.
   std::string label;
 };
 llvm::json::Value toJSON(const InlayHint &);
 bool operator==(const InlayHint &, const InlayHint &);
 bool operator<(const InlayHint &, const InlayHint &);
 
 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);
+  return O && O.map("textDocument", R.textDocument) && O.map("range", R.range);
 }
 
 llvm::json::Value toJSON(InlayHintKind K) {
   switch (K) {
   case InlayHintKind::ParameterHint:
     return "parameter";
   case InlayHintKind::TypeHint:
     return "type";
   }
   llvm_unreachable("Unknown clang.clangd.InlayHintKind");
 }
 
 llvm::json::Value toJSON(const InlayHint &H) {
-  return llvm::json::Object{
-      {"range", H.range}, {"kind", H.kind}, {"label", H.label}};
+  return llvm::json::Object{{"position", H.position},
+                            {"range", H.range},
+                            {"kind", H.kind},
+                            {"label", H.label}};
 }
 bool operator==(const InlayHint &A, const InlayHint &B) {
-  return std::tie(A.kind, A.range, A.label) ==
-         std::tie(B.kind, B.range, B.label);
+  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.kind, A.range, A.label) <
-         std::tie(B.kind, B.range, B.label);
+  return std::tie(A.position, A.range, A.kind, A.label) <
+         std::tie(B.position, B.range, B.kind, B.label);
 }
 
 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

 # RUN: clangd -lit-test < %s | FileCheck -strict-whitespace %s
 # Test initialize request parameters with rootUri
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootUri":"test:///workspace","capabilities":{},"trace":"off"}}
 #      CHECK:  "id": 0,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": {
 # CHECK-NEXT:    "capabilities": {
 # CHECK-NEXT:      "astProvider": true,
 # CHECK-NEXT:      "callHierarchyProvider": true,
+# CHECK-NEXT:      "clangdInlayHintsProvider": true,
 # CHECK-NEXT:      "codeActionProvider": true,
 # CHECK-NEXT:      "compilationDatabase": {
 # CHECK-NEXT:        "automaticReload": true
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "completionProvider": {
 # CHECK-NEXT:        "allCommitCharacters": [
 # CHECK-NEXT:          " ",
 # CHECK-NEXT:          "\t",

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

+# RUN: clangd -lit-test < %s | FileCheck %s
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{}}
+---
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{
+  "uri":"test:///main.cpp",
+  "languageId":"cpp",
+  "version":1,
+  "text":"int foo(int bar);\nint x = foo(42);\nint y = foo(42);"
+}}}
+---
+{"jsonrpc":"2.0","id":1,"method":"clangd/inlayHints","params":{
+  "textDocument":{"uri":"test:///main.cpp"},
+  "range":{
+    "start": {"line":1,"character":0},
+    "end": {"line":2,"character":0}
+  }
+}}
+#      CHECK:  "id": 1,
+# CHECK-NEXT:  "jsonrpc": "2.0",
+# CHECK-NEXT:  "result": [
+# CHECK-NEXT:    {
+# CHECK-NEXT:      "kind": "parameter",
+# CHECK-NEXT:      "label": "bar: ",
+# CHECK-NEXT:      "position": {
+# CHECK-NEXT:        "character": 12,
+# CHECK-NEXT:        "line": 1
+# CHECK-NEXT:      },
+# CHECK-NEXT:      "range": {
+# CHECK-NEXT:        "end": {
+# CHECK-NEXT:          "character": 14,
+# CHECK-NEXT:          "line": 1
+# CHECK-NEXT:        },
+# CHECK-NEXT:        "start": {
+# CHECK-NEXT:          "character": 12,
+# CHECK-NEXT:          "line": 1
+# CHECK-NEXT:        }
+# CHECK-NEXT:      }
+# CHECK-NEXT:    }
+# CHECK-NEXT:  ]
+# CHECK-NEXT:}
+---
+{"jsonrpc":"2.0","id":100,"method":"shutdown"}
+---
+{"jsonrpc":"2.0","method":"exit"}
+

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

 opt<bool> FoldingRanges{
     "folding-ranges",
     cat(Features),
     desc("Enable preview of FoldingRanges feature"),
     init(false),
     Hidden,
 };
 
-opt<bool> InlayHints{"inlay-hints", cat(Features),
-                     desc("Enable preview of InlayHints feature"), init(false)};
+opt<bool> InlayHints{
+    "inlay-hints",
+    cat(Features),
+    desc("Enable InlayHints feature"),
+    init(ClangdLSPServer::Options().InlayHints),
+    // FIXME: allow inlayHints to be disabled in Config and remove this option.
+    Hidden,
+};
 
 opt<unsigned> WorkerThreadsCount{
     "j",
     cat(Misc),
     desc("Number of async workers used by clangd. Background index also "
          "uses this many workers."),
     init(getDefaultAsyncThreadsCount()),
 };

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

 namespace clangd {
 
 std::ostream &operator<<(std::ostream &Stream, const InlayHint &Hint) {
   return Stream << Hint.label;
 }
 
 namespace {
 
-using ::testing::UnorderedElementsAre;
+using ::testing::ElementsAre;
 
 std::vector<InlayHint> hintsOfKind(ParsedAST &AST, InlayHintKind Kind) {
   std::vector<InlayHint> Result;
-  for (auto &Hint : inlayHints(AST)) {
+  for (auto &Hint : inlayHints(AST, /*RestrictRange=*/llvm::None)) {
     if (Hint.kind == Kind)
       Result.push_back(Hint);
   }
   return Result;
 }
 
+enum HintSide { Left, Right };
+
 struct ExpectedHint {
   std::string Label;
   std::string RangeName;
+  HintSide Side = Left;
 
   friend std::ostream &operator<<(std::ostream &Stream,
                                   const ExpectedHint &Hint) {
     return Stream << Hint.RangeName << ": " << Hint.Label;
   }
 };
 
 MATCHER_P2(HintMatcher, Expected, Code, "") {
   return arg.label == Expected.Label &&
-         arg.range == Code.range(Expected.RangeName);
+         arg.range == Code.range(Expected.RangeName) &&
+         arg.position ==
+             ((Expected.Side == Left) ? arg.range.start : arg.range.end);
 }
 
+MATCHER_P(labelIs, Label, "") { return arg.label == Label; }
+
 template <typename... ExpectedHints>
 void assertHints(InlayHintKind Kind, llvm::StringRef AnnotatedSource,
                  ExpectedHints... Expected) {
   Annotations Source(AnnotatedSource);
   TestTU TU = TestTU::withCode(Source.code());
   TU.ExtraArgs.push_back("-std=c++14");
   auto AST = TU.build();
 
   EXPECT_THAT(hintsOfKind(AST, Kind),
-              UnorderedElementsAre(HintMatcher(Expected, Source)...));
+              ElementsAre(HintMatcher(Expected, Source)...));
 }
 
+// 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...);
 }
 
 template <typename... ExpectedHints>
 void assertTypeHints(llvm::StringRef AnnotatedSource,
                      ExpectedHints... Expected) {
+  ignore(Expected.Side = Right...);
   assertHints(InlayHintKind::TypeHint, AnnotatedSource, Expected...);
 }
 
 TEST(ParameterHints, Smoke) {
   assertParameterHints(R"cpp(
     void foo(int param);
     void bar() {
       foo($param[[42]]);
void foo() {
       auto $var[[var]] = 42;
     }
     template void foo<int>();
     template void foo<float>();
   )cpp",
                   ExpectedHint{": int", "var"});
 }
 
+TEST(InlayHints, RestrictRange) {
+  Annotations Code(R"cpp(
+    auto a = false;
+    [[auto b = 1;
+    auto c = '2';]]
+    auto d = 3.f;
+  )cpp");
+  auto AST = TestTU::withCode(Code.code()).build();
+  EXPECT_THAT(inlayHints(AST, Code.range()),
+              ElementsAre(labelIs(": int"), labelIs(": char")));
+}
+
 // FIXME: Low-hanging fruit where we could omit a type hint:
 //  - auto x = TypeName(...);
 //  - auto x = (TypeName) (...);
 //  - auto x = static_cast<TypeName>(...);  // and other built-in casts
 
 // Annoyances for which a heuristic is not obvious:
 //  - auto x = llvm::dyn_cast<LongTypeName>(y);  // and similar
 //  - stdlib algos return unwieldy __normal_iterator<X*, ...> type
 //    (For this one, perhaps we should omit type hints that start
 //     with a double underscore.)
 
 } // namespace
 } // namespace clangd
 } // namespace clang