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