xref: /llvm-project/clang/lib/ExtractAPI/DeclarationFragments.cpp (revision 2bde13cda1e389599413132028731f18fb5c03c3) 
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().getArgument().print(
1027             NTP->getASTContext().getPrintingPolicy(), Output,
1028             /*IncludeType=*/false);
1029         Fragments.append(" = ", DeclarationFragments::FragmentKind::Text)
1030             .append(ExprStr, DeclarationFragments::FragmentKind::Text);
1031       }
1032     } else if (const auto *TTP =
1033                    dyn_cast<TemplateTemplateParmDecl>(ParameterArray[i])) {
1034       Fragments.append("template", DeclarationFragments::FragmentKind::Keyword)
1035           .appendSpace()
1036           .append("<", DeclarationFragments::FragmentKind::Text)
1037           .append(getFragmentsForTemplateParameters(
1038               TTP->getTemplateParameters()->asArray()))
1039           .append(">", DeclarationFragments::FragmentKind::Text)
1040           .appendSpace()
1041           .append(TTP->wasDeclaredWithTypename() ? "typename" : "class",
1042                   DeclarationFragments::FragmentKind::Keyword);
1043 
1044       if (TTP->isParameterPack())
1045         Fragments.append("...", DeclarationFragments::FragmentKind::Text);
1046 
1047       if (!TTP->getName().empty())
1048         Fragments.appendSpace().append(
1049             TTP->getName(),
1050             DeclarationFragments::FragmentKind::GenericParameter);
1051       if (TTP->hasDefaultArgument()) {
1052         const auto Default = TTP->getDefaultArgument();
1053         Fragments.append(" = ", DeclarationFragments::FragmentKind::Text)
1054             .append(getFragmentsForTemplateArguments(
1055                 {Default.getArgument()}, TTP->getASTContext(), {Default}));
1056       }
1057     }
1058   }
1059   return Fragments;
1060 }
1061 
1062 // Get fragments for template arguments, e.g. int in template<typename T>
1063 // Foo<int>;
1064 //
1065 // Note: TemplateParameters is only necessary if the Decl is a
1066 // PartialSpecialization, where we need the parameters to deduce the name of the
1067 // generic arguments.
1068 DeclarationFragments
1069 DeclarationFragmentsBuilder::getFragmentsForTemplateArguments(
1070     const ArrayRef<TemplateArgument> TemplateArguments, ASTContext &Context,
1071     const std::optional<ArrayRef<TemplateArgumentLoc>> TemplateArgumentLocs) {
1072   DeclarationFragments Fragments;
1073   for (unsigned i = 0, end = TemplateArguments.size(); i != end; ++i) {
1074     if (i)
1075       Fragments.append(",", DeclarationFragments::FragmentKind::Text)
1076           .appendSpace();
1077 
1078     const auto &CTA = TemplateArguments[i];
1079     switch (CTA.getKind()) {
1080     case TemplateArgument::Type: {
1081       DeclarationFragments After;
1082       DeclarationFragments ArgumentFragment =
1083           getFragmentsForType(CTA.getAsType(), Context, After);
1084 
1085       if (StringRef(ArgumentFragment.begin()->Spelling)
1086               .starts_with("type-parameter")) {
1087         std::string ProperArgName = TemplateArgumentLocs.value()[i]
1088                                         .getTypeSourceInfo()
1089                                         ->getType()
1090                                         .getAsString();
1091         ArgumentFragment.begin()->Spelling.swap(ProperArgName);
1092       }
1093       Fragments.append(std::move(ArgumentFragment));
1094       break;
1095     }
1096     case TemplateArgument::Declaration: {
1097       const auto *VD = CTA.getAsDecl();
1098       SmallString<128> USR;
1099       index::generateUSRForDecl(VD, USR);
1100       Fragments.append(VD->getNameAsString(),
1101                        DeclarationFragments::FragmentKind::Identifier, USR);
1102       break;
1103     }
1104     case TemplateArgument::NullPtr:
1105       Fragments.append("nullptr", DeclarationFragments::FragmentKind::Keyword);
1106       break;
1107 
1108     case TemplateArgument::Integral: {
1109       SmallString<4> Str;
1110       CTA.getAsIntegral().toString(Str);
1111       Fragments.append(Str, DeclarationFragments::FragmentKind::Text);
1112       break;
1113     }
1114 
1115     case TemplateArgument::StructuralValue: {
1116       const auto SVTy = CTA.getStructuralValueType();
1117       Fragments.append(CTA.getAsStructuralValue().getAsString(Context, SVTy),
1118                        DeclarationFragments::FragmentKind::Text);
1119       break;
1120     }
1121 
1122     case TemplateArgument::TemplateExpansion:
1123     case TemplateArgument::Template: {
1124       std::string Str;
1125       raw_string_ostream Stream(Str);
1126       CTA.getAsTemplate().print(Stream, Context.getPrintingPolicy());
1127       SmallString<64> USR("");
1128       if (const auto *TemplDecl =
1129               CTA.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
1130         index::generateUSRForDecl(TemplDecl, USR);
1131       Fragments.append(Str, DeclarationFragments::FragmentKind::TypeIdentifier,
1132                        USR);
1133       if (CTA.getKind() == TemplateArgument::TemplateExpansion)
1134         Fragments.append("...", DeclarationFragments::FragmentKind::Text);
1135       break;
1136     }
1137 
1138     case TemplateArgument::Pack:
1139       Fragments.append("<", DeclarationFragments::FragmentKind::Text)
1140           .append(getFragmentsForTemplateArguments(CTA.pack_elements(), Context,
1141                                                    {}))
1142           .append(">", DeclarationFragments::FragmentKind::Text);
1143       break;
1144 
1145     case TemplateArgument::Expression: {
1146       SmallString<8> ExprStr;
1147       raw_svector_ostream Output(ExprStr);
1148       CTA.getAsExpr()->printPretty(Output, nullptr,
1149                                    Context.getPrintingPolicy());
1150       Fragments.append(ExprStr, DeclarationFragments::FragmentKind::Text);
1151       break;
1152     }
1153 
1154     case TemplateArgument::Null:
1155       break;
1156     }
1157   }
1158   return Fragments;
1159 }
1160 
1161 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForConcept(
1162     const ConceptDecl *Concept) {
1163   DeclarationFragments Fragments;
1164   return Fragments
1165       .append("template", DeclarationFragments::FragmentKind::Keyword)
1166       .appendSpace()
1167       .append("<", DeclarationFragments::FragmentKind::Text)
1168       .append(getFragmentsForTemplateParameters(
1169           Concept->getTemplateParameters()->asArray()))
1170       .append("> ", DeclarationFragments::FragmentKind::Text)
1171       .appendSpace()
1172       .append("concept", DeclarationFragments::FragmentKind::Keyword)
1173       .appendSpace()
1174       .append(Concept->getName().str(),
1175               DeclarationFragments::FragmentKind::Identifier)
1176       .appendSemicolon();
1177 }
1178 
1179 DeclarationFragments
1180 DeclarationFragmentsBuilder::getFragmentsForRedeclarableTemplate(
1181     const RedeclarableTemplateDecl *RedeclarableTemplate) {
1182   DeclarationFragments Fragments;
1183   Fragments.append("template", DeclarationFragments::FragmentKind::Keyword)
1184       .appendSpace()
1185       .append("<", DeclarationFragments::FragmentKind::Text)
1186       .append(getFragmentsForTemplateParameters(
1187           RedeclarableTemplate->getTemplateParameters()->asArray()))
1188       .append(">", DeclarationFragments::FragmentKind::Text)
1189       .appendSpace();
1190 
1191   if (isa<TypeAliasTemplateDecl>(RedeclarableTemplate))
1192     Fragments.appendSpace()
1193         .append("using", DeclarationFragments::FragmentKind::Keyword)
1194         .appendSpace()
1195         .append(RedeclarableTemplate->getName(),
1196                 DeclarationFragments::FragmentKind::Identifier);
1197   // the templated records will be resposbible for injecting their templates
1198   return Fragments.appendSpace();
1199 }
1200 
1201 DeclarationFragments
1202 DeclarationFragmentsBuilder::getFragmentsForClassTemplateSpecialization(
1203     const ClassTemplateSpecializationDecl *Decl) {
1204   DeclarationFragments Fragments;
1205   return Fragments
1206       .append("template", DeclarationFragments::FragmentKind::Keyword)
1207       .appendSpace()
1208       .append("<", DeclarationFragments::FragmentKind::Text)
1209       .append(">", DeclarationFragments::FragmentKind::Text)
1210       .appendSpace()
1211       .append(DeclarationFragmentsBuilder::getFragmentsForCXXClass(
1212           cast<CXXRecordDecl>(Decl)))
1213       .pop_back() // there is an extra semicolon now
1214       .append("<", DeclarationFragments::FragmentKind::Text)
1215       .append(
1216           getFragmentsForTemplateArguments(Decl->getTemplateArgs().asArray(),
1217                                            Decl->getASTContext(), std::nullopt))
1218       .append(">", DeclarationFragments::FragmentKind::Text)
1219       .appendSemicolon();
1220 }
1221 
1222 DeclarationFragments
1223 DeclarationFragmentsBuilder::getFragmentsForClassTemplatePartialSpecialization(
1224     const ClassTemplatePartialSpecializationDecl *Decl) {
1225   DeclarationFragments Fragments;
1226   return Fragments
1227       .append("template", DeclarationFragments::FragmentKind::Keyword)
1228       .appendSpace()
1229       .append("<", DeclarationFragments::FragmentKind::Text)
1230       .append(getFragmentsForTemplateParameters(
1231           Decl->getTemplateParameters()->asArray()))
1232       .append(">", DeclarationFragments::FragmentKind::Text)
1233       .appendSpace()
1234       .append(DeclarationFragmentsBuilder::getFragmentsForCXXClass(
1235           cast<CXXRecordDecl>(Decl)))
1236       .pop_back() // there is an extra semicolon now
1237       .append("<", DeclarationFragments::FragmentKind::Text)
1238       .append(getFragmentsForTemplateArguments(
1239           Decl->getTemplateArgs().asArray(), Decl->getASTContext(),
1240           Decl->getTemplateArgsAsWritten()->arguments()))
1241       .append(">", DeclarationFragments::FragmentKind::Text)
1242       .appendSemicolon();
1243 }
1244 
1245 DeclarationFragments
1246 DeclarationFragmentsBuilder::getFragmentsForVarTemplateSpecialization(
1247     const VarTemplateSpecializationDecl *Decl) {
1248   DeclarationFragments Fragments;
1249   return Fragments
1250       .append("template", DeclarationFragments::FragmentKind::Keyword)
1251       .appendSpace()
1252       .append("<", DeclarationFragments::FragmentKind::Text)
1253       .append(">", DeclarationFragments::FragmentKind::Text)
1254       .appendSpace()
1255       .append(DeclarationFragmentsBuilder::getFragmentsForVarTemplate(Decl))
1256       .pop_back() // there is an extra semicolon now
1257       .append("<", DeclarationFragments::FragmentKind::Text)
1258       .append(
1259           getFragmentsForTemplateArguments(Decl->getTemplateArgs().asArray(),
1260                                            Decl->getASTContext(), std::nullopt))
1261       .append(">", DeclarationFragments::FragmentKind::Text)
1262       .appendSemicolon();
1263 }
1264 
1265 DeclarationFragments
1266 DeclarationFragmentsBuilder::getFragmentsForVarTemplatePartialSpecialization(
1267     const VarTemplatePartialSpecializationDecl *Decl) {
1268   DeclarationFragments Fragments;
1269   return Fragments
1270       .append("template", DeclarationFragments::FragmentKind::Keyword)
1271       .appendSpace()
1272       .append("<", DeclarationFragments::FragmentKind::Text)
1273       // Partial specs may have new params.
1274       .append(getFragmentsForTemplateParameters(
1275           Decl->getTemplateParameters()->asArray()))
1276       .append(">", DeclarationFragments::FragmentKind::Text)
1277       .appendSpace()
1278       .append(DeclarationFragmentsBuilder::getFragmentsForVarTemplate(Decl))
1279       .pop_back() // there is an extra semicolon now
1280       .append("<", DeclarationFragments::FragmentKind::Text)
1281       .append(getFragmentsForTemplateArguments(
1282           Decl->getTemplateArgs().asArray(), Decl->getASTContext(),
1283           Decl->getTemplateArgsAsWritten()->arguments()))
1284       .append(">", DeclarationFragments::FragmentKind::Text)
1285       .appendSemicolon();
1286 }
1287 
1288 DeclarationFragments
1289 DeclarationFragmentsBuilder::getFragmentsForFunctionTemplate(
1290     const FunctionTemplateDecl *Decl) {
1291   DeclarationFragments Fragments;
1292   return Fragments
1293       .append("template", DeclarationFragments::FragmentKind::Keyword)
1294       .appendSpace()
1295       .append("<", DeclarationFragments::FragmentKind::Text)
1296       // Partial specs may have new params.
1297       .append(getFragmentsForTemplateParameters(
1298           Decl->getTemplateParameters()->asArray()))
1299       .append(">", DeclarationFragments::FragmentKind::Text)
1300       .appendSpace()
1301       .append(DeclarationFragmentsBuilder::getFragmentsForFunction(
1302           Decl->getAsFunction()));
1303 }
1304 
1305 DeclarationFragments
1306 DeclarationFragmentsBuilder::getFragmentsForFunctionTemplateSpecialization(
1307     const FunctionDecl *Decl) {
1308   DeclarationFragments Fragments;
1309   return Fragments
1310       .append("template", DeclarationFragments::FragmentKind::Keyword)
1311       .appendSpace()
1312       .append("<>", DeclarationFragments::FragmentKind::Text)
1313       .appendSpace()
1314       .append(DeclarationFragmentsBuilder::getFragmentsForFunction(Decl));
1315 }
1316 
1317 DeclarationFragments
1318 DeclarationFragmentsBuilder::getFragmentsForMacro(StringRef Name,
1319                                                   const MacroDirective *MD) {
1320   DeclarationFragments Fragments;
1321   Fragments.append("#define", DeclarationFragments::FragmentKind::Keyword)
1322       .appendSpace();
1323   Fragments.append(Name, DeclarationFragments::FragmentKind::Identifier);
1324 
1325   auto *MI = MD->getMacroInfo();
1326 
1327   if (MI->isFunctionLike()) {
1328     Fragments.append("(", DeclarationFragments::FragmentKind::Text);
1329     unsigned numParameters = MI->getNumParams();
1330     if (MI->isC99Varargs())
1331       --numParameters;
1332     for (unsigned i = 0; i < numParameters; ++i) {
1333       if (i)
1334         Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1335       Fragments.append(MI->params()[i]->getName(),
1336                        DeclarationFragments::FragmentKind::InternalParam);
1337     }
1338     if (MI->isVariadic()) {
1339       if (numParameters && MI->isC99Varargs())
1340         Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1341       Fragments.append("...", DeclarationFragments::FragmentKind::Text);
1342     }
1343     Fragments.append(")", DeclarationFragments::FragmentKind::Text);
1344   }
1345   return Fragments;
1346 }
1347 
1348 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCCategory(
1349     const ObjCCategoryDecl *Category) {
1350   DeclarationFragments Fragments;
1351 
1352   auto *Interface = Category->getClassInterface();
1353   SmallString<128> InterfaceUSR;
1354   index::generateUSRForDecl(Interface, InterfaceUSR);
1355 
1356   Fragments.append("@interface", DeclarationFragments::FragmentKind::Keyword)
1357       .appendSpace()
1358       .append(Interface->getName(),
1359               DeclarationFragments::FragmentKind::TypeIdentifier, InterfaceUSR,
1360               Interface)
1361       .append(" (", DeclarationFragments::FragmentKind::Text)
1362       .append(Category->getName(),
1363               DeclarationFragments::FragmentKind::Identifier)
1364       .append(")", DeclarationFragments::FragmentKind::Text);
1365 
1366   return Fragments;
1367 }
1368 
1369 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCInterface(
1370     const ObjCInterfaceDecl *Interface) {
1371   DeclarationFragments Fragments;
1372   // Build the base of the Objective-C interface declaration.
1373   Fragments.append("@interface", DeclarationFragments::FragmentKind::Keyword)
1374       .appendSpace()
1375       .append(Interface->getName(),
1376               DeclarationFragments::FragmentKind::Identifier);
1377 
1378   // Build the inheritance part of the declaration.
1379   if (const ObjCInterfaceDecl *SuperClass = Interface->getSuperClass()) {
1380     SmallString<128> SuperUSR;
1381     index::generateUSRForDecl(SuperClass, SuperUSR);
1382     Fragments.append(" : ", DeclarationFragments::FragmentKind::Text)
1383         .append(SuperClass->getName(),
1384                 DeclarationFragments::FragmentKind::TypeIdentifier, SuperUSR,
1385                 SuperClass);
1386   }
1387 
1388   return Fragments;
1389 }
1390 
1391 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCMethod(
1392     const ObjCMethodDecl *Method) {
1393   DeclarationFragments Fragments, After;
1394   // Build the instance/class method indicator.
1395   if (Method->isClassMethod())
1396     Fragments.append("+ ", DeclarationFragments::FragmentKind::Text);
1397   else if (Method->isInstanceMethod())
1398     Fragments.append("- ", DeclarationFragments::FragmentKind::Text);
1399 
1400   // Build the return type.
1401   Fragments.append("(", DeclarationFragments::FragmentKind::Text)
1402       .append(getFragmentsForType(Method->getReturnType(),
1403                                   Method->getASTContext(), After))
1404       .append(std::move(After))
1405       .append(")", DeclarationFragments::FragmentKind::Text);
1406 
1407   // Build the selector part.
1408   Selector Selector = Method->getSelector();
1409   if (Selector.getNumArgs() == 0)
1410     // For Objective-C methods that don't take arguments, the first (and only)
1411     // slot of the selector is the method name.
1412     Fragments.appendSpace().append(
1413         Selector.getNameForSlot(0),
1414         DeclarationFragments::FragmentKind::Identifier);
1415 
1416   // For Objective-C methods that take arguments, build the selector slots.
1417   for (unsigned i = 0, end = Method->param_size(); i != end; ++i) {
1418     // Objective-C method selector parts are considered as identifiers instead
1419     // of "external parameters" as in Swift. This is because Objective-C method
1420     // symbols are referenced with the entire selector, instead of just the
1421     // method name in Swift.
1422     SmallString<32> ParamID(Selector.getNameForSlot(i));
1423     ParamID.append(":");
1424     Fragments.appendSpace().append(
1425         ParamID, DeclarationFragments::FragmentKind::Identifier);
1426 
1427     // Build the internal parameter.
1428     const ParmVarDecl *Param = Method->getParamDecl(i);
1429     Fragments.append(getFragmentsForParam(Param));
1430   }
1431 
1432   return Fragments.appendSemicolon();
1433 }
1434 
1435 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCProperty(
1436     const ObjCPropertyDecl *Property) {
1437   DeclarationFragments Fragments, After;
1438 
1439   // Build the Objective-C property keyword.
1440   Fragments.append("@property", DeclarationFragments::FragmentKind::Keyword);
1441 
1442   const auto Attributes = Property->getPropertyAttributesAsWritten();
1443   // Build the attributes if there is any associated with the property.
1444   if (Attributes != ObjCPropertyAttribute::kind_noattr) {
1445     // No leading comma for the first attribute.
1446     bool First = true;
1447     Fragments.append(" (", DeclarationFragments::FragmentKind::Text);
1448     // Helper function to render the attribute.
1449     auto RenderAttribute =
1450         [&](ObjCPropertyAttribute::Kind Kind, StringRef Spelling,
1451             StringRef Arg = "",
1452             DeclarationFragments::FragmentKind ArgKind =
1453                 DeclarationFragments::FragmentKind::Identifier) {
1454           // Check if the `Kind` attribute is set for this property.
1455           if ((Attributes & Kind) && !Spelling.empty()) {
1456             // Add a leading comma if this is not the first attribute rendered.
1457             if (!First)
1458               Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1459             // Render the spelling of this attribute `Kind` as a keyword.
1460             Fragments.append(Spelling,
1461                              DeclarationFragments::FragmentKind::Keyword);
1462             // If this attribute takes in arguments (e.g. `getter=getterName`),
1463             // render the arguments.
1464             if (!Arg.empty())
1465               Fragments.append("=", DeclarationFragments::FragmentKind::Text)
1466                   .append(Arg, ArgKind);
1467             First = false;
1468           }
1469         };
1470 
1471     // Go through all possible Objective-C property attributes and render set
1472     // ones.
1473     RenderAttribute(ObjCPropertyAttribute::kind_class, "class");
1474     RenderAttribute(ObjCPropertyAttribute::kind_direct, "direct");
1475     RenderAttribute(ObjCPropertyAttribute::kind_nonatomic, "nonatomic");
1476     RenderAttribute(ObjCPropertyAttribute::kind_atomic, "atomic");
1477     RenderAttribute(ObjCPropertyAttribute::kind_assign, "assign");
1478     RenderAttribute(ObjCPropertyAttribute::kind_retain, "retain");
1479     RenderAttribute(ObjCPropertyAttribute::kind_strong, "strong");
1480     RenderAttribute(ObjCPropertyAttribute::kind_copy, "copy");
1481     RenderAttribute(ObjCPropertyAttribute::kind_weak, "weak");
1482     RenderAttribute(ObjCPropertyAttribute::kind_unsafe_unretained,
1483                     "unsafe_unretained");
1484     RenderAttribute(ObjCPropertyAttribute::kind_readwrite, "readwrite");
1485     RenderAttribute(ObjCPropertyAttribute::kind_readonly, "readonly");
1486     RenderAttribute(ObjCPropertyAttribute::kind_getter, "getter",
1487                     Property->getGetterName().getAsString());
1488     RenderAttribute(ObjCPropertyAttribute::kind_setter, "setter",
1489                     Property->getSetterName().getAsString());
1490 
1491     // Render nullability attributes.
1492     if (Attributes & ObjCPropertyAttribute::kind_nullability) {
1493       QualType Type = Property->getType();
1494       if (const auto Nullability =
1495               AttributedType::stripOuterNullability(Type)) {
1496         if (!First)
1497           Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1498         if (*Nullability == NullabilityKind::Unspecified &&
1499             (Attributes & ObjCPropertyAttribute::kind_null_resettable))
1500           Fragments.append("null_resettable",
1501                            DeclarationFragments::FragmentKind::Keyword);
1502         else
1503           Fragments.append(
1504               getNullabilitySpelling(*Nullability, /*isContextSensitive=*/true),
1505               DeclarationFragments::FragmentKind::Keyword);
1506         First = false;
1507       }
1508     }
1509 
1510     Fragments.append(")", DeclarationFragments::FragmentKind::Text);
1511   }
1512 
1513   Fragments.appendSpace();
1514 
1515   FunctionTypeLoc BlockLoc;
1516   FunctionProtoTypeLoc BlockProtoLoc;
1517   findTypeLocForBlockDecl(Property->getTypeSourceInfo(), BlockLoc,
1518                           BlockProtoLoc);
1519 
1520   auto PropType = Property->getType();
1521   if (!BlockLoc)
1522     Fragments
1523         .append(getFragmentsForType(PropType, Property->getASTContext(), After))
1524         .appendSpace();
1525   else
1526     Fragments.append(
1527         getFragmentsForBlock(Property, BlockLoc, BlockProtoLoc, After));
1528 
1529   return Fragments
1530       .append(Property->getName(),
1531               DeclarationFragments::FragmentKind::Identifier)
1532       .append(std::move(After))
1533       .appendSemicolon();
1534 }
1535 
1536 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForObjCProtocol(
1537     const ObjCProtocolDecl *Protocol) {
1538   DeclarationFragments Fragments;
1539   // Build basic protocol declaration.
1540   Fragments.append("@protocol", DeclarationFragments::FragmentKind::Keyword)
1541       .appendSpace()
1542       .append(Protocol->getName(),
1543               DeclarationFragments::FragmentKind::Identifier);
1544 
1545   // If this protocol conforms to other protocols, build the conformance list.
1546   if (!Protocol->protocols().empty()) {
1547     Fragments.append(" <", DeclarationFragments::FragmentKind::Text);
1548     for (ObjCProtocolDecl::protocol_iterator It = Protocol->protocol_begin();
1549          It != Protocol->protocol_end(); It++) {
1550       // Add a leading comma if this is not the first protocol rendered.
1551       if (It != Protocol->protocol_begin())
1552         Fragments.append(", ", DeclarationFragments::FragmentKind::Text);
1553 
1554       SmallString<128> USR;
1555       index::generateUSRForDecl(*It, USR);
1556       Fragments.append((*It)->getName(),
1557                        DeclarationFragments::FragmentKind::TypeIdentifier, USR,
1558                        *It);
1559     }
1560     Fragments.append(">", DeclarationFragments::FragmentKind::Text);
1561   }
1562 
1563   return Fragments;
1564 }
1565 
1566 DeclarationFragments DeclarationFragmentsBuilder::getFragmentsForTypedef(
1567     const TypedefNameDecl *Decl) {
1568   DeclarationFragments Fragments, After;
1569   Fragments.append("typedef", DeclarationFragments::FragmentKind::Keyword)
1570       .appendSpace()
1571       .append(getFragmentsForType(Decl->getUnderlyingType(),
1572                                   Decl->getASTContext(), After))
1573       .append(std::move(After))
1574       .appendSpace()
1575       .append(Decl->getName(), DeclarationFragments::FragmentKind::Identifier);
1576 
1577   return Fragments.appendSemicolon();
1578 }
1579 
1580 // Instantiate template for FunctionDecl.
1581 template FunctionSignature
1582 DeclarationFragmentsBuilder::getFunctionSignature(const FunctionDecl *);
1583 
1584 // Instantiate template for ObjCMethodDecl.
1585 template FunctionSignature
1586 DeclarationFragmentsBuilder::getFunctionSignature(const ObjCMethodDecl *);
1587 
1588 // Subheading of a symbol defaults to its name.
1589 DeclarationFragments
1590 DeclarationFragmentsBuilder::getSubHeading(const NamedDecl *Decl) {
1591   DeclarationFragments Fragments;
1592   if (isa<CXXConstructorDecl>(Decl) || isa<CXXDestructorDecl>(Decl))
1593     Fragments.append(cast<CXXRecordDecl>(Decl->getDeclContext())->getName(),
1594                      DeclarationFragments::FragmentKind::Identifier);
1595   else if (isa<CXXConversionDecl>(Decl)) {
1596     Fragments.append(
1597         cast<CXXConversionDecl>(Decl)->getConversionType().getAsString(),
1598         DeclarationFragments::FragmentKind::Identifier);
1599   } else if (isa<CXXMethodDecl>(Decl) &&
1600              cast<CXXMethodDecl>(Decl)->isOverloadedOperator()) {
1601     Fragments.append(Decl->getNameAsString(),
1602                      DeclarationFragments::FragmentKind::Identifier);
1603   } else if (!Decl->getName().empty())
1604     Fragments.append(Decl->getName(),
1605                      DeclarationFragments::FragmentKind::Identifier);
1606   return Fragments;
1607 }
1608 
1609 // Subheading of an Objective-C method is a `+` or `-` sign indicating whether
1610 // it's a class method or an instance method, followed by the selector name.
1611 DeclarationFragments
1612 DeclarationFragmentsBuilder::getSubHeading(const ObjCMethodDecl *Method) {
1613   DeclarationFragments Fragments;
1614   if (Method->isClassMethod())
1615     Fragments.append("+ ", DeclarationFragments::FragmentKind::Text);
1616   else if (Method->isInstanceMethod())
1617     Fragments.append("- ", DeclarationFragments::FragmentKind::Text);
1618 
1619   return Fragments.append(Method->getNameAsString(),
1620                           DeclarationFragments::FragmentKind::Identifier);
1621 }
1622 
1623 // Subheading of a symbol defaults to its name.
1624 DeclarationFragments
1625 DeclarationFragmentsBuilder::getSubHeadingForMacro(StringRef Name) {
1626   DeclarationFragments Fragments;
1627   Fragments.append(Name, DeclarationFragments::FragmentKind::Identifier);
1628   return Fragments;
1629 }
1630