[clangd] Add designator inlay hints for initializer lists.

[sammccall]

Summary

These make the init lists appear as if designated initialization was used.

Example:

ExpectedHint{"param: ", "arg"}

becomes

ExpectedHint{.Label="param: ", .RangeName="arg"}

[sammccall]

(I know you're on vacation, this isn't urgent, just wanted to send it so I didn't lose it to git obscurity!)

clang-tools-extra/clangd/InlayHints.cpp

418–422

This makes the existing comment suppression (for param names) a bit sloppier, but I have a hard time imagining a case where punctuation makes a difference.

[nridge]

Thanks, this is a pretty nice addition!

My only piece of high-level feedback is probing if the array element designators ([0]=) are useful enough to be worth the space/noise. The rest is minor implementation comments.

clang-tools-extra/clangd/InlayHints.cpp

71

We could consider using the type name of the base (but I also get the impression that aggregate initialization with bases is uncommon enough to not worry about right now)

81

Should we try to more specifically restrict this to the case where the one field is an array? Otherwise skipping the field name feels a bit arbitrary.

99

suggest Iter and End, I and E are a bit cryptic

117

Can we add that the written sublist will get its own VisitInitListExpr call by RAV, while the implicit sublist will not? (If I've understood that correctly.)

128

"of the aggregate type"? ("the type Type" is a bit confusing, for a moment I thought you were talking about clang::Type)

145

aside: Prefix on this line is a great use case for the UsedAsMutableReference modifier. Now, if only we could somehow integrate clangd's semantic highlighting into Phabricator...

151

It took me a while to think through why it's not necessary to add more things into NestedBraces for the recursive call: since we only recurse in the case of elided braces, if a brace-elided subobject has an initializer with an explicit brace then syntactically that's a direct child of the containing explicit-brace initializer (even if semantically it's several levels deep), and thus its brace is already represented in NestedBraces. Might be worth pointing that out in a comment.

165

collectDesignators

176

"EmptyPrefix"? ("Scratch" makes it sound like "scratch space for it to write temporary things into")

292

I take it the parameter name Syn is supposed to suggest that the InitListExpr is the syntactic form (of the two forms described here), and that we know this because InlayHintVisitor does not override shouldVisitImplicitCode(), which makes RAV only traverse the syntactic form.

I think it would aid understandability if we mentioned these things in a comment.

422

Why do we need to trim ParamName?

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

687

I wonder how useful these array-index hints are.

Unlike the struct case, they're not taking information present "elsewhere" (field names from the structure declaration) and making it available in the initializer, they're just taking information already present in the initializer and making it more explicit.

On the other hand, I guess if it's important that you initialize the element at index 15 in particular to some value, these hints help ensure you don't make an off-by-one error...

740

Maybe add a clarifying comment saying "this argument gets a hint, but not of type Designator", as this confused me for a while.

[kadircet]

a drive by concern around possible flakiness of the interaction. have you checked how does it look like when the user is still forming the initializer? it might be annoying if their cursor kept jumping around while they're editing the (possibly half-formed) initializer.

[sammccall]

Address comments, rebase.
This category is *off* by default.

[sammccall]

In D116786#3247800, @kadircet wrote:

a drive by concern around possible flakiness of the interaction. have you checked how does it look like when the user is still forming the initializer? it might be annoying if their cursor kept jumping around while they're editing the (possibly half-formed) initializer.

Hmm, just tested and this is definitely a thing.
The biggest problem seems to be typing something that causes all prior designators to disappear.
This happens when you add an invalid expression to the init list, e.g a partial identifier you're typing.
(RecoveryExpr doesn't help here unless we can determine the type - dependent initlistexprs are not semantically analyzed).

Any ideas? :-(

clang-tools-extra/clangd/InlayHints.cpp

71

Yeah, I think this is rare.
Given that, I'd rather not create the confusion by having these hints be almost-but-not-quite-always valid syntax.

81

I modeled this after isIdiomaticBraceElisionEntity in SemaInit.cpp, which doesn't have this restriction.
(Though I didn't bother to implement the "base only" case, and restricted it to fields with reserved names).

I can change it if you want, though note that this is only eliding reserved names, and we *fail* (refuse to produce a designator) for reserved names otherwise.

145

Agree. I've also wondered about using 🌀 as an inlay-hint instead of a token modifier.

422

We're just passing in the designator string here, it may be .foo= and I want to match /*foo*/ and /*foo=*/ as well as /*.foo=*/.

I'd consider adding [] here too, to allow /*1=*/ to match [1]=.

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

687

they're just taking information already present in the initializer and making it more explicit

This is usually true but not always, e.g.

struct Point { float x, y, z; };
Point shape[] = {
  /*[0].x=*/1.0,
  /*[0].y=*/0.3,
  /*[0].z=*/0.3,
  /*[1].x=*/0.3,
  /*[1].y=*/0.1,
  /*[1].z=*/0.6,
  ...
};

We could try some other behavior:

• don't emit a hint if there's any array component
• don't emit a hint if there's exactly one array component and nothing else
• have array vs field designators separately configurable

I'm not sure how this will feel in practice. I quite like the idea of having them initially, but turning this category off by default to give a chance to dogfood and reevaluate

[kadircet]

Any ideas? :-(

I've got a feeling that, this should also be annoying in the case of function calls (especially when there's only one overload)? Maybe we should just debounce the inlayhint requests (by saying contents modified to the clients)?

[sammccall]

In D116786#3257932, @kadircet wrote:

Any ideas? :-(

I've got a feeling that, this should also be annoying in the case of function calls (especially when there's only one overload)? Maybe we should just debounce the inlayhint requests (by saying contents modified to the clients)?

This seems like the right track, but I'm not sure rejecting requests specifically is the right answer. Two reasons:

1. This requires careful impl on the client side. LSP has been amended to greatly discourage contentmodified. We still send it heuristically, but there's a capability to opt out of this and vscode sets it.

(As long as this is a custom protocol we can say what we want, but it won't be forever).

2. Choosing which requests to respond to is hard, stateful work.

This isn't the drop-for-efficiency situation where the queue is full, this behavior is most annoying when the server is able to keep up with keystrokes. And the errors that cause this may not be trivially brief "i'm in the middle of typing a word" anyway.
Really you want to work out if this is a "good" request based on the AST. And in fact the analysis you'll do looks a lot like actually generating the hints, and probably comparing with the last ones. Then we throw them all away?!

---

I'd suggest something slightly different: we compute inlay hints, heuristically merge with some previous state, and return the merged results.
Heuristics are something like:

• generally prefer freshly computed hints
• be willing to add old ones where newer ones are missing
• be willing to use older ones where code has changed near the hints (but not when they overlap!)

(There's not much here that's specific to inlay hints vs other decorations tied to ranges - certainly we could/should do this for semantictokens too, and documentSymbols, ...)

---

A variation on this idea is to compute these decorations frequently but "whenever we like" and always serve them from this cache, just patching them for changes in the source code.
This gives us more control of when the analyses run, maybe there's a lot of extra efficiency here. But I think the cache still needs stateful updates to solve this bug, unless we have *great* heuristics for "whenever we like".

[kadircet]

I was also thinking about a cache-based solution in which we can update results as we please, and as you noted the idea definitely generalizes to other requests as well, with possibly little nuances around the definition of "as we please", which makes things a lot more annoying as we can't have this as a single layer between all requests/responses but will require some feature specific customization.
I feel like this is the way to go, but we'll need to put more thought into the design especially considering the future improvements like pseudoparser and the way it's possibly going to change how these features are going to look like in presence of it. Maybe all of these features would work on top of a fresh pseudo-parse + last "good" ast :shrug:

[sammccall]

In D116786#3260970, @kadircet wrote:

I feel like this is the way to go, but we'll need to put more thought into the design

Agree. I guess then we ignore the issue for this patch? As you say that's affects other hints too, and a mitigation (hopefully) won't be specific to the kind of hint.

[nridge]

Thanks, I'm happy to try the array designators and see how they work out in practice.

The issue of hints appearing and disappearing as you type a function call is one I've noticed, but I've gotten used to it after a while. Improvements in this area would be nice but probably don't need to block the addition of new hints.

[kadircet]

Agree. I guess then we ignore the issue for this patch? As you say that's affects other hints too, and a mitigation (hopefully) won't be specific to the kind of hint.

Yup.

clang-tools-extra/clangd/Config.h

struct Config {
 
   struct {
     /// If false, inlay hints are completely disabled.
     bool Enabled = true;
 
     // Whether specific categories of hints are enabled.
     bool Parameters = true;
     bool DeducedTypes = true;
+    bool Designators = false;
   } InlayHints;
 };
 
 } // namespace clangd
 } // namespace clang
 
 namespace llvm {
 template <> struct DenseMapInfo<clang::clangd::Config::ExternalIndexSpec> {

clang-tools-extra/clangd/ConfigCompile.cpp

if (F.ParameterNames)
       Out.Apply.push_back(
           [Value(**F.ParameterNames)](const Params &, Config &C) {
             C.InlayHints.Parameters = Value;
           });
     if (F.DeducedTypes)
       Out.Apply.push_back([Value(**F.DeducedTypes)](const Params &, Config &C) {
         C.InlayHints.DeducedTypes = Value;
       });
+    if (F.Designators)
+      Out.Apply.push_back([Value(**F.Designators)](const Params &, Config &C) {
+        C.InlayHints.Designators = Value;
+      });
   }
 
   constexpr static llvm::SourceMgr::DiagKind Error = llvm::SourceMgr::DK_Error;
   constexpr static llvm::SourceMgr::DiagKind Warning =
       llvm::SourceMgr::DK_Warning;
   void diag(llvm::SourceMgr::DiagKind Kind, llvm::StringRef Message,
             llvm::SMRange Range) {
     if (Range.isValid() && SourceMgr != nullptr)

clang-tools-extra/clangd/ConfigFragment.h

struct Fragment {
   struct InlayHintsBlock {
     /// Enables/disables the inlay-hints feature.
     llvm::Optional<Located<bool>> Enabled;
 
     /// Show parameter names before function arguments.
     llvm::Optional<Located<bool>> ParameterNames;
     /// Show deduced types for `auto`.
     llvm::Optional<Located<bool>> DeducedTypes;
+    /// Show designators in aggregate initialization.
+    llvm::Optional<Located<bool>> Designators;
   };
   InlayHintsBlock InlayHints;
 };
 
 } // namespace config
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/ConfigYAML.cpp

void parse(Fragment::InlayHintsBlock &F, Node &N) {
     Dict.handle("ParameterNames", [&](Node &N) {
       if (auto Value = boolValue(N, "ParameterNames"))
         F.ParameterNames = *Value;
     });
     Dict.handle("DeducedTypes", [&](Node &N) {
       if (auto Value = boolValue(N, "DeducedTypes"))
         F.DeducedTypes = *Value;
     });
+    Dict.handle("Designators", [&](Node &N) {
+      if (auto Value = boolValue(N, "Designators"))
+        F.Designators = *Value;
+    });
     Dict.parse(N);
   }
 
   // Helper for parsing mapping nodes (dictionaries).
   // We don't use YamlIO as we want to control over unknown keys.
   class DictParser {
     llvm::StringRef Description;
     std::vector<std::pair<llvm::StringRef, std::function<void(Node &)>>> Keys;

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 "Config.h"
 #include "HeuristicResolver.h"
 #include "ParsedAST.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/SourceManager.h"
+#include "llvm/ADT/ScopeExit.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 };
 
+// Helper class to iterate over the designator names of an aggregate type.
+//
+// For an array type, yields [0], [1], [2]...
+// For aggregate classes, yields null for each base, then .field1, .field2, ...
+class AggregateDesignatorNames {
+public:
+  AggregateDesignatorNames(QualType T) {
+    if (!T.isNull()) {
+      T = T.getCanonicalType();
+      if (T->isArrayType()) {
+        IsArray = true;
+        Valid = true;
+        return;
+      }
+      if (const RecordDecl *RD = T->getAsRecordDecl()) {
+        Valid = true;
+        FieldsIt = RD->field_begin();
+        FieldsEnd = RD->field_end();
+        if (const auto *CRD = llvm::dyn_cast<CXXRecordDecl>(RD)) {
+          BasesIt = CRD->bases_begin();
+          BasesEnd = CRD->bases_end();
+          Valid = CRD->isAggregate();
+        }
+        OneField = Valid && BasesIt == BasesEnd && FieldsIt != FieldsEnd &&
+                   std::next(FieldsIt) == FieldsEnd;
+      }
+    }
+  }
+  // Returns false if the type was not an aggregate.
+  operator bool() { return Valid; }
+  // Advance to the next element in the aggregate.
+  void next() {
+    if (IsArray)
+      ++Index;
+    else if (BasesIt != BasesEnd)
+      ++BasesIt;
+    else if (FieldsIt != FieldsEnd)
+      ++FieldsIt;
+  }
+  // Print the designator to Out.
+  // Returns false if we could not produce a designator for this element.
+  bool append(std::string &Out, bool ForSubobject) {
+    if (IsArray) {
+      Out.push_back('[');
+      Out.append(std::to_string(Index));
+      Out.push_back(']');
+      return true;
+    }
+    if (BasesIt != BasesEnd)
+      return false; // Bases can't be designated. Should we make one up?
+    if (FieldsIt != FieldsEnd) {
+      llvm::StringRef FieldName;
+      if (const IdentifierInfo *II = FieldsIt->getIdentifier())
+        FieldName = II->getName();
+
+      // For certain objects, their subobjects may be named directly.
+      if (ForSubobject &&
+          (FieldsIt->isAnonymousStructOrUnion() ||
+           // std::array<int,3> x = {1,2,3}. Designators not strictly valid!
+           (OneField && isReservedName(FieldName))))
+        return true;
+
+      if (!FieldName.empty() && !isReservedName(FieldName)) {
+        Out.push_back('.');
+        Out.append(FieldName.begin(), FieldName.end());
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
+
+private:
+  bool Valid = false;
+  bool IsArray = false;
+  bool OneField = false; // e.g. std::array { T __elements[N]; }
+  unsigned Index = 0;
+  CXXRecordDecl::base_class_const_iterator BasesIt;
+  CXXRecordDecl::base_class_const_iterator BasesEnd;
+  RecordDecl::field_iterator FieldsIt;
+  RecordDecl::field_iterator FieldsEnd;
+};
+
+// Collect designator labels describing the elements of an init list.
+//
+// This function contributes the designators of some (sub)object, which is
+// represented by the semantic InitListExpr Sem.
+// This includes any nested subobjects, but *only* if they are part of the same
+// original syntactic init list (due to brace elision).
+// In other words, it may descend into subobjects but not written init-lists.
+//
+// For example: struct Outer { Inner a,b; }; struct Inner { int x, y; }
+//              Outer o{{1, 2}, 3};
+// This function will be called with Sem = { {1, 2}, {3, ImplicitValue} }
+// It should generate designators '.a:' and '.b.x:'.
+// '.a:' is produced directly without recursing into the written sublist.
+// (The written sublist will have a separate collectDesignators() call later).
+// Recursion with Prefix='.b' and Sem = {3, ImplicitValue} produces '.b.x:'.
+void collectDesignators(const InitListExpr *Sem,
+                        llvm::DenseMap<SourceLocation, std::string> &Out,
+                        const llvm::DenseSet<SourceLocation> &NestedBraces,
+                        std::string &Prefix) {
+  if (!Sem || Sem->isTransparent())
+    return;
+  assert(Sem->isSemanticForm());
+
+  // The elements of the semantic form all correspond to direct subobjects of
+  // the aggregate type. `Fields` iterates over these subobject names.
+  AggregateDesignatorNames Fields(Sem->getType());
+  if (!Fields)
+    return;
+  for (const Expr *Init : Sem->inits()) {
+    auto Next = llvm::make_scope_exit([&, Size(Prefix.size())] {
+      Fields.next();       // Always advance to the next subobject name.
+      Prefix.resize(Size); // Erase any designator we appended.
+    });
+    if (llvm::isa<ImplicitValueInitExpr>(Init))
+      continue; // a "hole" for a subobject that was not explicitly initialized
+
+    const auto *BraceElidedSubobject = llvm::dyn_cast<InitListExpr>(Init);
+    if (BraceElidedSubobject &&
+        NestedBraces.contains(BraceElidedSubobject->getLBraceLoc()))
+      BraceElidedSubobject = nullptr; // there were braces!
+
+    if (!Fields.append(Prefix, BraceElidedSubobject != nullptr))
+      continue; // no designator available for this subobject
+    if (BraceElidedSubobject) {
+      // If the braces were elided, this aggregate subobject is initialized
+      // inline in the same syntactic list.
+      // Descend into the semantic list describing the subobject.
+      // (NestedBraces are still correct, they're from the same syntactic list).
+      collectDesignators(BraceElidedSubobject, Out, NestedBraces, Prefix);
+      continue;
+    }
+    Out.try_emplace(Init->getBeginLoc(), Prefix);
+  }
+}
+
+// Get designators describing the elements of a (syntactic) init list.
+// This does not produce designators for any explicitly-written nested lists.
+llvm::DenseMap<SourceLocation, std::string>
+getDesignators(const InitListExpr *Syn) {
+  assert(Syn->isSyntacticForm());
+
+  // collectDesignators needs to know which InitListExprs in the semantic tree
+  // were actually written, but InitListExpr::isExplicit() lies.
+  // Instead, record where braces of sub-init-lists occur in the syntactic form.
+  llvm::DenseSet<SourceLocation> NestedBraces;
+  for (const Expr *Init : Syn->inits())
+    if (auto *Nested = llvm::dyn_cast<InitListExpr>(Init))
+      NestedBraces.insert(Nested->getLBraceLoc());
+
+  // Traverse the semantic form to find the designators.
+  // We use their SourceLocation to correlate with the syntactic form later.
+  llvm::DenseMap<SourceLocation, std::string> Designators;
+  std::string EmptyPrefix;
+  collectDesignators(Syn->isSemanticForm() ? Syn : Syn->getSemanticForm(),
+                     Designators, NestedBraces, EmptyPrefix);
+  return Designators;
+}
+
 class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
 public:
   InlayHintVisitor(std::vector<InlayHint> &Results, ParsedAST &AST,
                    const Config &Cfg, llvm::Optional<Range> RestrictRange)
       : Results(Results), AST(AST.getASTContext()), Cfg(Cfg),
         RestrictRange(std::move(RestrictRange)),
         MainFileID(AST.getSourceManager().getMainFileID()),
         Resolver(AST.getHeuristicResolver()),
if (D->getType()->getContainedAutoType()) {
         // Alternatively, we could place the hint on the `auto`
         // (and then just print the type deduced for the `auto`).
         addTypeHint(D->getLocation(), D->getType(), /*Prefix=*/": ");
       }
     }
     return true;
   }
 
+  bool VisitInitListExpr(InitListExpr *Syn) {
+    // We receive the syntactic form here (shouldVisitImplicitCode() is false).
+    // This is the one we will ultimately attach designators to.
+    // It may have subobject initializers inlined without braces. The *semantic*
+    // form of the init-list has nested init-lists for these.
+    // getDesignators will look at the semantic form to determine the labels.
+    assert(Syn->isSyntacticForm() && "RAV should not visit implicit code!");
+    if (!Cfg.InlayHints.Designators)
+      return true;
+    if (Syn->isIdiomaticZeroInitializer(AST.getLangOpts()))
+      return true;
+    llvm::DenseMap<SourceLocation, std::string> Designators =
+        getDesignators(Syn);
+    for (const Expr *Init : Syn->inits()) {
+      if (llvm::isa<DesignatedInitExpr>(Init))
+        continue;
+      auto It = Designators.find(Init->getBeginLoc());
+      if (It != Designators.end() &&
+          !isPrecededByParamNameComment(Init, It->second))
+        addDesignatorHint(Init->getSourceRange(), It->second);
+    }
+    return true;
+  }
+
   // FIXME: Handle RecoveryExpr to try to hint some invalid calls.
 
 private:
   using NameVec = SmallVector<StringRef, 8>;
 
   // The purpose of Anchor is to deal with macros. It should be the call's
   // opening or closing parenthesis or brace. (Always using the opening would
   // make more sense but CallExpr only exposes the closing.) We heuristically
if (Decomposed.first != MainFileID)
       return false;
 
     StringRef SourcePrefix = MainFileBuf.substr(0, Decomposed.second);
     // Allow whitespace between comment and expression.
     SourcePrefix = SourcePrefix.rtrim();
     // Check for comment ending.
     if (!SourcePrefix.consume_back("*/"))
       return false;
-    // Allow whitespace and "=" at end of comment.
-    SourcePrefix = SourcePrefix.rtrim().rtrim('=').rtrim();
+    // Ignore some punctuation and whitespace around comment.
+    // In particular this allows designators to match nicely.
+    llvm::StringLiteral IgnoreChars = " =.";
+    SourcePrefix = SourcePrefix.rtrim(IgnoreChars);
+    ParamName = ParamName.trim(IgnoreChars);
     // Other than that, the comment must contain exactly ParamName.
     if (!SourcePrefix.consume_back(ParamName))
       return false;
-    return SourcePrefix.rtrim().endswith("/*");
+    SourcePrefix = SourcePrefix.rtrim(IgnoreChars);
+    return SourcePrefix.endswith("/*");
   }
 
   // If "E" spells a single unqualified identifier, return that name.
   // Otherwise, return an empty string.
   static StringRef getSpelledIdentifier(const Expr *E) {
     E = E->IgnoreUnlessSpelledInSource();
 
     if (auto *DRE = dyn_cast<DeclRefExpr>(E))
#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);
 #undef CHECK_KIND
     }
 
     auto FileRange =
         toHalfOpenFileRange(AST.getSourceManager(), AST.getLangOpts(), R);
     if (!FileRange)
       return;
     Range LSPRange{
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=*/"");
   }
 
+  void addDesignatorHint(SourceRange R, llvm::StringRef Text) {
+    addInlayHint(R, HintSide::Left, InlayHintKind::DesignatorHint,
+                 /*Prefix=*/"", Text, /*Suffix=*/"=");
+  }
+
   std::vector<InlayHint> &Results;
   ASTContext &AST;
   const Config &Cfg;
   llvm::Optional<Range> RestrictRange;
   FileID MainFileID;
   StringRef MainFileBuf;
   const HeuristicResolver *Resolver;
   // We want to suppress default template arguments, but otherwise print

clang-tools-extra/clangd/Protocol.h

enum class InlayHintKind {
   ParameterHint,
 
   /// The hint corresponds to information about a deduced type.
   /// An example of a type hint is a hint in this position:
   ///    auto var ^ = expr;
   /// which shows the deduced type of the variable.
   TypeHint,
 
+  /// 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,
+
   /// 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);
 

clang-tools-extra/clangd/Protocol.cpp

 }
 
 llvm::json::Value toJSON(InlayHintKind K) {
   switch (K) {
   case InlayHintKind::ParameterHint:
     return "parameter";
   case InlayHintKind::TypeHint:
     return "type";
+  case InlayHintKind::DesignatorHint:
+    return "designator";
   }
   llvm_unreachable("Unknown clang.clangd.InlayHintKind");
 }
 
 llvm::json::Value toJSON(const InlayHint &H) {
   return llvm::json::Object{{"position", H.position},
                             {"range", H.range},
                             {"kind", H.kind},

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/Support/ScopedPrinter.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 
-std::ostream &operator<<(std::ostream &Stream, const InlayHint &Hint) {
-  return Stream << Hint.label;
+llvm::raw_ostream &operator<<(llvm::raw_ostream &Stream,
+                              const InlayHint &Hint) {
+  return Stream << Hint.label << "@" << Hint.range;
 }
 
 namespace {
 
 using ::testing::ElementsAre;
 using ::testing::IsEmpty;
-using ::testing::UnorderedElementsAre;
 
 std::vector<InlayHint> hintsOfKind(ParsedAST &AST, InlayHintKind Kind) {
   std::vector<InlayHint> Result;
   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,
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &Stream,
                                        const ExpectedHint &Hint) {
-    return Stream << Hint.RangeName << ": " << Hint.Label;
+    return Stream << Hint.Label << "@$" << Hint.RangeName;
   }
 };
 
-MATCHER_P2(HintMatcher, Expected, Code, "") {
-  return arg.label == Expected.Label &&
-         arg.range == Code.range(Expected.RangeName) &&
-         arg.position ==
-             ((Expected.Side == Left) ? arg.range.start : arg.range.end);
+MATCHER_P2(HintMatcher, Expected, Code, llvm::to_string(Expected)) {
+  if (arg.label != Expected.Label) {
+    *result_listener << "label is " << arg.label;
+    return false;
+  }
+  if (arg.range != Code.range(Expected.RangeName)) {
+    *result_listener << "range is " << arg.label << " but $"
+                     << Expected.RangeName << " is "
+                     << llvm::to_string(Code.range(Expected.RangeName));
+    return false;
+  }
+  return true;
 }
 
 MATCHER_P(labelIs, Label, "") { return arg.label == Label; }
 
 Config noHintsConfig() {
   Config C;
   C.InlayHints.Parameters = false;
   C.InlayHints.DeducedTypes = false;
+  C.InlayHints.Designators = false;
   return C;
 }
 
 template <typename... ExpectedHints>
 void assertHints(InlayHintKind Kind, llvm::StringRef AnnotatedSource,
                  ExpectedHints... Expected) {
   Annotations Source(AnnotatedSource);
   TestTU TU = TestTU::withCode(Source.code());

 
 template <typename... ExpectedHints>
 void assertTypeHints(llvm::StringRef AnnotatedSource,
                      ExpectedHints... Expected) {
   ignore(Expected.Side = Right...);
   assertHints(InlayHintKind::TypeHint, 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...);
+}
+
 TEST(ParameterHints, Smoke) {
   assertParameterHints(R"cpp(
     void foo(int param);
     void bar() {
       foo($param[[42]]);
     }
   )cpp",
                        ExpectedHint{"param: ", "param"});
void foo() {
       auto $var[[var]] = 42;
     }
     template void foo<int>();
     template void foo<float>();
   )cpp",
                   ExpectedHint{": int", "var"});
 }
 
+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]]};
+  )cpp",
+                        ExpectedHint{".x=", "x"}, ExpectedHint{".y=", "y"},
+                        ExpectedHint{"[0]=", "0"}, ExpectedHint{"[1]=", "1"});
+}
+
+TEST(DesignatorHints, Nested) {
+  assertDesignatorHints(R"cpp(
+    struct Inner { int x, y; };
+    struct Outer { Inner a, b; };
+    Outer o{ $a[[{ $x[[1]], $y[[2]] }]], $bx[[3]] };
+  )cpp",
+                        ExpectedHint{".a=", "a"}, ExpectedHint{".x=", "x"},
+                        ExpectedHint{".y=", "y"}, ExpectedHint{".b.x=", "bx"});
+}
+
+TEST(DesignatorHints, AnonymousRecord) {
+  assertDesignatorHints(R"cpp(
+    struct S {
+      union {
+        struct {
+          struct {
+            int y;
+          };
+        } x;
+      };
+    };
+    S s{$xy[[42]]};
+  )cpp",
+                        ExpectedHint{".x.y=", "xy"});
+}
+
+TEST(DesignatorHints, Suppression) {
+  assertDesignatorHints(R"cpp(
+    struct Point { int a, b, c, d, e, f, g, h; };
+    Point p{/*a=*/1, .c=2, /* .d = */3, $e[[4]]};
+  )cpp",
+                        ExpectedHint{".e=", "e"});
+}
+
+TEST(DesignatorHints, StdArray) {
+  // Designators for std::array should be [0] rather than .__elements[0].
+  // While technically correct, the designator is useless and horrible to read.
+  assertDesignatorHints(R"cpp(
+    template <typename T, int N> struct Array { T __elements[N]; };
+    Array<int, 2> x = {$0[[0]], $1[[1]]};
+  )cpp",
+                        ExpectedHint{"[0]=", "0"}, ExpectedHint{"[1]=", "1"});
+}
+
+TEST(DesignatorHints, OnlyAggregateInit) {
+  assertDesignatorHints(R"cpp(
+    struct Copyable { int x; } c;
+    Copyable d{c};
+
+    struct Constructible { Constructible(int x); };
+    Constructible x{42};
+  )cpp" /*no designator hints expected (but param hints!)*/);
+}
+
 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();