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