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