1 //===-- DeclarationName.cpp - Declaration names implementation --*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the DeclarationName and DeclarationNameTable
11 // classes.
12 //
13 //===----------------------------------------------------------------------===//
14 #include "clang/AST/DeclarationName.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/Type.h"
19 #include "clang/AST/TypeLoc.h"
20 #include "clang/AST/TypeOrdering.h"
21 #include "clang/Basic/IdentifierTable.h"
22 #include "llvm/ADT/FoldingSet.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/raw_ostream.h"
25 using namespace clang;
26 
27 namespace clang {
28 /// CXXSpecialName - Records the type associated with one of the
29 /// "special" kinds of declaration names in C++, e.g., constructors,
30 /// destructors, and conversion functions.
31 class CXXSpecialName
32   : public DeclarationNameExtra, public llvm::FoldingSetNode {
33 public:
34   /// Type - The type associated with this declaration name.
35   QualType Type;
36 
37   /// FETokenInfo - Extra information associated with this declaration
38   /// name that can be used by the front end.
39   void *FETokenInfo;
40 
41   void Profile(llvm::FoldingSetNodeID &ID) {
42     ID.AddInteger(ExtraKindOrNumArgs);
43     ID.AddPointer(Type.getAsOpaquePtr());
44   }
45 };
46 
47 /// Contains extra information for the name of a C++ deduction guide.
48 class CXXDeductionGuideNameExtra : public DeclarationNameExtra,
49                                    public llvm::FoldingSetNode {
50 public:
51   /// The template named by the deduction guide.
52   TemplateDecl *Template;
53 
54   /// FETokenInfo - Extra information associated with this operator
55   /// name that can be used by the front end.
56   void *FETokenInfo;
57 
58   void Profile(llvm::FoldingSetNodeID &ID) {
59     ID.AddPointer(Template);
60   }
61 };
62 
63 /// CXXOperatorIdName - Contains extra information for the name of an
64 /// overloaded operator in C++, such as "operator+.
65 class CXXOperatorIdName : public DeclarationNameExtra {
66 public:
67   /// FETokenInfo - Extra information associated with this operator
68   /// name that can be used by the front end.
69   void *FETokenInfo;
70 };
71 
72 /// CXXLiteralOperatorName - Contains the actual identifier that makes up the
73 /// name.
74 ///
75 /// This identifier is stored here rather than directly in DeclarationName so as
76 /// to allow Objective-C selectors, which are about a million times more common,
77 /// to consume minimal memory.
78 class CXXLiteralOperatorIdName
79   : public DeclarationNameExtra, public llvm::FoldingSetNode {
80 public:
81   IdentifierInfo *ID;
82 
83   /// FETokenInfo - Extra information associated with this operator
84   /// name that can be used by the front end.
85   void *FETokenInfo;
86 
87   void Profile(llvm::FoldingSetNodeID &FSID) {
88     FSID.AddPointer(ID);
89   }
90 };
91 
92 static int compareInt(unsigned A, unsigned B) {
93   return (A < B ? -1 : (A > B ? 1 : 0));
94 }
95 
96 int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
97   if (LHS.getNameKind() != RHS.getNameKind())
98     return (LHS.getNameKind() < RHS.getNameKind() ? -1 : 1);
99 
100   switch (LHS.getNameKind()) {
101   case DeclarationName::Identifier: {
102     IdentifierInfo *LII = LHS.getAsIdentifierInfo();
103     IdentifierInfo *RII = RHS.getAsIdentifierInfo();
104     if (!LII) return RII ? -1 : 0;
105     if (!RII) return 1;
106 
107     return LII->getName().compare(RII->getName());
108   }
109 
110   case DeclarationName::ObjCZeroArgSelector:
111   case DeclarationName::ObjCOneArgSelector:
112   case DeclarationName::ObjCMultiArgSelector: {
113     Selector LHSSelector = LHS.getObjCSelector();
114     Selector RHSSelector = RHS.getObjCSelector();
115     // getNumArgs for ZeroArgSelector returns 0, but we still need to compare.
116     if (LHS.getNameKind() == DeclarationName::ObjCZeroArgSelector &&
117         RHS.getNameKind() == DeclarationName::ObjCZeroArgSelector) {
118       return LHSSelector.getAsIdentifierInfo()->getName().compare(
119              RHSSelector.getAsIdentifierInfo()->getName());
120     }
121     unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
122     for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I) {
123       switch (LHSSelector.getNameForSlot(I).compare(
124                                                RHSSelector.getNameForSlot(I))) {
125       case -1: return -1;
126       case 1: return 1;
127       default: break;
128       }
129     }
130 
131     return compareInt(LN, RN);
132   }
133 
134   case DeclarationName::CXXConstructorName:
135   case DeclarationName::CXXDestructorName:
136   case DeclarationName::CXXConversionFunctionName:
137     if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType()))
138       return -1;
139     if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType()))
140       return 1;
141     return 0;
142 
143   case DeclarationName::CXXDeductionGuideName:
144     // We never want to compare deduction guide names for templates from
145     // different scopes, so just compare the template-name.
146     return compare(LHS.getCXXDeductionGuideTemplate()->getDeclName(),
147                    RHS.getCXXDeductionGuideTemplate()->getDeclName());
148 
149   case DeclarationName::CXXOperatorName:
150     return compareInt(LHS.getCXXOverloadedOperator(),
151                       RHS.getCXXOverloadedOperator());
152 
153   case DeclarationName::CXXLiteralOperatorName:
154     return LHS.getCXXLiteralIdentifier()->getName().compare(
155                                    RHS.getCXXLiteralIdentifier()->getName());
156 
157   case DeclarationName::CXXUsingDirective:
158     return 0;
159   }
160 
161   llvm_unreachable("Invalid DeclarationName Kind!");
162 }
163 
164 static void printCXXConstructorDestructorName(QualType ClassType,
165                                               raw_ostream &OS,
166                                               PrintingPolicy Policy) {
167   // We know we're printing C++ here. Ensure we print types properly.
168   Policy.adjustForCPlusPlus();
169 
170   if (const RecordType *ClassRec = ClassType->getAs<RecordType>()) {
171     OS << *ClassRec->getDecl();
172     return;
173   }
174   if (Policy.SuppressTemplateArgsInCXXConstructors) {
175     if (auto *InjTy = ClassType->getAs<InjectedClassNameType>()) {
176       OS << *InjTy->getDecl();
177       return;
178     }
179   }
180   ClassType.print(OS, Policy);
181 }
182 
183 void DeclarationName::print(raw_ostream &OS, const PrintingPolicy &Policy) {
184   DeclarationName &N = *this;
185   switch (N.getNameKind()) {
186   case DeclarationName::Identifier:
187     if (const IdentifierInfo *II = N.getAsIdentifierInfo())
188       OS << II->getName();
189     return;
190 
191   case DeclarationName::ObjCZeroArgSelector:
192   case DeclarationName::ObjCOneArgSelector:
193   case DeclarationName::ObjCMultiArgSelector:
194     N.getObjCSelector().print(OS);
195     return;
196 
197   case DeclarationName::CXXConstructorName:
198     return printCXXConstructorDestructorName(N.getCXXNameType(), OS, Policy);
199 
200   case DeclarationName::CXXDestructorName: {
201     OS << '~';
202     return printCXXConstructorDestructorName(N.getCXXNameType(), OS, Policy);
203   }
204 
205   case DeclarationName::CXXDeductionGuideName:
206     OS << "<deduction guide for ";
207     getCXXDeductionGuideTemplate()->getDeclName().print(OS, Policy);
208     OS << '>';
209     return;
210 
211   case DeclarationName::CXXOperatorName: {
212     static const char* const OperatorNames[NUM_OVERLOADED_OPERATORS] = {
213       nullptr,
214 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
215       Spelling,
216 #include "clang/Basic/OperatorKinds.def"
217     };
218     const char *OpName = OperatorNames[N.getCXXOverloadedOperator()];
219     assert(OpName && "not an overloaded operator");
220 
221     OS << "operator";
222     if (OpName[0] >= 'a' && OpName[0] <= 'z')
223       OS << ' ';
224     OS << OpName;
225     return;
226   }
227 
228   case DeclarationName::CXXLiteralOperatorName:
229     OS << "operator\"\"" << N.getCXXLiteralIdentifier()->getName();
230     return;
231 
232   case DeclarationName::CXXConversionFunctionName: {
233     OS << "operator ";
234     QualType Type = N.getCXXNameType();
235     if (const RecordType *Rec = Type->getAs<RecordType>()) {
236       OS << *Rec->getDecl();
237       return;
238     }
239     // We know we're printing C++ here, ensure we print 'bool' properly.
240     PrintingPolicy CXXPolicy = Policy;
241     CXXPolicy.adjustForCPlusPlus();
242     Type.print(OS, CXXPolicy);
243     return;
244   }
245   case DeclarationName::CXXUsingDirective:
246     OS << "<using-directive>";
247     return;
248   }
249 
250   llvm_unreachable("Unexpected declaration name kind");
251 }
252 
253 raw_ostream &operator<<(raw_ostream &OS, DeclarationName N) {
254   LangOptions LO;
255   N.print(OS, PrintingPolicy(LO));
256   return OS;
257 }
258 
259 } // end namespace clang
260 
261 DeclarationName::NameKind DeclarationName::getNameKind() const {
262   switch (getStoredNameKind()) {
263   case StoredIdentifier:          return Identifier;
264   case StoredObjCZeroArgSelector: return ObjCZeroArgSelector;
265   case StoredObjCOneArgSelector:  return ObjCOneArgSelector;
266 
267   case StoredDeclarationNameExtra:
268     switch (getExtra()->ExtraKindOrNumArgs) {
269     case DeclarationNameExtra::CXXConstructor:
270       return CXXConstructorName;
271 
272     case DeclarationNameExtra::CXXDestructor:
273       return CXXDestructorName;
274 
275     case DeclarationNameExtra::CXXDeductionGuide:
276       return CXXDeductionGuideName;
277 
278     case DeclarationNameExtra::CXXConversionFunction:
279       return CXXConversionFunctionName;
280 
281     case DeclarationNameExtra::CXXLiteralOperator:
282       return CXXLiteralOperatorName;
283 
284     case DeclarationNameExtra::CXXUsingDirective:
285       return CXXUsingDirective;
286 
287     default:
288       // Check if we have one of the CXXOperator* enumeration values.
289       if (getExtra()->ExtraKindOrNumArgs <
290             DeclarationNameExtra::CXXUsingDirective)
291         return CXXOperatorName;
292 
293       return ObjCMultiArgSelector;
294     }
295   }
296 
297   // Can't actually get here.
298   llvm_unreachable("This should be unreachable!");
299 }
300 
301 bool DeclarationName::isDependentName() const {
302   QualType T = getCXXNameType();
303   if (!T.isNull() && T->isDependentType())
304     return true;
305 
306   // A class-scope deduction guide in a dependent context has a dependent name.
307   auto *TD = getCXXDeductionGuideTemplate();
308   if (TD && TD->getDeclContext()->isDependentContext())
309     return true;
310 
311   return false;
312 }
313 
314 std::string DeclarationName::getAsString() const {
315   std::string Result;
316   llvm::raw_string_ostream OS(Result);
317   OS << *this;
318   return OS.str();
319 }
320 
321 QualType DeclarationName::getCXXNameType() const {
322   if (CXXSpecialName *CXXName = getAsCXXSpecialName())
323     return CXXName->Type;
324   else
325     return QualType();
326 }
327 
328 TemplateDecl *DeclarationName::getCXXDeductionGuideTemplate() const {
329   if (auto *Guide = getAsCXXDeductionGuideNameExtra())
330     return Guide->Template;
331   return nullptr;
332 }
333 
334 OverloadedOperatorKind DeclarationName::getCXXOverloadedOperator() const {
335   if (CXXOperatorIdName *CXXOp = getAsCXXOperatorIdName()) {
336     unsigned value
337       = CXXOp->ExtraKindOrNumArgs - DeclarationNameExtra::CXXConversionFunction;
338     return static_cast<OverloadedOperatorKind>(value);
339   } else {
340     return OO_None;
341   }
342 }
343 
344 IdentifierInfo *DeclarationName::getCXXLiteralIdentifier() const {
345   if (CXXLiteralOperatorIdName *CXXLit = getAsCXXLiteralOperatorIdName())
346     return CXXLit->ID;
347   else
348     return nullptr;
349 }
350 
351 void *DeclarationName::getFETokenInfoAsVoidSlow() const {
352   switch (getNameKind()) {
353   case Identifier:
354     llvm_unreachable("Handled by getFETokenInfo()");
355 
356   case CXXConstructorName:
357   case CXXDestructorName:
358   case CXXConversionFunctionName:
359     return getAsCXXSpecialName()->FETokenInfo;
360 
361   case CXXDeductionGuideName:
362     return getAsCXXDeductionGuideNameExtra()->FETokenInfo;
363 
364   case CXXOperatorName:
365     return getAsCXXOperatorIdName()->FETokenInfo;
366 
367   case CXXLiteralOperatorName:
368     return getAsCXXLiteralOperatorIdName()->FETokenInfo;
369 
370   default:
371     llvm_unreachable("Declaration name has no FETokenInfo");
372   }
373 }
374 
375 void DeclarationName::setFETokenInfo(void *T) {
376   switch (getNameKind()) {
377   case Identifier:
378     getAsIdentifierInfo()->setFETokenInfo(T);
379     break;
380 
381   case CXXConstructorName:
382   case CXXDestructorName:
383   case CXXConversionFunctionName:
384     getAsCXXSpecialName()->FETokenInfo = T;
385     break;
386 
387   case CXXDeductionGuideName:
388     getAsCXXDeductionGuideNameExtra()->FETokenInfo = T;
389     break;
390 
391   case CXXOperatorName:
392     getAsCXXOperatorIdName()->FETokenInfo = T;
393     break;
394 
395   case CXXLiteralOperatorName:
396     getAsCXXLiteralOperatorIdName()->FETokenInfo = T;
397     break;
398 
399   default:
400     llvm_unreachable("Declaration name has no FETokenInfo");
401   }
402 }
403 
404 DeclarationName DeclarationName::getUsingDirectiveName() {
405   // Single instance of DeclarationNameExtra for using-directive
406   static const DeclarationNameExtra UDirExtra =
407     { DeclarationNameExtra::CXXUsingDirective };
408 
409   uintptr_t Ptr = reinterpret_cast<uintptr_t>(&UDirExtra);
410   Ptr |= StoredDeclarationNameExtra;
411 
412   return DeclarationName(Ptr);
413 }
414 
415 LLVM_DUMP_METHOD void DeclarationName::dump() const {
416   llvm::errs() << *this << '\n';
417 }
418 
419 DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : Ctx(C) {
420   CXXSpecialNamesImpl = new llvm::FoldingSet<CXXSpecialName>;
421   CXXLiteralOperatorNames = new llvm::FoldingSet<CXXLiteralOperatorIdName>;
422   CXXDeductionGuideNames = new llvm::FoldingSet<CXXDeductionGuideNameExtra>;
423 
424   // Initialize the overloaded operator names.
425   CXXOperatorNames = new (Ctx) CXXOperatorIdName[NUM_OVERLOADED_OPERATORS];
426   for (unsigned Op = 0; Op < NUM_OVERLOADED_OPERATORS; ++Op) {
427     CXXOperatorNames[Op].ExtraKindOrNumArgs
428       = Op + DeclarationNameExtra::CXXConversionFunction;
429     CXXOperatorNames[Op].FETokenInfo = nullptr;
430   }
431 }
432 
433 DeclarationNameTable::~DeclarationNameTable() {
434   auto *SpecialNames =
435       static_cast<llvm::FoldingSet<CXXSpecialName> *>(CXXSpecialNamesImpl);
436   auto *LiteralNames =
437       static_cast<llvm::FoldingSet<CXXLiteralOperatorIdName> *>(
438           CXXLiteralOperatorNames);
439   auto *DeductionGuideNames =
440       static_cast<llvm::FoldingSet<CXXDeductionGuideNameExtra> *>(
441           CXXDeductionGuideNames);
442 
443   delete SpecialNames;
444   delete LiteralNames;
445   delete DeductionGuideNames;
446 }
447 
448 DeclarationName DeclarationNameTable::getCXXConstructorName(CanQualType Ty) {
449   return getCXXSpecialName(DeclarationName::CXXConstructorName,
450                            Ty.getUnqualifiedType());
451 }
452 
453 DeclarationName DeclarationNameTable::getCXXDestructorName(CanQualType Ty) {
454   return getCXXSpecialName(DeclarationName::CXXDestructorName,
455                            Ty.getUnqualifiedType());
456 }
457 
458 DeclarationName
459 DeclarationNameTable::getCXXDeductionGuideName(TemplateDecl *Template) {
460   Template = cast<TemplateDecl>(Template->getCanonicalDecl());
461 
462   auto *DeductionGuideNames =
463       static_cast<llvm::FoldingSet<CXXDeductionGuideNameExtra> *>(
464           CXXDeductionGuideNames);
465 
466   llvm::FoldingSetNodeID ID;
467   ID.AddPointer(Template);
468 
469   void *InsertPos = nullptr;
470   if (auto *Name = DeductionGuideNames->FindNodeOrInsertPos(ID, InsertPos))
471     return DeclarationName(Name);
472 
473   auto *Name = new (Ctx) CXXDeductionGuideNameExtra;
474   Name->ExtraKindOrNumArgs = DeclarationNameExtra::CXXDeductionGuide;
475   Name->Template = Template;
476   Name->FETokenInfo = nullptr;
477 
478   DeductionGuideNames->InsertNode(Name, InsertPos);
479   return DeclarationName(Name);
480 }
481 
482 DeclarationName
483 DeclarationNameTable::getCXXConversionFunctionName(CanQualType Ty) {
484   return getCXXSpecialName(DeclarationName::CXXConversionFunctionName, Ty);
485 }
486 
487 DeclarationName
488 DeclarationNameTable::getCXXSpecialName(DeclarationName::NameKind Kind,
489                                         CanQualType Ty) {
490   assert(Kind >= DeclarationName::CXXConstructorName &&
491          Kind <= DeclarationName::CXXConversionFunctionName &&
492          "Kind must be a C++ special name kind");
493   llvm::FoldingSet<CXXSpecialName> *SpecialNames
494     = static_cast<llvm::FoldingSet<CXXSpecialName>*>(CXXSpecialNamesImpl);
495 
496   DeclarationNameExtra::ExtraKind EKind;
497   switch (Kind) {
498   case DeclarationName::CXXConstructorName:
499     EKind = DeclarationNameExtra::CXXConstructor;
500     assert(!Ty.hasQualifiers() &&"Constructor type must be unqualified");
501     break;
502   case DeclarationName::CXXDestructorName:
503     EKind = DeclarationNameExtra::CXXDestructor;
504     assert(!Ty.hasQualifiers() && "Destructor type must be unqualified");
505     break;
506   case DeclarationName::CXXConversionFunctionName:
507     EKind = DeclarationNameExtra::CXXConversionFunction;
508     break;
509   default:
510     return DeclarationName();
511   }
512 
513   // Unique selector, to guarantee there is one per name.
514   llvm::FoldingSetNodeID ID;
515   ID.AddInteger(EKind);
516   ID.AddPointer(Ty.getAsOpaquePtr());
517 
518   void *InsertPos = nullptr;
519   if (CXXSpecialName *Name = SpecialNames->FindNodeOrInsertPos(ID, InsertPos))
520     return DeclarationName(Name);
521 
522   CXXSpecialName *SpecialName = new (Ctx) CXXSpecialName;
523   SpecialName->ExtraKindOrNumArgs = EKind;
524   SpecialName->Type = Ty;
525   SpecialName->FETokenInfo = nullptr;
526 
527   SpecialNames->InsertNode(SpecialName, InsertPos);
528   return DeclarationName(SpecialName);
529 }
530 
531 DeclarationName
532 DeclarationNameTable::getCXXOperatorName(OverloadedOperatorKind Op) {
533   return DeclarationName(&CXXOperatorNames[(unsigned)Op]);
534 }
535 
536 DeclarationName
537 DeclarationNameTable::getCXXLiteralOperatorName(IdentifierInfo *II) {
538   llvm::FoldingSet<CXXLiteralOperatorIdName> *LiteralNames
539     = static_cast<llvm::FoldingSet<CXXLiteralOperatorIdName>*>
540                                                       (CXXLiteralOperatorNames);
541 
542   llvm::FoldingSetNodeID ID;
543   ID.AddPointer(II);
544 
545   void *InsertPos = nullptr;
546   if (CXXLiteralOperatorIdName *Name =
547                                LiteralNames->FindNodeOrInsertPos(ID, InsertPos))
548     return DeclarationName (Name);
549 
550   CXXLiteralOperatorIdName *LiteralName = new (Ctx) CXXLiteralOperatorIdName;
551   LiteralName->ExtraKindOrNumArgs = DeclarationNameExtra::CXXLiteralOperator;
552   LiteralName->ID = II;
553   LiteralName->FETokenInfo = nullptr;
554 
555   LiteralNames->InsertNode(LiteralName, InsertPos);
556   return DeclarationName(LiteralName);
557 }
558 
559 DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) {
560   switch (Name.getNameKind()) {
561   case DeclarationName::Identifier:
562   case DeclarationName::CXXDeductionGuideName:
563     break;
564   case DeclarationName::CXXConstructorName:
565   case DeclarationName::CXXDestructorName:
566   case DeclarationName::CXXConversionFunctionName:
567     NamedType.TInfo = nullptr;
568     break;
569   case DeclarationName::CXXOperatorName:
570     CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
571     CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
572     break;
573   case DeclarationName::CXXLiteralOperatorName:
574     CXXLiteralOperatorName.OpNameLoc = SourceLocation().getRawEncoding();
575     break;
576   case DeclarationName::ObjCZeroArgSelector:
577   case DeclarationName::ObjCOneArgSelector:
578   case DeclarationName::ObjCMultiArgSelector:
579     // FIXME: ?
580     break;
581   case DeclarationName::CXXUsingDirective:
582     break;
583   }
584 }
585 
586 bool DeclarationNameInfo::containsUnexpandedParameterPack() const {
587   switch (Name.getNameKind()) {
588   case DeclarationName::Identifier:
589   case DeclarationName::ObjCZeroArgSelector:
590   case DeclarationName::ObjCOneArgSelector:
591   case DeclarationName::ObjCMultiArgSelector:
592   case DeclarationName::CXXOperatorName:
593   case DeclarationName::CXXLiteralOperatorName:
594   case DeclarationName::CXXUsingDirective:
595   case DeclarationName::CXXDeductionGuideName:
596     return false;
597 
598   case DeclarationName::CXXConstructorName:
599   case DeclarationName::CXXDestructorName:
600   case DeclarationName::CXXConversionFunctionName:
601     if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
602       return TInfo->getType()->containsUnexpandedParameterPack();
603 
604     return Name.getCXXNameType()->containsUnexpandedParameterPack();
605   }
606   llvm_unreachable("All name kinds handled.");
607 }
608 
609 bool DeclarationNameInfo::isInstantiationDependent() const {
610   switch (Name.getNameKind()) {
611   case DeclarationName::Identifier:
612   case DeclarationName::ObjCZeroArgSelector:
613   case DeclarationName::ObjCOneArgSelector:
614   case DeclarationName::ObjCMultiArgSelector:
615   case DeclarationName::CXXOperatorName:
616   case DeclarationName::CXXLiteralOperatorName:
617   case DeclarationName::CXXUsingDirective:
618   case DeclarationName::CXXDeductionGuideName:
619     return false;
620 
621   case DeclarationName::CXXConstructorName:
622   case DeclarationName::CXXDestructorName:
623   case DeclarationName::CXXConversionFunctionName:
624     if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
625       return TInfo->getType()->isInstantiationDependentType();
626 
627     return Name.getCXXNameType()->isInstantiationDependentType();
628   }
629   llvm_unreachable("All name kinds handled.");
630 }
631 
632 std::string DeclarationNameInfo::getAsString() const {
633   std::string Result;
634   llvm::raw_string_ostream OS(Result);
635   printName(OS);
636   return OS.str();
637 }
638 
639 void DeclarationNameInfo::printName(raw_ostream &OS) const {
640   switch (Name.getNameKind()) {
641   case DeclarationName::Identifier:
642   case DeclarationName::ObjCZeroArgSelector:
643   case DeclarationName::ObjCOneArgSelector:
644   case DeclarationName::ObjCMultiArgSelector:
645   case DeclarationName::CXXOperatorName:
646   case DeclarationName::CXXLiteralOperatorName:
647   case DeclarationName::CXXUsingDirective:
648   case DeclarationName::CXXDeductionGuideName:
649     OS << Name;
650     return;
651 
652   case DeclarationName::CXXConstructorName:
653   case DeclarationName::CXXDestructorName:
654   case DeclarationName::CXXConversionFunctionName:
655     if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo) {
656       if (Name.getNameKind() == DeclarationName::CXXDestructorName)
657         OS << '~';
658       else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
659         OS << "operator ";
660       LangOptions LO;
661       LO.CPlusPlus = true;
662       LO.Bool = true;
663       PrintingPolicy PP(LO);
664       PP.SuppressScope = true;
665       OS << TInfo->getType().getAsString(PP);
666     } else
667       OS << Name;
668     return;
669   }
670   llvm_unreachable("Unexpected declaration name kind");
671 }
672 
673 SourceLocation DeclarationNameInfo::getEndLoc() const {
674   switch (Name.getNameKind()) {
675   case DeclarationName::Identifier:
676   case DeclarationName::CXXDeductionGuideName:
677     return NameLoc;
678 
679   case DeclarationName::CXXOperatorName: {
680     unsigned raw = LocInfo.CXXOperatorName.EndOpNameLoc;
681     return SourceLocation::getFromRawEncoding(raw);
682   }
683 
684   case DeclarationName::CXXLiteralOperatorName: {
685     unsigned raw = LocInfo.CXXLiteralOperatorName.OpNameLoc;
686     return SourceLocation::getFromRawEncoding(raw);
687   }
688 
689   case DeclarationName::CXXConstructorName:
690   case DeclarationName::CXXDestructorName:
691   case DeclarationName::CXXConversionFunctionName:
692     if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
693       return TInfo->getTypeLoc().getEndLoc();
694     else
695       return NameLoc;
696 
697     // DNInfo work in progress: FIXME.
698   case DeclarationName::ObjCZeroArgSelector:
699   case DeclarationName::ObjCOneArgSelector:
700   case DeclarationName::ObjCMultiArgSelector:
701   case DeclarationName::CXXUsingDirective:
702     return NameLoc;
703   }
704   llvm_unreachable("Unexpected declaration name kind");
705 }
706