contrib/llvm/tools/clang/lib/AST/DeclarationName.cpp

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