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