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