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