xref: /llvm-project/clang/lib/ExtractAPI/DeclarationFragments.cpp (revision e42b799bb28815431f2c5a95f7e13fde3f1b36a1) 
1 //===- ExtractAPI/DeclarationFragments.cpp ----------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// This file implements Declaration Fragments related classes.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/ExtractAPI/DeclarationFragments.h"
15 #include "clang/AST/ASTFwd.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/TemplateBase.h"
19 #include "clang/AST/TemplateName.h"
20 #include "clang/AST/Type.h"
21 #include "clang/AST/TypeLoc.h"
22 #include "clang/ExtractAPI/TypedefUnderlyingTypeResolver.h"
23 #include "clang/Index/USRGeneration.h"
24 #include "llvm/ADT/StringSwitch.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/raw_ostream.h"
27 #include <optional>
28 
29 using namespace clang::extractapi;
30 using namespace llvm;
31 
32 namespace {
33 
34 void findTypeLocForBlockDecl(const clang::TypeSourceInfo *TSInfo,
35                              clang::FunctionTypeLoc &Block,
36                              clang::FunctionProtoTypeLoc &BlockProto) {
37   if (!TSInfo)
38     return;
39 
40   clang::TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
41   while (true) {
42     // Look through qualified types
43     if (auto QualifiedTL = TL.getAs<clang::QualifiedTypeLoc>()) {
44       TL = QualifiedTL.getUnqualifiedLoc();
45       continue;
46     }
47 
48     if (auto AttrTL = TL.getAs<clang::AttributedTypeLoc>()) {
49       TL = AttrTL.getModifiedLoc();
50       continue;
51     }
52 
53     // Try to get the function prototype behind the block pointer type,
54     // then we're done.
55     if (auto BlockPtr = TL.getAs<clang::BlockPointerTypeLoc>()) {
56       TL = BlockPtr.getPointeeLoc().IgnoreParens();
57       Block = TL.getAs<clang::FunctionTypeLoc>();
58       BlockProto = TL.getAs<clang::FunctionProtoTypeLoc>();
59     }
60     break;
61   }
62 }
63 
64 } // namespace
65 
66 DeclarationFragments &
67 DeclarationFragments::appendUnduplicatedTextCharacter(char Character) {
68   if (!Fragments.empty()) {
69     Fragment &Last = Fragments.back();
70     if (Last.Kind == FragmentKind::Text) {
71       // Merge the extra space into the last fragment if the last fragment is
72       // also text.
73       if (Last.Spelling.back() != Character) { // avoid duplicates at end
74         Last.Spelling.push_back(Character);
75       }
76     } else {
77       append("", FragmentKind::Text);
78       Fragments.back().Spelling.push_back(Character);
79     }
80   }
81 
82   return *this;
83 }
84 
85 DeclarationFragments &DeclarationFragments::appendSpace() {
86   return appendUnduplicatedTextCharacter(' ');
87 }
88 
89 DeclarationFragments &DeclarationFragments::appendSemicolon() {
90   return appendUnduplicatedTextCharacter(';');
91 }
92 
93 DeclarationFragments &DeclarationFragments::removeTrailingSemicolon() {
94   if (Fragments.empty())
95     return *this;
96 
97   Fragment &Last = Fragments.back();
98   if (Last.Kind == FragmentKind::Text && Last.Spelling.back() == ';')
99     Last.Spelling.pop_back();
100 
101   return *this;
102 }
103 
104 StringRef DeclarationFragments::getFragmentKindString(
105     DeclarationFragments::FragmentKind Kind) {
106   switch (Kind) {
107   case DeclarationFragments::FragmentKind::None:
108     return "none";
109   case DeclarationFragments::FragmentKind::Keyword:
110     return "keyword";
111   case DeclarationFragments::FragmentKind::Attribute:
112     return "attribute";
113   case DeclarationFragments::FragmentKind::NumberLiteral:
114     return "number";
115   case DeclarationFragments::FragmentKind::StringLiteral:
116     return "string";
117   case DeclarationFragments::FragmentKind::Identifier:
118     return "identifier";
119   case DeclarationFragments::FragmentKind::TypeIdentifier:
120     return "typeIdentifier";
121   case DeclarationFragments::FragmentKind::GenericParameter:
122     return "genericParameter";
123   case DeclarationFragments::FragmentKind::ExternalParam:
124     return "externalParam";
125   case DeclarationFragments::FragmentKind::InternalParam:
126     return "internalParam";
127   case DeclarationFragments::FragmentKind::Text:
128     return "text";
129   }
130 
131   llvm_unreachable("Unhandled FragmentKind");
132 }
133 
134 DeclarationFragments::FragmentKind
135 DeclarationFragments::parseFragmentKindFromString(StringRef S) {
136   return llvm::StringSwitch<FragmentKind>(S)
137       .Case("keyword", DeclarationFragments::FragmentKind::Keyword)
138       .Case("attribute", DeclarationFragments::FragmentKind::Attribute)
139       .Case("number", DeclarationFragments::FragmentKind::NumberLiteral)
140       .Case("string", DeclarationFragments::FragmentKind::StringLiteral)
141       .Case("identifier", DeclarationFragments::FragmentKind::Identifier)
142       .Case("typeIdentifier",
143             DeclarationFragments::FragmentKind::TypeIdentifier)
144       .Case("genericParameter",
145             DeclarationFragments::FragmentKind::GenericParameter)
146       .Case("internalParam", DeclarationFragments::FragmentKind::InternalParam)
147       .Case("externalParam", DeclarationFragments::FragmentKind::ExternalParam)
148       .Case("text", DeclarationFragments::FragmentKind::Text)
149       .Default(DeclarationFragments::FragmentKind::None);
150 }
151 
152 DeclarationFragments DeclarationFragments::getExceptionSpecificationString(
153     ExceptionSpecificationType ExceptionSpec) {
154   DeclarationFragments Fragments;
155   switch (ExceptionSpec) {
156   case ExceptionSpecificationType::EST_None:
157     return Fragments;
158   case ExceptionSpecificationType::EST_DynamicNone:
159     return Fragments.append(" ", DeclarationFragments::FragmentKind::Text)
160         .append("throw", DeclarationFragments::FragmentKind::Keyword)
161         .append("(", DeclarationFragments::FragmentKind::Text)
162         .append(")", DeclarationFragments::FragmentKind::Text);
163   case ExceptionSpecificationType::EST_Dynamic:
164     // FIXME: throw(int), get types of inner expression
165     return Fragments;
166   case ExceptionSpecificationType::EST_BasicNoexcept:
167     return Fragments.append(" ", DeclarationFragments::FragmentKind::Text)
168         .append("noexcept", DeclarationFragments::FragmentKind::Keyword);
169   case ExceptionSpecificationType::EST_DependentNoexcept:
170     // FIXME: throw(conditional-expression), get expression
171     break;
172   case ExceptionSpecificationType::EST_NoexceptFalse:
173     return Fragments.append(" ", DeclarationFragments::FragmentKind::Text)
174         .append("noexcept", DeclarationFragments::FragmentKind::Keyword)
175         .append("(", DeclarationFragments::FragmentKind::Text)
176         .append("false", DeclarationFragments::FragmentKind::Keyword)
177         .append(")", DeclarationFragments::FragmentKind::Text);
178   case ExceptionSpecificationType::EST_NoexceptTrue:
179     return Fragments.append(" ", DeclarationFragments::FragmentKind::Text)
180         .append("noexcept", DeclarationFragments::FragmentKind::Keyword)
181         .append("(", DeclarationFragments::FragmentKind::Text)
182         .append("true", DeclarationFragments::FragmentKind::Keyword)
183         .append(")", DeclarationFragments::FragmentKind::Text);
184   default:
185     return Fragments;
186   }
187 
188   llvm_unreachable("Unhandled exception specification");
189 }
190 
191 DeclarationFragments
192 DeclarationFragments::getStructureTypeFragment(const RecordDecl *Record) {
193   DeclarationFragments Fragments;
194   if (Record->isStruct())
195     Fragments.append("struct", DeclarationFragments::FragmentKind::Keyword);
196   else if (Record->isUnion())
197     Fragments.append("union", DeclarationFragments::FragmentKind::Keyword);
198   else
199     Fragments.append("class", DeclarationFragments::FragmentKind::Keyword);
200 
201   return Fragments;
202 }
203 
204 // NNS stores C++ nested name specifiers, which are prefixes to qualified names.
205 // Build declaration fragments for NNS recursively so that we have the USR for
206 // every part in a qualified name, and also leaves the actual underlying type
207 // cleaner for its own fragment.
208 DeclarationFragments
209 DeclarationFragmentsBuilder::getFragmentsForNNS(const NestedNameSpecifier *NNS,
210                                                 ASTContext &Context,
211                                                 DeclarationFragments &After) {
212   DeclarationFragments Fragments;
213   if (NNS->getPrefix())
214     Fragments.append(getFragmentsForNNS(NNS->getPrefix(), Context, After));
215 
216   switch (NNS->getKind()) {
217   case NestedNameSpecifier::Identifier:
218     Fragments.append(NNS->getAsIdentifier()->getName(),
219                      DeclarationFragments::FragmentKind::Identifier);
220     break;
221 
222   case NestedNameSpecifier::Namespace: {
223     const NamespaceDecl *NS = NNS->getAsNamespace();
224     if (NS->isAnonymousNamespace())
225       return Fragments;
226     SmallString<128> USR;
227     index::generateUSRForDecl(NS, USR);
228     Fragments.append(NS->getName(),
229                      DeclarationFragments::FragmentKind::Identifier, USR, NS);
230     break;
231   }
232 
233   case NestedNameSpecifier::NamespaceAlias: {
234     const NamespaceAliasDecl *Alias = NNS->getAsNamespaceAlias();
235     SmallString<128> USR;
236     index::generateUSRForDecl(Alias, USR);
237     Fragments.append(Alias->getName(),
238                      DeclarationFragments::FragmentKind::Identifier, USR,
239                      Alias);
240     break;
241   }
242 
243   case NestedNameSpecifier::Global:
244     // The global specifier `::` at the beginning. No stored value.
245     break;
246 
247   case NestedNameSpecifier::Super:
248     // Microsoft's `__super` specifier.
249     Fragments.append("__super", DeclarationFragments::FragmentKind::Keyword);
250     break;
251 
252   case NestedNameSpecifier::TypeSpecWithTemplate:
253     // A type prefixed by the `template` keyword.
254     Fragments.append("template", DeclarationFragments::FragmentKind::Keyword);
255     Fragments.appendSpace();
256     // Fallthrough after adding the keyword to handle the actual type.
257     [[fallthrough]];
258 
259   case NestedNameSpecifier::TypeSpec: {
260     const Type *T = NNS->getAsType();
261     // FIXME: Handle C++ template specialization type
262     Fragments.append(getFragmentsForType(T, Context, After));
263     break;
264   }
265   }
266 
267   // Add the separator text `::` for this segment.
268   return Fragments.append("::", DeclarationFragments::FragmentKind::Text);
269 }
270 
271 // Recursively build the declaration fragments for an underlying `Type` with
272 // qualifiers removed.
273 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForType(
274     const Type *T, ASTContext &Context, DeclarationFragments &After) {
275   assert(T && "invalid type");
276 
277   DeclarationFragments Fragments;
278 
279   // An ElaboratedType is a sugar for types that are referred to using an
280   // elaborated keyword, e.g., `struct S`, `enum E`, or (in C++) via a
281   // qualified name, e.g., `N::M::type`, or both.
282   if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(T)) {
283     ElaboratedTypeKeyword Keyword = ET->getKeyword();
284     if (Keyword != ElaboratedTypeKeyword::None) {
285       Fragments
286           .append(ElaboratedType::getKeywordName(Keyword),
287                   DeclarationFragments::FragmentKind::Keyword)
288           .appendSpace();
289     }
290 
291     if (const NestedNameSpecifier *NNS = ET->getQualifier())
292       Fragments.append(getFragmentsForNNS(NNS, Context, After));
293 
294     // After handling the elaborated keyword or qualified name, build
295     // declaration fragments for the desugared underlying type.
296     return Fragments.append(getFragmentsForType(ET->desugar(), Context, After));
297   }
298 
299   // If the type is a typedefed type, get the underlying TypedefNameDecl for a
300   // direct reference to the typedef instead of the wrapped type.
301 
302   // 'id' type is a typedef for an ObjCObjectPointerType
303   //  we treat it as a typedef
304   if (const TypedefType *TypedefTy = dyn_cast<TypedefType>(T)) {
305     const TypedefNameDecl *Decl = TypedefTy->getDecl();
306     TypedefUnderlyingTypeResolver TypedefResolver(Context);
307     std::string USR = TypedefResolver.getUSRForType(QualType(T, 0));
308 
309     if (T->isObjCIdType()) {
310       return Fragments.append(Decl->getName(),
311                               DeclarationFragments::FragmentKind::Keyword);
312     }
313 
314     return Fragments.append(
315         Decl->getName(), DeclarationFragments::FragmentKind::TypeIdentifier,
316         USR, TypedefResolver.getUnderlyingTypeDecl(QualType(T, 0)));
317   }
318 
319   // Declaration fragments of a pointer type is the declaration fragments of
320   // the pointee type followed by a `*`,
321   if (T->isPointerType() && !T->isFunctionPointerType())
322     return Fragments
323         .append(getFragmentsForType(T->getPointeeType(), Context, After))
324         .append(" *", DeclarationFragments::FragmentKind::Text);
325 
326   // For Objective-C `id` and `Class` pointers
327   // we do not spell out the `*`.
328   if (T->isObjCObjectPointerType() &&
329       !T->getAs<ObjCObjectPointerType>()->isObjCIdOrClassType()) {
330 
331     Fragments.append(getFragmentsForType(T->getPointeeType(), Context, After));
332 
333     // id<protocol> is an qualified id type
334     // id<protocol>* is not an qualified id type
335     if (!T->getAs<ObjCObjectPointerType>()->isObjCQualifiedIdType()) {
336       Fragments.append(" *", DeclarationFragments::FragmentKind::Text);
337     }
338 
339     return Fragments;
340   }
341 
342   // Declaration fragments of a lvalue reference type is the declaration
343   // fragments of the underlying type followed by a `&`.
344   if (const LValueReferenceType *LRT = dyn_cast<LValueReferenceType>(T))
345     return Fragments
346         .append(
347             getFragmentsForType(LRT->getPointeeTypeAsWritten(), Context, After))
348         .append(" &", DeclarationFragments::FragmentKind::Text);
349 
350   // Declaration fragments of a rvalue reference type is the declaration
351   // fragments of the underlying type followed by a `&&`.
352   if (const RValueReferenceType *RRT = dyn_cast<RValueReferenceType>(T))
353     return Fragments
354         .append(
355             getFragmentsForType(RRT->getPointeeTypeAsWritten(), Context, After))
356         .append(" &&", DeclarationFragments::FragmentKind::Text);
357 
358   // Declaration fragments of an array-typed variable have two parts:
359   // 1. the element type of the array that appears before the variable name;
360   // 2. array brackets `[(0-9)?]` that appear after the variable name.
361   if (const ArrayType *AT = T->getAsArrayTypeUnsafe()) {
362     // Build the "after" part first because the inner element type might also
363     // be an array-type. For example `int matrix[3][4]` which has a type of
364     // "(array 3 of (array 4 of ints))."
365     // Push the array size part first to make sure they are in the right order.
366     After.append("[", DeclarationFragments::FragmentKind::Text);
367 
368     switch (AT->getSizeModifier()) {
369     case ArraySizeModifier::Normal:
370       break;
371     case ArraySizeModifier::Static:
372       Fragments.append("static", DeclarationFragments::FragmentKind::Keyword);
373       break;
374     case ArraySizeModifier::Star:
375       Fragments.append("*", DeclarationFragments::FragmentKind::Text);
376       break;
377     }
378 
379     if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) {
380       // FIXME: right now this would evaluate any expressions/macros written in
381       // the original source to concrete values. For example
382       // `int nums[MAX]` -> `int nums[100]`
383       // `char *str[5 + 1]` -> `char *str[6]`
384       SmallString<128> Size;
385       CAT->getSize().toStringUnsigned(Size);
386       After.append(Size, DeclarationFragments::FragmentKind::NumberLiteral);
387     }
388 
389     After.append("]", DeclarationFragments::FragmentKind::Text);
390 
391     return Fragments.append(
392         getFragmentsForType(AT->getElementType(), Context, After));
393   }
394 
395   if (const TemplateSpecializationType *TemplSpecTy =
396           dyn_cast<TemplateSpecializationType>(T)) {
397     const auto TemplName = TemplSpecTy->getTemplateName();
398     std::string Str;
399     raw_string_ostream Stream(Str);
400     TemplName.print(Stream, Context.getPrintingPolicy(),
401                     TemplateName::Qualified::AsWritten);
402     SmallString<64> USR("");
403     if (const auto *TemplDecl = TemplName.getAsTemplateDecl())
404       index::generateUSRForDecl(TemplDecl, USR);
405 
406     return Fragments
407         .append(Str, DeclarationFragments::FragmentKind::TypeIdentifier, USR)
408         .append("<", DeclarationFragments::FragmentKind::Text)
409         .append(getFragmentsForTemplateArguments(
410             TemplSpecTy->template_arguments(), Context, std::nullopt))
411         .append(">", DeclarationFragments::FragmentKind::Text);
412   }
413 
414   // Everything we care about has been handled now, reduce to the canonical
415   // unqualified base type.
416   QualType Base = T->getCanonicalTypeUnqualified();
417 
418   // If the base type is a TagType (struct/interface/union/class/enum), let's
419   // get the underlying Decl for better names and USRs.
420   if (const TagType *TagTy = dyn_cast<TagType>(Base)) {
421     const TagDecl *Decl = TagTy->getDecl();
422     // Anonymous decl, skip this fragment.
423     if (Decl->getName().empty())
424       return Fragments.append("{ ... }",
425                               DeclarationFragments::FragmentKind::Text);
426     SmallString<128> TagUSR;
427     clang::index::generateUSRForDecl(Decl, TagUSR);
428     return Fragments.append(Decl->getName(),
429                             DeclarationFragments::FragmentKind::TypeIdentifier,
430                             TagUSR, Decl);
431   }
432 
433   // If the base type is an ObjCInterfaceType, use the underlying
434   // ObjCInterfaceDecl for the true USR.
435   if (const auto *ObjCIT = dyn_cast<ObjCInterfaceType>(Base)) {
436     const auto *Decl = ObjCIT->getDecl();
437     SmallString<128> USR;
438     index::generateUSRForDecl(Decl, USR);
439     return Fragments.append(Decl->getName(),
440                             DeclarationFragments::FragmentKind::TypeIdentifier,
441                             USR, Decl);
442   }
443 
444   // Default fragment builder for other kinds of types (BuiltinType etc.)
445   SmallString<128> USR;
446   clang::index::generateUSRForType(Base, Context, USR);
447   Fragments.append(Base.getAsString(),
448                    DeclarationFragments::FragmentKind::TypeIdentifier, USR);
449 
450   return Fragments;
451 }
452 
453 DeclarationFragments
454 DeclarationFragmentsBuilder::getFragmentsForQualifiers(const Qualifiers Quals) {
455   DeclarationFragments Fragments;
456   if (Quals.hasConst())
457     Fragments.append("const", DeclarationFragments::FragmentKind::Keyword);
458   if (Quals.hasVolatile())
459     Fragments.append("volatile", DeclarationFragments::FragmentKind::Keyword);
460   if (Quals.hasRestrict())
461     Fragments.append("restrict", DeclarationFragments::FragmentKind::Keyword);
462 
463   return Fragments;
464 }
465 
466 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForType(
467     const QualType QT, ASTContext &Context, DeclarationFragments &After) {
468   assert(!QT.isNull() && "invalid type");
469 
470   if (const ParenType *PT = dyn_cast<ParenType>(QT)) {
471     After.append(")", DeclarationFragments::FragmentKind::Text);
472     return getFragmentsForType(PT->getInnerType(), Context, After)
473         .append("(", DeclarationFragments::FragmentKind::Text);
474   }
475 
476   const SplitQualType SQT = QT.split();
477   DeclarationFragments QualsFragments = getFragmentsForQualifiers(SQT.Quals),
478                        TypeFragments =
479                            getFragmentsForType(SQT.Ty, Context, After);
480   if (QT.getAsString() == "_Bool")
481     TypeFragments.replace("bool", 0);
482 
483   if (QualsFragments.getFragments().empty())
484     return TypeFragments;
485 
486   // Use east qualifier for pointer types
487   // For example:
488   // ```
489   // int *   const
490   // ^----   ^----
491   //  type    qualifier
492   // ^-----------------
493   //  const pointer to int
494   // ```
495   // should not be reconstructed as
496   // ```
497   // const       int       *
498   // ^----       ^--
499   //  qualifier   type
500   // ^----------------     ^
501   //  pointer to const int
502   // ```
503   if (SQT.Ty->isAnyPointerType())
504     return TypeFragments.appendSpace().append(std::move(QualsFragments));
505 
506   return QualsFragments.appendSpace().append(std::move(TypeFragments));
507 }
508 
509 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForNamespace(
510     const NamespaceDecl *Decl) {
511   DeclarationFragments Fragments;
512   Fragments.append("namespace", DeclarationFragments::FragmentKind::Keyword);
513   if (!Decl->isAnonymousNamespace())
514     Fragments.appendSpace().append(
515         Decl->getName(), DeclarationFragments::FragmentKind::Identifier);
516   return Fragments.appendSemicolon();
517 }
518 
519 DeclarationFragments
520 DeclarationFragmentsBuilder::getFragmentsForVar(const VarDecl *Var) {
521   DeclarationFragments Fragments;
522   if (Var->isConstexpr())
523     Fragments.append("constexpr", DeclarationFragments::FragmentKind::Keyword)
524         .appendSpace();
525 
526   StorageClass SC = Var->getStorageClass();
527   if (SC != SC_None)
528     Fragments
529         .append(VarDecl::getStorageClassSpecifierString(SC),
530                 DeclarationFragments::FragmentKind::Keyword)
531         .appendSpace();
532 
533   // Capture potential fragments that needs to be placed after the variable name
534   // ```
535   // int nums[5];
536   // char (*ptr_to_array)[6];
537   // ```
538   DeclarationFragments After;
539   FunctionTypeLoc BlockLoc;
540   FunctionProtoTypeLoc BlockProtoLoc;
541   findTypeLocForBlockDecl(Var->getTypeSourceInfo(), BlockLoc, BlockProtoLoc);
542 
543   if (!BlockLoc) {
544     QualType T = Var->getTypeSourceInfo()
545                      ? Var->getTypeSourceInfo()->getType()
546                      : Var->getASTContext().getUnqualifiedObjCPointerType(
547                            Var->getType());
548 
549     Fragments.append(getFragmentsForType(T, Var->getASTContext(), After))
550         .appendSpace();
551   } else {
552     Fragments.append(getFragmentsForBlock(Var, BlockLoc, BlockProtoLoc, After));
553   }
554 
555   return Fragments
556       .append(Var->getName(), DeclarationFragments::FragmentKind::Identifier)
557       .append(std::move(After))
558       .appendSemicolon();
559 }
560 
561 DeclarationFragments
562 DeclarationFragmentsBuilder::getFragmentsForVarTemplate(const VarDecl *Var) {
563   DeclarationFragments Fragments;
564   if (Var->isConstexpr())
565     Fragments.append("constexpr", DeclarationFragments::FragmentKind::Keyword)
566         .appendSpace();
567   QualType T =
568       Var->getTypeSourceInfo()
569           ? Var->getTypeSourceInfo()->getType()
570           : Var->getASTContext().getUnqualifiedObjCPointerType(Var->getType());
571 
572   // Might be a member, so might be static.
573   if (Var->isStaticDataMember())
574     Fragments.append("static", DeclarationFragments::FragmentKind::Keyword)
575         .appendSpace();
576 
577   DeclarationFragments After;
578   DeclarationFragments ArgumentFragment =
579       getFragmentsForType(T, Var->getASTContext(), After);
580   if (StringRef(ArgumentFragment.begin()->Spelling)
581           .starts_with("type-parameter")) {
582     std::string ProperArgName = T.getAsString();
583     ArgumentFragment.begin()->Spelling.swap(ProperArgName);
584   }
585   Fragments.append(std::move(ArgumentFragment))
586       .appendSpace()
587       .append(Var->getName(), DeclarationFragments::FragmentKind::Identifier)
588       .appendSemicolon();
589   return Fragments;
590 }
591 
592 DeclarationFragments
593 DeclarationFragmentsBuilder::getFragmentsForParam(const ParmVarDecl *Param) {
594   DeclarationFragments Fragments, After;
595 
596   auto *TSInfo = Param->getTypeSourceInfo();
597 
598   QualType T = TSInfo ? TSInfo->getType()
599                       : Param->getASTContext().getUnqualifiedObjCPointerType(
600                             Param->getType());
601 
602   FunctionTypeLoc BlockLoc;
603   FunctionProtoTypeLoc BlockProtoLoc;
604   findTypeLocForBlockDecl(TSInfo, BlockLoc, BlockProtoLoc);
605 
606   DeclarationFragments TypeFragments;
607   if (BlockLoc)
608     TypeFragments.append(
609         getFragmentsForBlock(Param, BlockLoc, BlockProtoLoc, After));
610   else
611     TypeFragments.append(getFragmentsForType(T, Param->getASTContext(), After));
612 
613   if (StringRef(TypeFragments.begin()->Spelling)
614           .starts_with("type-parameter")) {
615     std::string ProperArgName = Param->getOriginalType().getAsString();
616     TypeFragments.begin()->Spelling.swap(ProperArgName);
617   }
618 
619   if (Param->isObjCMethodParameter()) {
620     Fragments.append("(", DeclarationFragments::FragmentKind::Text)
621         .append(std::move(TypeFragments))
622         .append(std::move(After))
623         .append(") ", DeclarationFragments::FragmentKind::Text)
624         .append(Param->getName(),
625                 DeclarationFragments::FragmentKind::InternalParam);
626   } else {
627     Fragments.append(std::move(TypeFragments));
628     if (!T->isBlockPointerType())
629       Fragments.appendSpace();
630     Fragments
631         .append(Param->getName(),
632                 DeclarationFragments::FragmentKind::InternalParam)
633         .append(std::move(After));
634   }
635   return Fragments;
636 }
637 
638 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForBlock(
639     const NamedDecl *BlockDecl, FunctionTypeLoc &Block,
640     FunctionProtoTypeLoc &BlockProto, DeclarationFragments &After) {
641   DeclarationFragments Fragments;
642 
643   DeclarationFragments RetTyAfter;
644   auto ReturnValueFragment = getFragmentsForType(
645       Block.getTypePtr()->getReturnType(), BlockDecl->getASTContext(), After);
646 
647   Fragments.append(std::move(ReturnValueFragment))
648       .append(std::move(RetTyAfter))
649       .appendSpace()
650       .append("(^", DeclarationFragments::FragmentKind::Text);
651 
652   After.append(")", DeclarationFragments::FragmentKind::Text);
653   unsigned NumParams = Block.getNumParams();
654 
655   if (!BlockProto || NumParams == 0) {
656     if (BlockProto && BlockProto.getTypePtr()->isVariadic())
657       After.append("(...)", DeclarationFragments::FragmentKind::Text);
658     else
659       After.append("()", DeclarationFragments::FragmentKind::Text);
660   } else {
661     After.append("(", DeclarationFragments::FragmentKind::Text);
662     for (unsigned I = 0; I != NumParams; ++I) {
663       if (I)
664         After.append(", ", DeclarationFragments::FragmentKind::Text);
665       After.append(getFragmentsForParam(Block.getParam(I)));
666       if (I == NumParams - 1 && BlockProto.getTypePtr()->isVariadic())
667         After.append(", ...", DeclarationFragments::FragmentKind::Text);
668     }
669     After.append(")", DeclarationFragments::FragmentKind::Text);
670   }
671 
672   return Fragments;
673 }
674 
675 DeclarationFragments
676 DeclarationFragmentsBuilder::getFragmentsForFunction(const FunctionDecl *Func) {
677   DeclarationFragments Fragments;
678   switch (Func->getStorageClass()) {
679   case SC_None:
680   case SC_PrivateExtern:
681     break;
682   case SC_Extern:
683     Fragments.append("extern", DeclarationFragments::FragmentKind::Keyword)
684         .appendSpace();
685     break;
686   case SC_Static:
687     Fragments.append("static", DeclarationFragments::FragmentKind::Keyword)
688         .appendSpace();
689     break;
690   case SC_Auto:
691   case SC_Register:
692     llvm_unreachable("invalid for functions");
693   }
694   if (Func->isConsteval()) // if consteval, it is also constexpr
695     Fragments.append("consteval", DeclarationFragments::FragmentKind::Keyword)
696         .appendSpace();
697   else if (Func->isConstexpr())
698     Fragments.append("constexpr", DeclarationFragments::FragmentKind::Keyword)
699         .appendSpace();
700 
701   // FIXME: Is `after` actually needed here?
702   DeclarationFragments After;
703   auto ReturnValueFragment =
704       getFragmentsForType(Func->getReturnType(), Func->getASTContext(), After);
705   if (StringRef(ReturnValueFragment.begin()->Spelling)
706           .starts_with("type-parameter")) {
707     std::string ProperArgName = Func->getReturnType().getAsString();
708     ReturnValueFragment.begin()->Spelling.swap(ProperArgName);
709   }
710 
711   Fragments.append(std::move(ReturnValueFragment))
712       .appendSpace()
713       .append(Func->getName(), DeclarationFragments::FragmentKind::Identifier);
714 
715   if (Func->getTemplateSpecializationInfo()) {
716     Fragments.append("<", DeclarationFragments::FragmentKind::Text);
717 
718     for (unsigned i = 0, end = Func->getNumParams(); i != end; ++i) {
719       if (i)
720         Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
721       Fragments.append(
722           getFragmentsForType(Func->getParamDecl(i)->getType(),
723                               Func->getParamDecl(i)->getASTContext(), After));
724     }
725     Fragments.append(">", DeclarationFragments::FragmentKind::Text);
726   }
727   Fragments.append(std::move(After));
728 
729   Fragments.append("(", DeclarationFragments::FragmentKind::Text);
730   unsigned NumParams = Func->getNumParams();
731   for (unsigned i = 0; i != NumParams; ++i) {
732     if (i)
733       Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
734     Fragments.append(getFragmentsForParam(Func->getParamDecl(i)));
735   }
736 
737   if (Func->isVariadic()) {
738     if (NumParams > 0)
739       Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
740     Fragments.append("...", DeclarationFragments::FragmentKind::Text);
741   }
742   Fragments.append(")", DeclarationFragments::FragmentKind::Text);
743 
744   Fragments.append(DeclarationFragments::getExceptionSpecificationString(
745       Func->getExceptionSpecType()));
746 
747   return Fragments.appendSemicolon();
748 }
749 
750 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForEnumConstant(
751     const EnumConstantDecl *EnumConstDecl) {
752   DeclarationFragments Fragments;
753   return Fragments.append(EnumConstDecl->getName(),
754                           DeclarationFragments::FragmentKind::Identifier);
755 }
756 
757 DeclarationFragments
758 DeclarationFragmentsBuilder::getFragmentsForEnum(const EnumDecl *EnumDecl) {
759   if (const auto *TypedefNameDecl = EnumDecl->getTypedefNameForAnonDecl())
760     return getFragmentsForTypedef(TypedefNameDecl);
761 
762   DeclarationFragments Fragments, After;
763   Fragments.append("enum", DeclarationFragments::FragmentKind::Keyword);
764 
765   if (!EnumDecl->getName().empty())
766     Fragments.appendSpace().append(
767         EnumDecl->getName(), DeclarationFragments::FragmentKind::Identifier);
768 
769   QualType IntegerType = EnumDecl->getIntegerType();
770   if (!IntegerType.isNull())
771     Fragments.appendSpace()
772         .append(": ", DeclarationFragments::FragmentKind::Text)
773         .append(
774             getFragmentsForType(IntegerType, EnumDecl->getASTContext(), After))
775         .append(std::move(After));
776 
777   if (EnumDecl->getName().empty())
778     Fragments.appendSpace().append("{ ... }",
779                                    DeclarationFragments::FragmentKind::Text);
780 
781   return Fragments.appendSemicolon();
782 }
783 
784 DeclarationFragments
785 DeclarationFragmentsBuilder::getFragmentsForField(const FieldDecl *Field) {
786   DeclarationFragments After;
787   DeclarationFragments Fragments;
788   if (Field->isMutable())
789     Fragments.append("mutable", DeclarationFragments::FragmentKind::Keyword)
790         .appendSpace();
791   return Fragments
792       .append(
793           getFragmentsForType(Field->getType(), Field->getASTContext(), After))
794       .appendSpace()
795       .append(Field->getName(), DeclarationFragments::FragmentKind::Identifier)
796       .append(std::move(After))
797       .appendSemicolon();
798 }
799 
800 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForRecordDecl(
801     const RecordDecl *Record) {
802   if (const auto *TypedefNameDecl = Record->getTypedefNameForAnonDecl())
803     return getFragmentsForTypedef(TypedefNameDecl);
804 
805   DeclarationFragments Fragments;
806   if (Record->isUnion())
807     Fragments.append("union", DeclarationFragments::FragmentKind::Keyword);
808   else
809     Fragments.append("struct", DeclarationFragments::FragmentKind::Keyword);
810 
811   Fragments.appendSpace();
812   if (!Record->getName().empty())
813     Fragments.append(Record->getName(),
814                      DeclarationFragments::FragmentKind::Identifier);
815   else
816     Fragments.append("{ ... }", DeclarationFragments::FragmentKind::Text);
817 
818   return Fragments.appendSemicolon();
819 }
820 
821 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForCXXClass(
822     const CXXRecordDecl *Record) {
823   if (const auto *TypedefNameDecl = Record->getTypedefNameForAnonDecl())
824     return getFragmentsForTypedef(TypedefNameDecl);
825 
826   DeclarationFragments Fragments;
827   Fragments.append(DeclarationFragments::getStructureTypeFragment(Record));
828 
829   if (!Record->getName().empty())
830     Fragments.appendSpace().append(
831         Record->getName(), DeclarationFragments::FragmentKind::Identifier);
832 
833   return Fragments.appendSemicolon();
834 }
835 
836 DeclarationFragments
837 DeclarationFragmentsBuilder::getFragmentsForSpecialCXXMethod(
838     const CXXMethodDecl *Method) {
839   DeclarationFragments Fragments;
840   std::string Name;
841   if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(Method)) {
842     Name = Method->getNameAsString();
843     if (Constructor->isExplicit())
844       Fragments.append("explicit", DeclarationFragments::FragmentKind::Keyword)
845           .appendSpace();
846   } else if (isa<CXXDestructorDecl>(Method))
847     Name = Method->getNameAsString();
848 
849   DeclarationFragments After;
850   Fragments.append(Name, DeclarationFragments::FragmentKind::Identifier)
851       .append(std::move(After));
852   Fragments.append("(", DeclarationFragments::FragmentKind::Text);
853   for (unsigned i = 0, end = Method->getNumParams(); i != end; ++i) {
854     if (i)
855       Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
856     Fragments.append(getFragmentsForParam(Method->getParamDecl(i)));
857   }
858   Fragments.append(")", DeclarationFragments::FragmentKind::Text);
859 
860   Fragments.append(DeclarationFragments::getExceptionSpecificationString(
861       Method->getExceptionSpecType()));
862 
863   return Fragments.appendSemicolon();
864 }
865 
866 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForCXXMethod(
867     const CXXMethodDecl *Method) {
868   DeclarationFragments Fragments;
869   StringRef Name = Method->getName();
870   if (Method->isStatic())
871     Fragments.append("static", DeclarationFragments::FragmentKind::Keyword)
872         .appendSpace();
873   if (Method->isConstexpr())
874     Fragments.append("constexpr", DeclarationFragments::FragmentKind::Keyword)
875         .appendSpace();
876   if (Method->isVolatile())
877     Fragments.append("volatile", DeclarationFragments::FragmentKind::Keyword)
878         .appendSpace();
879 
880   // Build return type
881   DeclarationFragments After;
882   Fragments
883       .append(getFragmentsForType(Method->getReturnType(),
884                                   Method->getASTContext(), After))
885       .appendSpace()
886       .append(Name, DeclarationFragments::FragmentKind::Identifier)
887       .append(std::move(After));
888   Fragments.append("(", DeclarationFragments::FragmentKind::Text);
889   for (unsigned i = 0, end = Method->getNumParams(); i != end; ++i) {
890     if (i)
891       Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
892     Fragments.append(getFragmentsForParam(Method->getParamDecl(i)));
893   }
894   Fragments.append(")", DeclarationFragments::FragmentKind::Text);
895 
896   if (Method->isConst())
897     Fragments.appendSpace().append("const",
898                                    DeclarationFragments::FragmentKind::Keyword);
899 
900   Fragments.append(DeclarationFragments::getExceptionSpecificationString(
901       Method->getExceptionSpecType()));
902 
903   return Fragments.appendSemicolon();
904 }
905 
906 DeclarationFragments
907 DeclarationFragmentsBuilder::getFragmentsForConversionFunction(
908     const CXXConversionDecl *ConversionFunction) {
909   DeclarationFragments Fragments;
910 
911   if (ConversionFunction->isExplicit())
912     Fragments.append("explicit", DeclarationFragments::FragmentKind::Keyword)
913         .appendSpace();
914 
915   Fragments.append("operator", DeclarationFragments::FragmentKind::Keyword)
916       .appendSpace();
917 
918   Fragments
919       .append(ConversionFunction->getConversionType().getAsString(),
920               DeclarationFragments::FragmentKind::TypeIdentifier)
921       .append("(", DeclarationFragments::FragmentKind::Text);
922   for (unsigned i = 0, end = ConversionFunction->getNumParams(); i != end;
923        ++i) {
924     if (i)
925       Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
926     Fragments.append(getFragmentsForParam(ConversionFunction->getParamDecl(i)));
927   }
928   Fragments.append(")", DeclarationFragments::FragmentKind::Text);
929 
930   if (ConversionFunction->isConst())
931     Fragments.appendSpace().append("const",
932                                    DeclarationFragments::FragmentKind::Keyword);
933 
934   return Fragments.appendSemicolon();
935 }
936 
937 DeclarationFragments
938 DeclarationFragmentsBuilder::getFragmentsForOverloadedOperator(
939     const CXXMethodDecl *Method) {
940   DeclarationFragments Fragments;
941 
942   // Build return type
943   DeclarationFragments After;
944   Fragments
945       .append(getFragmentsForType(Method->getReturnType(),
946                                   Method->getASTContext(), After))
947       .appendSpace()
948       .append(Method->getNameAsString(),
949               DeclarationFragments::FragmentKind::Identifier)
950       .append(std::move(After));
951   Fragments.append("(", DeclarationFragments::FragmentKind::Text);
952   for (unsigned i = 0, end = Method->getNumParams(); i != end; ++i) {
953     if (i)
954       Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
955     Fragments.append(getFragmentsForParam(Method->getParamDecl(i)));
956   }
957   Fragments.append(")", DeclarationFragments::FragmentKind::Text);
958 
959   if (Method->isConst())
960     Fragments.appendSpace().append("const",
961                                    DeclarationFragments::FragmentKind::Keyword);
962 
963   Fragments.append(DeclarationFragments::getExceptionSpecificationString(
964       Method->getExceptionSpecType()));
965 
966   return Fragments.appendSemicolon();
967 }
968 
969 // Get fragments for template parameters, e.g. T in tempalte<typename T> ...
970 DeclarationFragments
971 DeclarationFragmentsBuilder::getFragmentsForTemplateParameters(
972     ArrayRef<NamedDecl *> ParameterArray) {
973   DeclarationFragments Fragments;
974   for (unsigned i = 0, end = ParameterArray.size(); i != end; ++i) {
975     if (i)
976       Fragments.append(",", DeclarationFragments::FragmentKind::Text)
977           .appendSpace();
978 
979     if (const auto *TemplateParam =
980             dyn_cast<TemplateTypeParmDecl>(ParameterArray[i])) {
981       if (TemplateParam->hasTypeConstraint())
982         Fragments.append(TemplateParam->getTypeConstraint()
983                              ->getNamedConcept()
984                              ->getName()
985                              .str(),
986                          DeclarationFragments::FragmentKind::TypeIdentifier);
987       else if (TemplateParam->wasDeclaredWithTypename())
988         Fragments.append("typename",
989                          DeclarationFragments::FragmentKind::Keyword);
990       else
991         Fragments.append("class", DeclarationFragments::FragmentKind::Keyword);
992 
993       if (TemplateParam->isParameterPack())
994         Fragments.append("...", DeclarationFragments::FragmentKind::Text);
995 
996       if (!TemplateParam->getName().empty())
997         Fragments.appendSpace().append(
998             TemplateParam->getName(),
999             DeclarationFragments::FragmentKind::GenericParameter);
1000 
1001       if (TemplateParam->hasDefaultArgument()) {
1002         const auto Default = TemplateParam->getDefaultArgument();
1003         Fragments.append(" = ", DeclarationFragments::FragmentKind::Text)
1004             .append(getFragmentsForTemplateArguments(
1005                 {Default.getArgument()}, TemplateParam->getASTContext(),
1006                 {Default}));
1007       }
1008     } else if (const auto *NTP =
1009                    dyn_cast<NonTypeTemplateParmDecl>(ParameterArray[i])) {
1010       DeclarationFragments After;
1011       const auto TyFragments =
1012           getFragmentsForType(NTP->getType(), NTP->getASTContext(), After);
1013       Fragments.append(std::move(TyFragments)).append(std::move(After));
1014 
1015       if (NTP->isParameterPack())
1016         Fragments.append("...", DeclarationFragments::FragmentKind::Text);
1017 
1018       if (!NTP->getName().empty())
1019         Fragments.appendSpace().append(
1020             NTP->getName(),
1021             DeclarationFragments::FragmentKind::GenericParameter);
1022 
1023       if (NTP->hasDefaultArgument()) {
1024         SmallString<8> ExprStr;
1025         raw_svector_ostream Output(ExprStr);
1026         NTP->getDefaultArgument()->printPretty(
1027             Output, nullptr, NTP->getASTContext().getPrintingPolicy());
1028         Fragments.append(" = ", DeclarationFragments::FragmentKind::Text)
1029             .append(ExprStr, DeclarationFragments::FragmentKind::Text);
1030       }
1031     } else if (const auto *TTP =
1032                    dyn_cast<TemplateTemplateParmDecl>(ParameterArray[i])) {
1033       Fragments.append("template", DeclarationFragments::FragmentKind::Keyword)
1034           .appendSpace()
1035           .append("<", DeclarationFragments::FragmentKind::Text)
1036           .append(getFragmentsForTemplateParameters(
1037               TTP->getTemplateParameters()->asArray()))
1038           .append(">", DeclarationFragments::FragmentKind::Text)
1039           .appendSpace()
1040           .append(TTP->wasDeclaredWithTypename() ? "typename" : "class",
1041                   DeclarationFragments::FragmentKind::Keyword);
1042 
1043       if (TTP->isParameterPack())
1044         Fragments.append("...", DeclarationFragments::FragmentKind::Text);
1045 
1046       if (!TTP->getName().empty())
1047         Fragments.appendSpace().append(
1048             TTP->getName(),
1049             DeclarationFragments::FragmentKind::GenericParameter);
1050       if (TTP->hasDefaultArgument()) {
1051         const auto Default = TTP->getDefaultArgument();
1052         Fragments.append(" = ", DeclarationFragments::FragmentKind::Text)
1053             .append(getFragmentsForTemplateArguments(
1054                 {Default.getArgument()}, TTP->getASTContext(), {Default}));
1055       }
1056     }
1057   }
1058   return Fragments;
1059 }
1060 
1061 // Get fragments for template arguments, e.g. int in template<typename T>
1062 // Foo<int>;
1063 //
1064 // Note: TemplateParameters is only necessary if the Decl is a
1065 // PartialSpecialization, where we need the parameters to deduce the name of the
1066 // generic arguments.
1067 DeclarationFragments
1068 DeclarationFragmentsBuilder::getFragmentsForTemplateArguments(
1069     const ArrayRef<TemplateArgument> TemplateArguments, ASTContext &Context,
1070     const std::optional<ArrayRef<TemplateArgumentLoc>> TemplateArgumentLocs) {
1071   DeclarationFragments Fragments;
1072   for (unsigned i = 0, end = TemplateArguments.size(); i != end; ++i) {
1073     if (i)
1074       Fragments.append(",", DeclarationFragments::FragmentKind::Text)
1075           .appendSpace();
1076 
1077     const auto &CTA = TemplateArguments[i];
1078     switch (CTA.getKind()) {
1079     case TemplateArgument::Type: {
1080       DeclarationFragments After;
1081       DeclarationFragments ArgumentFragment =
1082           getFragmentsForType(CTA.getAsType(), Context, After);
1083 
1084       if (StringRef(ArgumentFragment.begin()->Spelling)
1085               .starts_with("type-parameter")) {
1086         std::string ProperArgName = TemplateArgumentLocs.value()[i]
1087                                         .getTypeSourceInfo()
1088                                         ->getType()
1089                                         .getAsString();
1090         ArgumentFragment.begin()->Spelling.swap(ProperArgName);
1091       }
1092       Fragments.append(std::move(ArgumentFragment));
1093       break;
1094     }
1095     case TemplateArgument::Declaration: {
1096       const auto *VD = CTA.getAsDecl();
1097       SmallString<128> USR;
1098       index::generateUSRForDecl(VD, USR);
1099       Fragments.append(VD->getNameAsString(),
1100                        DeclarationFragments::FragmentKind::Identifier, USR);
1101       break;
1102     }
1103     case TemplateArgument::NullPtr:
1104       Fragments.append("nullptr", DeclarationFragments::FragmentKind::Keyword);
1105       break;
1106 
1107     case TemplateArgument::Integral: {
1108       SmallString<4> Str;
1109       CTA.getAsIntegral().toString(Str);
1110       Fragments.append(Str, DeclarationFragments::FragmentKind::Text);
1111       break;
1112     }
1113 
1114     case TemplateArgument::StructuralValue: {
1115       const auto SVTy = CTA.getStructuralValueType();
1116       Fragments.append(CTA.getAsStructuralValue().getAsString(Context, SVTy),
1117                        DeclarationFragments::FragmentKind::Text);
1118       break;
1119     }
1120 
1121     case TemplateArgument::TemplateExpansion:
1122     case TemplateArgument::Template: {
1123       std::string Str;
1124       raw_string_ostream Stream(Str);
1125       CTA.getAsTemplate().print(Stream, Context.getPrintingPolicy());
1126       SmallString<64> USR("");
1127       if (const auto *TemplDecl =
1128               CTA.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
1129         index::generateUSRForDecl(TemplDecl, USR);
1130       Fragments.append(Str, DeclarationFragments::FragmentKind::TypeIdentifier,
1131                        USR);
1132       if (CTA.getKind() == TemplateArgument::TemplateExpansion)
1133         Fragments.append("...", DeclarationFragments::FragmentKind::Text);
1134       break;
1135     }
1136 
1137     case TemplateArgument::Pack:
1138       Fragments.append("<", DeclarationFragments::FragmentKind::Text)
1139           .append(getFragmentsForTemplateArguments(CTA.pack_elements(), Context,
1140                                                    {}))
1141           .append(">", DeclarationFragments::FragmentKind::Text);
1142       break;
1143 
1144     case TemplateArgument::Expression: {
1145       SmallString<8> ExprStr;
1146       raw_svector_ostream Output(ExprStr);
1147       CTA.getAsExpr()->printPretty(Output, nullptr,
1148                                    Context.getPrintingPolicy());
1149       Fragments.append(ExprStr, DeclarationFragments::FragmentKind::Text);
1150       break;
1151     }
1152 
1153     case TemplateArgument::Null:
1154       break;
1155     }
1156   }
1157   return Fragments;
1158 }
1159 
1160 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForConcept(
1161     const ConceptDecl *Concept) {
1162   DeclarationFragments Fragments;
1163   return Fragments
1164       .append("template", DeclarationFragments::FragmentKind::Keyword)
1165       .appendSpace()
1166       .append("<", DeclarationFragments::FragmentKind::Text)
1167       .append(getFragmentsForTemplateParameters(
1168           Concept->getTemplateParameters()->asArray()))
1169       .append("> ", DeclarationFragments::FragmentKind::Text)
1170       .appendSpace()
1171       .append("concept", DeclarationFragments::FragmentKind::Keyword)
1172       .appendSpace()
1173       .append(Concept->getName().str(),
1174               DeclarationFragments::FragmentKind::Identifier)
1175       .appendSemicolon();
1176 }
1177 
1178 DeclarationFragments
1179 DeclarationFragmentsBuilder::getFragmentsForRedeclarableTemplate(
1180     const RedeclarableTemplateDecl *RedeclarableTemplate) {
1181   DeclarationFragments Fragments;
1182   Fragments.append("template", DeclarationFragments::FragmentKind::Keyword)
1183       .appendSpace()
1184       .append("<", DeclarationFragments::FragmentKind::Text)
1185       .append(getFragmentsForTemplateParameters(
1186           RedeclarableTemplate->getTemplateParameters()->asArray()))
1187       .append(">", DeclarationFragments::FragmentKind::Text)
1188       .appendSpace();
1189 
1190   if (isa<TypeAliasTemplateDecl>(RedeclarableTemplate))
1191     Fragments.appendSpace()
1192         .append("using", DeclarationFragments::FragmentKind::Keyword)
1193         .appendSpace()
1194         .append(RedeclarableTemplate->getName(),
1195                 DeclarationFragments::FragmentKind::Identifier);
1196   // the templated records will be resposbible for injecting their templates
1197   return Fragments.appendSpace();
1198 }
1199 
1200 DeclarationFragments
1201 DeclarationFragmentsBuilder::getFragmentsForClassTemplateSpecialization(
1202     const ClassTemplateSpecializationDecl *Decl) {
1203   DeclarationFragments Fragments;
1204   return Fragments
1205       .append("template", DeclarationFragments::FragmentKind::Keyword)
1206       .appendSpace()
1207       .append("<", DeclarationFragments::FragmentKind::Text)
1208       .append(">", DeclarationFragments::FragmentKind::Text)
1209       .appendSpace()
1210       .append(DeclarationFragmentsBuilder::getFragmentsForCXXClass(
1211           cast<CXXRecordDecl>(Decl)))
1212       .pop_back() // there is an extra semicolon now
1213       .append("<", DeclarationFragments::FragmentKind::Text)
1214       .append(
1215           getFragmentsForTemplateArguments(Decl->getTemplateArgs().asArray(),
1216                                            Decl->getASTContext(), std::nullopt))
1217       .append(">", DeclarationFragments::FragmentKind::Text)
1218       .appendSemicolon();
1219 }
1220 
1221 DeclarationFragments
1222 DeclarationFragmentsBuilder::getFragmentsForClassTemplatePartialSpecialization(
1223     const ClassTemplatePartialSpecializationDecl *Decl) {
1224   DeclarationFragments Fragments;
1225   return Fragments
1226       .append("template", DeclarationFragments::FragmentKind::Keyword)
1227       .appendSpace()
1228       .append("<", DeclarationFragments::FragmentKind::Text)
1229       .append(getFragmentsForTemplateParameters(
1230           Decl->getTemplateParameters()->asArray()))
1231       .append(">", DeclarationFragments::FragmentKind::Text)
1232       .appendSpace()
1233       .append(DeclarationFragmentsBuilder::getFragmentsForCXXClass(
1234           cast<CXXRecordDecl>(Decl)))
1235       .pop_back() // there is an extra semicolon now
1236       .append("<", DeclarationFragments::FragmentKind::Text)
1237       .append(getFragmentsForTemplateArguments(
1238           Decl->getTemplateArgs().asArray(), Decl->getASTContext(),
1239           Decl->getTemplateArgsAsWritten()->arguments()))
1240       .append(">", DeclarationFragments::FragmentKind::Text)
1241       .appendSemicolon();
1242 }
1243 
1244 DeclarationFragments
1245 DeclarationFragmentsBuilder::getFragmentsForVarTemplateSpecialization(
1246     const VarTemplateSpecializationDecl *Decl) {
1247   DeclarationFragments Fragments;
1248   return Fragments
1249       .append("template", DeclarationFragments::FragmentKind::Keyword)
1250       .appendSpace()
1251       .append("<", DeclarationFragments::FragmentKind::Text)
1252       .append(">", DeclarationFragments::FragmentKind::Text)
1253       .appendSpace()
1254       .append(DeclarationFragmentsBuilder::getFragmentsForVarTemplate(Decl))
1255       .pop_back() // there is an extra semicolon now
1256       .append("<", DeclarationFragments::FragmentKind::Text)
1257       .append(
1258           getFragmentsForTemplateArguments(Decl->getTemplateArgs().asArray(),
1259                                            Decl->getASTContext(), std::nullopt))
1260       .append(">", DeclarationFragments::FragmentKind::Text)
1261       .appendSemicolon();
1262 }
1263 
1264 DeclarationFragments
1265 DeclarationFragmentsBuilder::getFragmentsForVarTemplatePartialSpecialization(
1266     const VarTemplatePartialSpecializationDecl *Decl) {
1267   DeclarationFragments Fragments;
1268   return Fragments
1269       .append("template", DeclarationFragments::FragmentKind::Keyword)
1270       .appendSpace()
1271       .append("<", DeclarationFragments::FragmentKind::Text)
1272       // Partial specs may have new params.
1273       .append(getFragmentsForTemplateParameters(
1274           Decl->getTemplateParameters()->asArray()))
1275       .append(">", DeclarationFragments::FragmentKind::Text)
1276       .appendSpace()
1277       .append(DeclarationFragmentsBuilder::getFragmentsForVarTemplate(Decl))
1278       .pop_back() // there is an extra semicolon now
1279       .append("<", DeclarationFragments::FragmentKind::Text)
1280       .append(getFragmentsForTemplateArguments(
1281           Decl->getTemplateArgs().asArray(), Decl->getASTContext(),
1282           Decl->getTemplateArgsAsWritten()->arguments()))
1283       .append(">", DeclarationFragments::FragmentKind::Text)
1284       .appendSemicolon();
1285 }
1286 
1287 DeclarationFragments
1288 DeclarationFragmentsBuilder::getFragmentsForFunctionTemplate(
1289     const FunctionTemplateDecl *Decl) {
1290   DeclarationFragments Fragments;
1291   return Fragments
1292       .append("template", DeclarationFragments::FragmentKind::Keyword)
1293       .appendSpace()
1294       .append("<", DeclarationFragments::FragmentKind::Text)
1295       // Partial specs may have new params.
1296       .append(getFragmentsForTemplateParameters(
1297           Decl->getTemplateParameters()->asArray()))
1298       .append(">", DeclarationFragments::FragmentKind::Text)
1299       .appendSpace()
1300       .append(DeclarationFragmentsBuilder::getFragmentsForFunction(
1301           Decl->getAsFunction()));
1302 }
1303 
1304 DeclarationFragments
1305 DeclarationFragmentsBuilder::getFragmentsForFunctionTemplateSpecialization(
1306     const FunctionDecl *Decl) {
1307   DeclarationFragments Fragments;
1308   return Fragments
1309       .append("template", DeclarationFragments::FragmentKind::Keyword)
1310       .appendSpace()
1311       .append("<>", DeclarationFragments::FragmentKind::Text)
1312       .appendSpace()
1313       .append(DeclarationFragmentsBuilder::getFragmentsForFunction(Decl));
1314 }
1315 
1316 DeclarationFragments
1317 DeclarationFragmentsBuilder::getFragmentsForMacro(StringRef Name,
1318                                                   const MacroDirective *MD) {
1319   DeclarationFragments Fragments;
1320   Fragments.append("#define", DeclarationFragments::FragmentKind::Keyword)
1321       .appendSpace();
1322   Fragments.append(Name, DeclarationFragments::FragmentKind::Identifier);
1323 
1324   auto *MI = MD->getMacroInfo();
1325 
1326   if (MI->isFunctionLike()) {
1327     Fragments.append("(", DeclarationFragments::FragmentKind::Text);
1328     unsigned numParameters = MI->getNumParams();
1329     if (MI->isC99Varargs())
1330       --numParameters;
1331     for (unsigned i = 0; i < numParameters; ++i) {
1332       if (i)
1333         Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1334       Fragments.append(MI->params()[i]->getName(),
1335                        DeclarationFragments::FragmentKind::InternalParam);
1336     }
1337     if (MI->isVariadic()) {
1338       if (numParameters && MI->isC99Varargs())
1339         Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1340       Fragments.append("...", DeclarationFragments::FragmentKind::Text);
1341     }
1342     Fragments.append(")", DeclarationFragments::FragmentKind::Text);
1343   }
1344   return Fragments;
1345 }
1346 
1347 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCCategory(
1348     const ObjCCategoryDecl *Category) {
1349   DeclarationFragments Fragments;
1350 
1351   auto *Interface = Category->getClassInterface();
1352   SmallString<128> InterfaceUSR;
1353   index::generateUSRForDecl(Interface, InterfaceUSR);
1354 
1355   Fragments.append("@interface", DeclarationFragments::FragmentKind::Keyword)
1356       .appendSpace()
1357       .append(Interface->getName(),
1358               DeclarationFragments::FragmentKind::TypeIdentifier, InterfaceUSR,
1359               Interface)
1360       .append(" (", DeclarationFragments::FragmentKind::Text)
1361       .append(Category->getName(),
1362               DeclarationFragments::FragmentKind::Identifier)
1363       .append(")", DeclarationFragments::FragmentKind::Text);
1364 
1365   return Fragments;
1366 }
1367 
1368 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCInterface(
1369     const ObjCInterfaceDecl *Interface) {
1370   DeclarationFragments Fragments;
1371   // Build the base of the Objective-C interface declaration.
1372   Fragments.append("@interface", DeclarationFragments::FragmentKind::Keyword)
1373       .appendSpace()
1374       .append(Interface->getName(),
1375               DeclarationFragments::FragmentKind::Identifier);
1376 
1377   // Build the inheritance part of the declaration.
1378   if (const ObjCInterfaceDecl *SuperClass = Interface->getSuperClass()) {
1379     SmallString<128> SuperUSR;
1380     index::generateUSRForDecl(SuperClass, SuperUSR);
1381     Fragments.append(" : ", DeclarationFragments::FragmentKind::Text)
1382         .append(SuperClass->getName(),
1383                 DeclarationFragments::FragmentKind::TypeIdentifier, SuperUSR,
1384                 SuperClass);
1385   }
1386 
1387   return Fragments;
1388 }
1389 
1390 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCMethod(
1391     const ObjCMethodDecl *Method) {
1392   DeclarationFragments Fragments, After;
1393   // Build the instance/class method indicator.
1394   if (Method->isClassMethod())
1395     Fragments.append("+ ", DeclarationFragments::FragmentKind::Text);
1396   else if (Method->isInstanceMethod())
1397     Fragments.append("- ", DeclarationFragments::FragmentKind::Text);
1398 
1399   // Build the return type.
1400   Fragments.append("(", DeclarationFragments::FragmentKind::Text)
1401       .append(getFragmentsForType(Method->getReturnType(),
1402                                   Method->getASTContext(), After))
1403       .append(std::move(After))
1404       .append(")", DeclarationFragments::FragmentKind::Text);
1405 
1406   // Build the selector part.
1407   Selector Selector = Method->getSelector();
1408   if (Selector.getNumArgs() == 0)
1409     // For Objective-C methods that don't take arguments, the first (and only)
1410     // slot of the selector is the method name.
1411     Fragments.appendSpace().append(
1412         Selector.getNameForSlot(0),
1413         DeclarationFragments::FragmentKind::Identifier);
1414 
1415   // For Objective-C methods that take arguments, build the selector slots.
1416   for (unsigned i = 0, end = Method->param_size(); i != end; ++i) {
1417     // Objective-C method selector parts are considered as identifiers instead
1418     // of "external parameters" as in Swift. This is because Objective-C method
1419     // symbols are referenced with the entire selector, instead of just the
1420     // method name in Swift.
1421     SmallString<32> ParamID(Selector.getNameForSlot(i));
1422     ParamID.append(":");
1423     Fragments.appendSpace().append(
1424         ParamID, DeclarationFragments::FragmentKind::Identifier);
1425 
1426     // Build the internal parameter.
1427     const ParmVarDecl *Param = Method->getParamDecl(i);
1428     Fragments.append(getFragmentsForParam(Param));
1429   }
1430 
1431   return Fragments.appendSemicolon();
1432 }
1433 
1434 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCProperty(
1435     const ObjCPropertyDecl *Property) {
1436   DeclarationFragments Fragments, After;
1437 
1438   // Build the Objective-C property keyword.
1439   Fragments.append("@property", DeclarationFragments::FragmentKind::Keyword);
1440 
1441   const auto Attributes = Property->getPropertyAttributesAsWritten();
1442   // Build the attributes if there is any associated with the property.
1443   if (Attributes != ObjCPropertyAttribute::kind_noattr) {
1444     // No leading comma for the first attribute.
1445     bool First = true;
1446     Fragments.append(" (", DeclarationFragments::FragmentKind::Text);
1447     // Helper function to render the attribute.
1448     auto RenderAttribute =
1449         [&](ObjCPropertyAttribute::Kind Kind, StringRef Spelling,
1450             StringRef Arg = "",
1451             DeclarationFragments::FragmentKind ArgKind =
1452                 DeclarationFragments::FragmentKind::Identifier) {
1453           // Check if the `Kind` attribute is set for this property.
1454           if ((Attributes & Kind) && !Spelling.empty()) {
1455             // Add a leading comma if this is not the first attribute rendered.
1456             if (!First)
1457               Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1458             // Render the spelling of this attribute `Kind` as a keyword.
1459             Fragments.append(Spelling,
1460                              DeclarationFragments::FragmentKind::Keyword);
1461             // If this attribute takes in arguments (e.g. `getter=getterName`),
1462             // render the arguments.
1463             if (!Arg.empty())
1464               Fragments.append("=", DeclarationFragments::FragmentKind::Text)
1465                   .append(Arg, ArgKind);
1466             First = false;
1467           }
1468         };
1469 
1470     // Go through all possible Objective-C property attributes and render set
1471     // ones.
1472     RenderAttribute(ObjCPropertyAttribute::kind_class, "class");
1473     RenderAttribute(ObjCPropertyAttribute::kind_direct, "direct");
1474     RenderAttribute(ObjCPropertyAttribute::kind_nonatomic, "nonatomic");
1475     RenderAttribute(ObjCPropertyAttribute::kind_atomic, "atomic");
1476     RenderAttribute(ObjCPropertyAttribute::kind_assign, "assign");
1477     RenderAttribute(ObjCPropertyAttribute::kind_retain, "retain");
1478     RenderAttribute(ObjCPropertyAttribute::kind_strong, "strong");
1479     RenderAttribute(ObjCPropertyAttribute::kind_copy, "copy");
1480     RenderAttribute(ObjCPropertyAttribute::kind_weak, "weak");
1481     RenderAttribute(ObjCPropertyAttribute::kind_unsafe_unretained,
1482                     "unsafe_unretained");
1483     RenderAttribute(ObjCPropertyAttribute::kind_readwrite, "readwrite");
1484     RenderAttribute(ObjCPropertyAttribute::kind_readonly, "readonly");
1485     RenderAttribute(ObjCPropertyAttribute::kind_getter, "getter",
1486                     Property->getGetterName().getAsString());
1487     RenderAttribute(ObjCPropertyAttribute::kind_setter, "setter",
1488                     Property->getSetterName().getAsString());
1489 
1490     // Render nullability attributes.
1491     if (Attributes & ObjCPropertyAttribute::kind_nullability) {
1492       QualType Type = Property->getType();
1493       if (const auto Nullability =
1494               AttributedType::stripOuterNullability(Type)) {
1495         if (!First)
1496           Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1497         if (*Nullability == NullabilityKind::Unspecified &&
1498             (Attributes & ObjCPropertyAttribute::kind_null_resettable))
1499           Fragments.append("null_resettable",
1500                            DeclarationFragments::FragmentKind::Keyword);
1501         else
1502           Fragments.append(
1503               getNullabilitySpelling(*Nullability, /*isContextSensitive=*/true),
1504               DeclarationFragments::FragmentKind::Keyword);
1505         First = false;
1506       }
1507     }
1508 
1509     Fragments.append(")", DeclarationFragments::FragmentKind::Text);
1510   }
1511 
1512   Fragments.appendSpace();
1513 
1514   FunctionTypeLoc BlockLoc;
1515   FunctionProtoTypeLoc BlockProtoLoc;
1516   findTypeLocForBlockDecl(Property->getTypeSourceInfo(), BlockLoc,
1517                           BlockProtoLoc);
1518 
1519   auto PropType = Property->getType();
1520   if (!BlockLoc)
1521     Fragments
1522         .append(getFragmentsForType(PropType, Property->getASTContext(), After))
1523         .appendSpace();
1524   else
1525     Fragments.append(
1526         getFragmentsForBlock(Property, BlockLoc, BlockProtoLoc, After));
1527 
1528   return Fragments
1529       .append(Property->getName(),
1530               DeclarationFragments::FragmentKind::Identifier)
1531       .append(std::move(After))
1532       .appendSemicolon();
1533 }
1534 
1535 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCProtocol(
1536     const ObjCProtocolDecl *Protocol) {
1537   DeclarationFragments Fragments;
1538   // Build basic protocol declaration.
1539   Fragments.append("@protocol", DeclarationFragments::FragmentKind::Keyword)
1540       .appendSpace()
1541       .append(Protocol->getName(),
1542               DeclarationFragments::FragmentKind::Identifier);
1543 
1544   // If this protocol conforms to other protocols, build the conformance list.
1545   if (!Protocol->protocols().empty()) {
1546     Fragments.append(" <", DeclarationFragments::FragmentKind::Text);
1547     for (ObjCProtocolDecl::protocol_iterator It = Protocol->protocol_begin();
1548          It != Protocol->protocol_end(); It++) {
1549       // Add a leading comma if this is not the first protocol rendered.
1550       if (It != Protocol->protocol_begin())
1551         Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1552 
1553       SmallString<128> USR;
1554       index::generateUSRForDecl(*It, USR);
1555       Fragments.append((*It)->getName(),
1556                        DeclarationFragments::FragmentKind::TypeIdentifier, USR,
1557                        *It);
1558     }
1559     Fragments.append(">", DeclarationFragments::FragmentKind::Text);
1560   }
1561 
1562   return Fragments;
1563 }
1564 
1565 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForTypedef(
1566     const TypedefNameDecl *Decl) {
1567   DeclarationFragments Fragments, After;
1568   Fragments.append("typedef", DeclarationFragments::FragmentKind::Keyword)
1569       .appendSpace()
1570       .append(getFragmentsForType(Decl->getUnderlyingType(),
1571                                   Decl->getASTContext(), After))
1572       .append(std::move(After))
1573       .appendSpace()
1574       .append(Decl->getName(), DeclarationFragments::FragmentKind::Identifier);
1575 
1576   return Fragments.appendSemicolon();
1577 }
1578 
1579 // Instantiate template for FunctionDecl.
1580 template FunctionSignature
1581 DeclarationFragmentsBuilder::getFunctionSignature(const FunctionDecl *);
1582 
1583 // Instantiate template for ObjCMethodDecl.
1584 template FunctionSignature
1585 DeclarationFragmentsBuilder::getFunctionSignature(const ObjCMethodDecl *);
1586 
1587 // Subheading of a symbol defaults to its name.
1588 DeclarationFragments
1589 DeclarationFragmentsBuilder::getSubHeading(const NamedDecl *Decl) {
1590   DeclarationFragments Fragments;
1591   if (isa<CXXConstructorDecl>(Decl) || isa<CXXDestructorDecl>(Decl))
1592     Fragments.append(cast<CXXRecordDecl>(Decl->getDeclContext())->getName(),
1593                      DeclarationFragments::FragmentKind::Identifier);
1594   else if (isa<CXXConversionDecl>(Decl)) {
1595     Fragments.append(
1596         cast<CXXConversionDecl>(Decl)->getConversionType().getAsString(),
1597         DeclarationFragments::FragmentKind::Identifier);
1598   } else if (isa<CXXMethodDecl>(Decl) &&
1599              cast<CXXMethodDecl>(Decl)->isOverloadedOperator()) {
1600     Fragments.append(Decl->getNameAsString(),
1601                      DeclarationFragments::FragmentKind::Identifier);
1602   } else if (!Decl->getName().empty())
1603     Fragments.append(Decl->getName(),
1604                      DeclarationFragments::FragmentKind::Identifier);
1605   return Fragments;
1606 }
1607 
1608 // Subheading of an Objective-C method is a `+` or `-` sign indicating whether
1609 // it's a class method or an instance method, followed by the selector name.
1610 DeclarationFragments
1611 DeclarationFragmentsBuilder::getSubHeading(const ObjCMethodDecl *Method) {
1612   DeclarationFragments Fragments;
1613   if (Method->isClassMethod())
1614     Fragments.append("+ ", DeclarationFragments::FragmentKind::Text);
1615   else if (Method->isInstanceMethod())
1616     Fragments.append("- ", DeclarationFragments::FragmentKind::Text);
1617 
1618   return Fragments.append(Method->getNameAsString(),
1619                           DeclarationFragments::FragmentKind::Identifier);
1620 }
1621 
1622 // Subheading of a symbol defaults to its name.
1623 DeclarationFragments
1624 DeclarationFragmentsBuilder::getSubHeadingForMacro(StringRef Name) {
1625   DeclarationFragments Fragments;
1626   Fragments.append(Name, DeclarationFragments::FragmentKind::Identifier);
1627   return Fragments;
1628 }
1629