1 //===- DeclarationName.cpp - Declaration names implementation -------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the DeclarationName and DeclarationNameTable
13 //===----------------------------------------------------------------------===//
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"
40 using namespace clang;
44 /// CXXSpecialName - Records the type associated with one of the
45 /// "special" kinds of declaration names in C++, e.g., constructors,
46 /// destructors, and conversion functions.
48 : public DeclarationNameExtra, public llvm::FoldingSetNode {
50 /// Type - The type associated with this declaration name.
53 /// FETokenInfo - Extra information associated with this declaration
54 /// name that can be used by the front end.
57 void Profile(llvm::FoldingSetNodeID &ID) {
58 ID.AddInteger(ExtraKindOrNumArgs);
59 ID.AddPointer(Type.getAsOpaquePtr());
63 /// Contains extra information for the name of a C++ deduction guide.
64 class CXXDeductionGuideNameExtra : public DeclarationNameExtra,
65 public llvm::FoldingSetNode {
67 /// The template named by the deduction guide.
68 TemplateDecl *Template;
70 /// FETokenInfo - Extra information associated with this operator
71 /// name that can be used by the front end.
74 void Profile(llvm::FoldingSetNodeID &ID) {
75 ID.AddPointer(Template);
79 /// CXXOperatorIdName - Contains extra information for the name of an
80 /// overloaded operator in C++, such as "operator+.
81 class CXXOperatorIdName : public DeclarationNameExtra {
83 /// FETokenInfo - Extra information associated with this operator
84 /// name that can be used by the front end.
88 /// CXXLiteralOperatorName - Contains the actual identifier that makes up the
91 /// This identifier is stored here rather than directly in DeclarationName so as
92 /// to allow Objective-C selectors, which are about a million times more common,
93 /// to consume minimal memory.
94 class CXXLiteralOperatorIdName
95 : public DeclarationNameExtra, public llvm::FoldingSetNode {
99 /// FETokenInfo - Extra information associated with this operator
100 /// name that can be used by the front end.
103 void Profile(llvm::FoldingSetNodeID &FSID) {
110 static int compareInt(unsigned A, unsigned B) {
111 return (A < B ? -1 : (A > B ? 1 : 0));
114 int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
115 if (LHS.getNameKind() != RHS.getNameKind())
116 return (LHS.getNameKind() < RHS.getNameKind() ? -1 : 1);
118 switch (LHS.getNameKind()) {
119 case DeclarationName::Identifier: {
120 IdentifierInfo *LII = LHS.getAsIdentifierInfo();
121 IdentifierInfo *RII = RHS.getAsIdentifierInfo();
122 if (!LII) return RII ? -1 : 0;
125 return LII->getName().compare(RII->getName());
128 case DeclarationName::ObjCZeroArgSelector:
129 case DeclarationName::ObjCOneArgSelector:
130 case DeclarationName::ObjCMultiArgSelector: {
131 Selector LHSSelector = LHS.getObjCSelector();
132 Selector RHSSelector = RHS.getObjCSelector();
133 // getNumArgs for ZeroArgSelector returns 0, but we still need to compare.
134 if (LHS.getNameKind() == DeclarationName::ObjCZeroArgSelector &&
135 RHS.getNameKind() == DeclarationName::ObjCZeroArgSelector) {
136 return LHSSelector.getAsIdentifierInfo()->getName().compare(
137 RHSSelector.getAsIdentifierInfo()->getName());
139 unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
140 for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I) {
141 switch (LHSSelector.getNameForSlot(I).compare(
142 RHSSelector.getNameForSlot(I))) {
149 return compareInt(LN, RN);
152 case DeclarationName::CXXConstructorName:
153 case DeclarationName::CXXDestructorName:
154 case DeclarationName::CXXConversionFunctionName:
155 if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType()))
157 if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType()))
161 case DeclarationName::CXXDeductionGuideName:
162 // We never want to compare deduction guide names for templates from
163 // different scopes, so just compare the template-name.
164 return compare(LHS.getCXXDeductionGuideTemplate()->getDeclName(),
165 RHS.getCXXDeductionGuideTemplate()->getDeclName());
167 case DeclarationName::CXXOperatorName:
168 return compareInt(LHS.getCXXOverloadedOperator(),
169 RHS.getCXXOverloadedOperator());
171 case DeclarationName::CXXLiteralOperatorName:
172 return LHS.getCXXLiteralIdentifier()->getName().compare(
173 RHS.getCXXLiteralIdentifier()->getName());
175 case DeclarationName::CXXUsingDirective:
179 llvm_unreachable("Invalid DeclarationName Kind!");
182 static void printCXXConstructorDestructorName(QualType ClassType,
184 PrintingPolicy Policy) {
185 // We know we're printing C++ here. Ensure we print types properly.
186 Policy.adjustForCPlusPlus();
188 if (const RecordType *ClassRec = ClassType->getAs<RecordType>()) {
189 OS << *ClassRec->getDecl();
192 if (Policy.SuppressTemplateArgsInCXXConstructors) {
193 if (auto *InjTy = ClassType->getAs<InjectedClassNameType>()) {
194 OS << *InjTy->getDecl();
198 ClassType.print(OS, Policy);
201 void DeclarationName::print(raw_ostream &OS, const PrintingPolicy &Policy) {
202 DeclarationName &N = *this;
203 switch (N.getNameKind()) {
204 case DeclarationName::Identifier:
205 if (const IdentifierInfo *II = N.getAsIdentifierInfo())
209 case DeclarationName::ObjCZeroArgSelector:
210 case DeclarationName::ObjCOneArgSelector:
211 case DeclarationName::ObjCMultiArgSelector:
212 N.getObjCSelector().print(OS);
215 case DeclarationName::CXXConstructorName:
216 return printCXXConstructorDestructorName(N.getCXXNameType(), OS, Policy);
218 case DeclarationName::CXXDestructorName:
220 return printCXXConstructorDestructorName(N.getCXXNameType(), OS, Policy);
222 case DeclarationName::CXXDeductionGuideName:
223 OS << "<deduction guide for ";
224 getCXXDeductionGuideTemplate()->getDeclName().print(OS, Policy);
228 case DeclarationName::CXXOperatorName: {
229 static const char* const OperatorNames[NUM_OVERLOADED_OPERATORS] = {
231 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
233 #include "clang/Basic/OperatorKinds.def"
235 const char *OpName = OperatorNames[N.getCXXOverloadedOperator()];
236 assert(OpName && "not an overloaded operator");
239 if (OpName[0] >= 'a' && OpName[0] <= 'z')
245 case DeclarationName::CXXLiteralOperatorName:
246 OS << "operator\"\"" << N.getCXXLiteralIdentifier()->getName();
249 case DeclarationName::CXXConversionFunctionName: {
251 QualType Type = N.getCXXNameType();
252 if (const RecordType *Rec = Type->getAs<RecordType>()) {
253 OS << *Rec->getDecl();
256 // We know we're printing C++ here, ensure we print 'bool' properly.
257 PrintingPolicy CXXPolicy = Policy;
258 CXXPolicy.adjustForCPlusPlus();
259 Type.print(OS, CXXPolicy);
262 case DeclarationName::CXXUsingDirective:
263 OS << "<using-directive>";
267 llvm_unreachable("Unexpected declaration name kind");
272 raw_ostream &operator<<(raw_ostream &OS, DeclarationName N) {
274 N.print(OS, PrintingPolicy(LO));
280 DeclarationName::NameKind DeclarationName::getNameKind() const {
281 switch (getStoredNameKind()) {
282 case StoredIdentifier: return Identifier;
283 case StoredObjCZeroArgSelector: return ObjCZeroArgSelector;
284 case StoredObjCOneArgSelector: return ObjCOneArgSelector;
286 case StoredDeclarationNameExtra:
287 switch (getExtra()->ExtraKindOrNumArgs) {
288 case DeclarationNameExtra::CXXConstructor:
289 return CXXConstructorName;
291 case DeclarationNameExtra::CXXDestructor:
292 return CXXDestructorName;
294 case DeclarationNameExtra::CXXDeductionGuide:
295 return CXXDeductionGuideName;
297 case DeclarationNameExtra::CXXConversionFunction:
298 return CXXConversionFunctionName;
300 case DeclarationNameExtra::CXXLiteralOperator:
301 return CXXLiteralOperatorName;
303 case DeclarationNameExtra::CXXUsingDirective:
304 return CXXUsingDirective;
307 // Check if we have one of the CXXOperator* enumeration values.
308 if (getExtra()->ExtraKindOrNumArgs <
309 DeclarationNameExtra::CXXUsingDirective)
310 return CXXOperatorName;
312 return ObjCMultiArgSelector;
316 // Can't actually get here.
317 llvm_unreachable("This should be unreachable!");
320 bool DeclarationName::isDependentName() const {
321 QualType T = getCXXNameType();
322 if (!T.isNull() && T->isDependentType())
325 // A class-scope deduction guide in a dependent context has a dependent name.
326 auto *TD = getCXXDeductionGuideTemplate();
327 if (TD && TD->getDeclContext()->isDependentContext())
333 std::string DeclarationName::getAsString() const {
335 llvm::raw_string_ostream OS(Result);
340 QualType DeclarationName::getCXXNameType() const {
341 if (CXXSpecialName *CXXName = getAsCXXSpecialName())
342 return CXXName->Type;
347 TemplateDecl *DeclarationName::getCXXDeductionGuideTemplate() const {
348 if (auto *Guide = getAsCXXDeductionGuideNameExtra())
349 return Guide->Template;
353 OverloadedOperatorKind DeclarationName::getCXXOverloadedOperator() const {
354 if (CXXOperatorIdName *CXXOp = getAsCXXOperatorIdName()) {
356 = CXXOp->ExtraKindOrNumArgs - DeclarationNameExtra::CXXConversionFunction;
357 return static_cast<OverloadedOperatorKind>(value);
363 IdentifierInfo *DeclarationName::getCXXLiteralIdentifier() const {
364 if (CXXLiteralOperatorIdName *CXXLit = getAsCXXLiteralOperatorIdName())
370 void *DeclarationName::getFETokenInfoAsVoidSlow() const {
371 switch (getNameKind()) {
373 llvm_unreachable("Handled by getFETokenInfo()");
375 case CXXConstructorName:
376 case CXXDestructorName:
377 case CXXConversionFunctionName:
378 return getAsCXXSpecialName()->FETokenInfo;
380 case CXXDeductionGuideName:
381 return getAsCXXDeductionGuideNameExtra()->FETokenInfo;
383 case CXXOperatorName:
384 return getAsCXXOperatorIdName()->FETokenInfo;
386 case CXXLiteralOperatorName:
387 return getAsCXXLiteralOperatorIdName()->FETokenInfo;
390 llvm_unreachable("Declaration name has no FETokenInfo");
394 void DeclarationName::setFETokenInfo(void *T) {
395 switch (getNameKind()) {
397 getAsIdentifierInfo()->setFETokenInfo(T);
400 case CXXConstructorName:
401 case CXXDestructorName:
402 case CXXConversionFunctionName:
403 getAsCXXSpecialName()->FETokenInfo = T;
406 case CXXDeductionGuideName:
407 getAsCXXDeductionGuideNameExtra()->FETokenInfo = T;
410 case CXXOperatorName:
411 getAsCXXOperatorIdName()->FETokenInfo = T;
414 case CXXLiteralOperatorName:
415 getAsCXXLiteralOperatorIdName()->FETokenInfo = T;
419 llvm_unreachable("Declaration name has no FETokenInfo");
423 DeclarationName DeclarationName::getUsingDirectiveName() {
424 // Single instance of DeclarationNameExtra for using-directive
425 static const DeclarationNameExtra UDirExtra =
426 { DeclarationNameExtra::CXXUsingDirective };
428 uintptr_t Ptr = reinterpret_cast<uintptr_t>(&UDirExtra);
429 Ptr |= StoredDeclarationNameExtra;
431 return DeclarationName(Ptr);
434 LLVM_DUMP_METHOD void DeclarationName::dump() const {
435 llvm::errs() << *this << '\n';
438 DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : Ctx(C) {
439 CXXSpecialNamesImpl = new llvm::FoldingSet<CXXSpecialName>;
440 CXXLiteralOperatorNames = new llvm::FoldingSet<CXXLiteralOperatorIdName>;
441 CXXDeductionGuideNames = new llvm::FoldingSet<CXXDeductionGuideNameExtra>;
443 // Initialize the overloaded operator names.
444 CXXOperatorNames = new (Ctx) CXXOperatorIdName[NUM_OVERLOADED_OPERATORS];
445 for (unsigned Op = 0; Op < NUM_OVERLOADED_OPERATORS; ++Op) {
446 CXXOperatorNames[Op].ExtraKindOrNumArgs
447 = Op + DeclarationNameExtra::CXXConversionFunction;
448 CXXOperatorNames[Op].FETokenInfo = nullptr;
452 DeclarationNameTable::~DeclarationNameTable() {
454 static_cast<llvm::FoldingSet<CXXSpecialName> *>(CXXSpecialNamesImpl);
456 static_cast<llvm::FoldingSet<CXXLiteralOperatorIdName> *>(
457 CXXLiteralOperatorNames);
458 auto *DeductionGuideNames =
459 static_cast<llvm::FoldingSet<CXXDeductionGuideNameExtra> *>(
460 CXXDeductionGuideNames);
464 delete DeductionGuideNames;
467 DeclarationName DeclarationNameTable::getCXXConstructorName(CanQualType Ty) {
468 return getCXXSpecialName(DeclarationName::CXXConstructorName,
469 Ty.getUnqualifiedType());
472 DeclarationName DeclarationNameTable::getCXXDestructorName(CanQualType Ty) {
473 return getCXXSpecialName(DeclarationName::CXXDestructorName,
474 Ty.getUnqualifiedType());
478 DeclarationNameTable::getCXXDeductionGuideName(TemplateDecl *Template) {
479 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
481 auto *DeductionGuideNames =
482 static_cast<llvm::FoldingSet<CXXDeductionGuideNameExtra> *>(
483 CXXDeductionGuideNames);
485 llvm::FoldingSetNodeID ID;
486 ID.AddPointer(Template);
488 void *InsertPos = nullptr;
489 if (auto *Name = DeductionGuideNames->FindNodeOrInsertPos(ID, InsertPos))
490 return DeclarationName(Name);
492 auto *Name = new (Ctx) CXXDeductionGuideNameExtra;
493 Name->ExtraKindOrNumArgs = DeclarationNameExtra::CXXDeductionGuide;
494 Name->Template = Template;
495 Name->FETokenInfo = nullptr;
497 DeductionGuideNames->InsertNode(Name, InsertPos);
498 return DeclarationName(Name);
502 DeclarationNameTable::getCXXConversionFunctionName(CanQualType Ty) {
503 return getCXXSpecialName(DeclarationName::CXXConversionFunctionName, Ty);
507 DeclarationNameTable::getCXXSpecialName(DeclarationName::NameKind Kind,
509 assert(Kind >= DeclarationName::CXXConstructorName &&
510 Kind <= DeclarationName::CXXConversionFunctionName &&
511 "Kind must be a C++ special name kind");
512 llvm::FoldingSet<CXXSpecialName> *SpecialNames
513 = static_cast<llvm::FoldingSet<CXXSpecialName>*>(CXXSpecialNamesImpl);
515 DeclarationNameExtra::ExtraKind EKind;
517 case DeclarationName::CXXConstructorName:
518 EKind = DeclarationNameExtra::CXXConstructor;
519 assert(!Ty.hasQualifiers() &&"Constructor type must be unqualified");
521 case DeclarationName::CXXDestructorName:
522 EKind = DeclarationNameExtra::CXXDestructor;
523 assert(!Ty.hasQualifiers() && "Destructor type must be unqualified");
525 case DeclarationName::CXXConversionFunctionName:
526 EKind = DeclarationNameExtra::CXXConversionFunction;
529 return DeclarationName();
532 // Unique selector, to guarantee there is one per name.
533 llvm::FoldingSetNodeID ID;
534 ID.AddInteger(EKind);
535 ID.AddPointer(Ty.getAsOpaquePtr());
537 void *InsertPos = nullptr;
538 if (CXXSpecialName *Name = SpecialNames->FindNodeOrInsertPos(ID, InsertPos))
539 return DeclarationName(Name);
541 CXXSpecialName *SpecialName = new (Ctx) CXXSpecialName;
542 SpecialName->ExtraKindOrNumArgs = EKind;
543 SpecialName->Type = Ty;
544 SpecialName->FETokenInfo = nullptr;
546 SpecialNames->InsertNode(SpecialName, InsertPos);
547 return DeclarationName(SpecialName);
551 DeclarationNameTable::getCXXOperatorName(OverloadedOperatorKind Op) {
552 return DeclarationName(&CXXOperatorNames[(unsigned)Op]);
556 DeclarationNameTable::getCXXLiteralOperatorName(IdentifierInfo *II) {
557 llvm::FoldingSet<CXXLiteralOperatorIdName> *LiteralNames
558 = static_cast<llvm::FoldingSet<CXXLiteralOperatorIdName>*>
559 (CXXLiteralOperatorNames);
561 llvm::FoldingSetNodeID ID;
564 void *InsertPos = nullptr;
565 if (CXXLiteralOperatorIdName *Name =
566 LiteralNames->FindNodeOrInsertPos(ID, InsertPos))
567 return DeclarationName (Name);
569 CXXLiteralOperatorIdName *LiteralName = new (Ctx) CXXLiteralOperatorIdName;
570 LiteralName->ExtraKindOrNumArgs = DeclarationNameExtra::CXXLiteralOperator;
571 LiteralName->ID = II;
572 LiteralName->FETokenInfo = nullptr;
574 LiteralNames->InsertNode(LiteralName, InsertPos);
575 return DeclarationName(LiteralName);
578 DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) {
579 switch (Name.getNameKind()) {
580 case DeclarationName::Identifier:
581 case DeclarationName::CXXDeductionGuideName:
583 case DeclarationName::CXXConstructorName:
584 case DeclarationName::CXXDestructorName:
585 case DeclarationName::CXXConversionFunctionName:
586 NamedType.TInfo = nullptr;
588 case DeclarationName::CXXOperatorName:
589 CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
590 CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
592 case DeclarationName::CXXLiteralOperatorName:
593 CXXLiteralOperatorName.OpNameLoc = SourceLocation().getRawEncoding();
595 case DeclarationName::ObjCZeroArgSelector:
596 case DeclarationName::ObjCOneArgSelector:
597 case DeclarationName::ObjCMultiArgSelector:
600 case DeclarationName::CXXUsingDirective:
605 bool DeclarationNameInfo::containsUnexpandedParameterPack() const {
606 switch (Name.getNameKind()) {
607 case DeclarationName::Identifier:
608 case DeclarationName::ObjCZeroArgSelector:
609 case DeclarationName::ObjCOneArgSelector:
610 case DeclarationName::ObjCMultiArgSelector:
611 case DeclarationName::CXXOperatorName:
612 case DeclarationName::CXXLiteralOperatorName:
613 case DeclarationName::CXXUsingDirective:
614 case DeclarationName::CXXDeductionGuideName:
617 case DeclarationName::CXXConstructorName:
618 case DeclarationName::CXXDestructorName:
619 case DeclarationName::CXXConversionFunctionName:
620 if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
621 return TInfo->getType()->containsUnexpandedParameterPack();
623 return Name.getCXXNameType()->containsUnexpandedParameterPack();
625 llvm_unreachable("All name kinds handled.");
628 bool DeclarationNameInfo::isInstantiationDependent() const {
629 switch (Name.getNameKind()) {
630 case DeclarationName::Identifier:
631 case DeclarationName::ObjCZeroArgSelector:
632 case DeclarationName::ObjCOneArgSelector:
633 case DeclarationName::ObjCMultiArgSelector:
634 case DeclarationName::CXXOperatorName:
635 case DeclarationName::CXXLiteralOperatorName:
636 case DeclarationName::CXXUsingDirective:
637 case DeclarationName::CXXDeductionGuideName:
640 case DeclarationName::CXXConstructorName:
641 case DeclarationName::CXXDestructorName:
642 case DeclarationName::CXXConversionFunctionName:
643 if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
644 return TInfo->getType()->isInstantiationDependentType();
646 return Name.getCXXNameType()->isInstantiationDependentType();
648 llvm_unreachable("All name kinds handled.");
651 std::string DeclarationNameInfo::getAsString() const {
653 llvm::raw_string_ostream OS(Result);
658 void DeclarationNameInfo::printName(raw_ostream &OS) const {
659 switch (Name.getNameKind()) {
660 case DeclarationName::Identifier:
661 case DeclarationName::ObjCZeroArgSelector:
662 case DeclarationName::ObjCOneArgSelector:
663 case DeclarationName::ObjCMultiArgSelector:
664 case DeclarationName::CXXOperatorName:
665 case DeclarationName::CXXLiteralOperatorName:
666 case DeclarationName::CXXUsingDirective:
667 case DeclarationName::CXXDeductionGuideName:
671 case DeclarationName::CXXConstructorName:
672 case DeclarationName::CXXDestructorName:
673 case DeclarationName::CXXConversionFunctionName:
674 if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo) {
675 if (Name.getNameKind() == DeclarationName::CXXDestructorName)
677 else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
682 PrintingPolicy PP(LO);
683 PP.SuppressScope = true;
684 OS << TInfo->getType().getAsString(PP);
689 llvm_unreachable("Unexpected declaration name kind");
692 SourceLocation DeclarationNameInfo::getEndLoc() const {
693 switch (Name.getNameKind()) {
694 case DeclarationName::Identifier:
695 case DeclarationName::CXXDeductionGuideName:
698 case DeclarationName::CXXOperatorName: {
699 unsigned raw = LocInfo.CXXOperatorName.EndOpNameLoc;
700 return SourceLocation::getFromRawEncoding(raw);
703 case DeclarationName::CXXLiteralOperatorName: {
704 unsigned raw = LocInfo.CXXLiteralOperatorName.OpNameLoc;
705 return SourceLocation::getFromRawEncoding(raw);
708 case DeclarationName::CXXConstructorName:
709 case DeclarationName::CXXDestructorName:
710 case DeclarationName::CXXConversionFunctionName:
711 if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
712 return TInfo->getTypeLoc().getEndLoc();
716 // DNInfo work in progress: FIXME.
717 case DeclarationName::ObjCZeroArgSelector:
718 case DeclarationName::ObjCOneArgSelector:
719 case DeclarationName::ObjCMultiArgSelector:
720 case DeclarationName::CXXUsingDirective:
723 llvm_unreachable("Unexpected declaration name kind");