tools/libclang/CXCursor.cpp

   1 //===- CXCursor.cpp - Routines for manipulating CXCursors -----------------===//
   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 defines routines for manipulating CXCursors. It should be the
  11 // only file that has internal knowledge of the encoding of the data in
  12 // CXCursor.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "CXTranslationUnit.h"
  17 #include "CXCursor.h"
  18 #include "CXString.h"
  19 #include "CXType.h"
  20 #include "clang-c/Index.h"
  21 #include "clang/AST/Decl.h"
  22 #include "clang/AST/DeclCXX.h"
  23 #include "clang/AST/DeclObjC.h"
  24 #include "clang/AST/DeclTemplate.h"
  25 #include "clang/AST/Expr.h"
  26 #include "clang/AST/ExprCXX.h"
  27 #include "clang/AST/ExprObjC.h"
  28 #include "clang/Frontend/ASTUnit.h"
  29 #include "llvm/Support/ErrorHandling.h"
  30
  31 using namespace clang;
  32 using namespace cxcursor;
  33
  34 CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K, CXTranslationUnit TU) {
  35   assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid);
  36   CXCursor C = { K, 0, { 0, 0, TU } };
  37   return C;
  38 }
  39
  40 static CXCursorKind GetCursorKind(const Attr *A) {
  41   assert(A && "Invalid arguments!");
  42   switch (A->getKind()) {
  43     default: break;
  44     case attr::IBAction: return CXCursor_IBActionAttr;
  45     case attr::IBOutlet: return CXCursor_IBOutletAttr;
  46     case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr;
  47     case attr::Final: return CXCursor_CXXFinalAttr;
  48     case attr::Override: return CXCursor_CXXOverrideAttr;
  49     case attr::Annotate: return CXCursor_AnnotateAttr;
  50     case attr::AsmLabel: return CXCursor_AsmLabelAttr;
  51   }
  52
  53   return CXCursor_UnexposedAttr;
  54 }
  55
  56 CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent,
  57                                 CXTranslationUnit TU) {
  58   assert(A && Parent && TU && "Invalid arguments!");
  59   CXCursor C = { GetCursorKind(A), 0, { Parent, A, TU } };
  60   return C;
  61 }
  62
  63 CXCursor cxcursor::MakeCXCursor(const Decl *D, CXTranslationUnit TU,
  64                                 SourceRange RegionOfInterest,
  65                                 bool FirstInDeclGroup) {
  66   assert(D && TU && "Invalid arguments!");
  67
  68   CXCursorKind K = getCursorKindForDecl(D);
  69
  70   if (K == CXCursor_ObjCClassMethodDecl ||
  71       K == CXCursor_ObjCInstanceMethodDecl) {
  72     int SelectorIdIndex = -1;
  73     // Check if cursor points to a selector id.
  74     if (RegionOfInterest.isValid() &&
  75         RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) {
  76       SmallVector<SourceLocation, 16> SelLocs;
  77       cast<ObjCMethodDecl>(D)->getSelectorLocs(SelLocs);
  78       SmallVector<SourceLocation, 16>::iterator
  79         I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin());
  80       if (I != SelLocs.end())
  81         SelectorIdIndex = I - SelLocs.begin();
  82     }
  83     CXCursor C = { K, SelectorIdIndex,
  84                    { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }};
  85     return C;
  86   }
  87
  88   CXCursor C = { K, 0, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }};
  89   return C;
  90 }
  91
  92 CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
  93                                 CXTranslationUnit TU,
  94                                 SourceRange RegionOfInterest) {
  95   assert(S && TU && "Invalid arguments!");
  96   CXCursorKind K = CXCursor_NotImplemented;
  97
  98   switch (S->getStmtClass()) {
  99   case Stmt::NoStmtClass:
 100     break;
 101
 102   case Stmt::CaseStmtClass:
 103     K = CXCursor_CaseStmt;
 104     break;
 105
 106   case Stmt::DefaultStmtClass:
 107     K = CXCursor_DefaultStmt;
 108     break;
 109
 110   case Stmt::IfStmtClass:
 111     K = CXCursor_IfStmt;
 112     break;
 113
 114   case Stmt::SwitchStmtClass:
 115     K = CXCursor_SwitchStmt;
 116     break;
 117
 118   case Stmt::WhileStmtClass:
 119     K = CXCursor_WhileStmt;
 120     break;
 121
 122   case Stmt::DoStmtClass:
 123     K = CXCursor_DoStmt;
 124     break;
 125
 126   case Stmt::ForStmtClass:
 127     K = CXCursor_ForStmt;
 128     break;
 129
 130   case Stmt::GotoStmtClass:
 131     K = CXCursor_GotoStmt;
 132     break;
 133
 134   case Stmt::IndirectGotoStmtClass:
 135     K = CXCursor_IndirectGotoStmt;
 136     break;
 137
 138   case Stmt::ContinueStmtClass:
 139     K = CXCursor_ContinueStmt;
 140     break;
 141
 142   case Stmt::BreakStmtClass:
 143     K = CXCursor_BreakStmt;
 144     break;
 145
 146   case Stmt::ReturnStmtClass:
 147     K = CXCursor_ReturnStmt;
 148     break;
 149
 150   case Stmt::GCCAsmStmtClass:
 151     K = CXCursor_GCCAsmStmt;
 152     break;
 153
 154   case Stmt::MSAsmStmtClass:
 155     K = CXCursor_MSAsmStmt;
 156     break;
 157
 158   case Stmt::ObjCAtTryStmtClass:
 159     K = CXCursor_ObjCAtTryStmt;
 160     break;
 161
 162   case Stmt::ObjCAtCatchStmtClass:
 163     K = CXCursor_ObjCAtCatchStmt;
 164     break;
 165
 166   case Stmt::ObjCAtFinallyStmtClass:
 167     K = CXCursor_ObjCAtFinallyStmt;
 168     break;
 169
 170   case Stmt::ObjCAtThrowStmtClass:
 171     K = CXCursor_ObjCAtThrowStmt;
 172     break;
 173
 174   case Stmt::ObjCAtSynchronizedStmtClass:
 175     K = CXCursor_ObjCAtSynchronizedStmt;
 176     break;
 177
 178   case Stmt::ObjCAutoreleasePoolStmtClass:
 179     K = CXCursor_ObjCAutoreleasePoolStmt;
 180     break;
 181
 182   case Stmt::ObjCForCollectionStmtClass:
 183     K = CXCursor_ObjCForCollectionStmt;
 184     break;
 185
 186   case Stmt::CXXCatchStmtClass:
 187     K = CXCursor_CXXCatchStmt;
 188     break;
 189
 190   case Stmt::CXXTryStmtClass:
 191     K = CXCursor_CXXTryStmt;
 192     break;
 193
 194   case Stmt::CXXForRangeStmtClass:
 195     K = CXCursor_CXXForRangeStmt;
 196     break;
 197
 198   case Stmt::SEHTryStmtClass:
 199     K = CXCursor_SEHTryStmt;
 200     break;
 201
 202   case Stmt::SEHExceptStmtClass:
 203     K = CXCursor_SEHExceptStmt;
 204     break;
 205
 206   case Stmt::SEHFinallyStmtClass:
 207     K = CXCursor_SEHFinallyStmt;
 208     break;
 209
 210   case Stmt::ArrayTypeTraitExprClass:
 211   case Stmt::AsTypeExprClass:
 212   case Stmt::AtomicExprClass:
 213   case Stmt::BinaryConditionalOperatorClass:
 214   case Stmt::BinaryTypeTraitExprClass:
 215   case Stmt::TypeTraitExprClass:
 216   case Stmt::CXXBindTemporaryExprClass:
 217   case Stmt::CXXDefaultArgExprClass:
 218   case Stmt::CXXDefaultInitExprClass:
 219   case Stmt::CXXScalarValueInitExprClass:
 220   case Stmt::CXXUuidofExprClass:
 221   case Stmt::ChooseExprClass:
 222   case Stmt::DesignatedInitExprClass:
 223   case Stmt::ExprWithCleanupsClass:
 224   case Stmt::ExpressionTraitExprClass:
 225   case Stmt::ExtVectorElementExprClass:
 226   case Stmt::ImplicitCastExprClass:
 227   case Stmt::ImplicitValueInitExprClass:
 228   case Stmt::MaterializeTemporaryExprClass:
 229   case Stmt::ObjCIndirectCopyRestoreExprClass:
 230   case Stmt::OffsetOfExprClass:
 231   case Stmt::ParenListExprClass:
 232   case Stmt::PredefinedExprClass:
 233   case Stmt::ShuffleVectorExprClass:
 234   case Stmt::UnaryExprOrTypeTraitExprClass:
 235   case Stmt::UnaryTypeTraitExprClass:
 236   case Stmt::VAArgExprClass:
 237   case Stmt::ObjCArrayLiteralClass:
 238   case Stmt::ObjCDictionaryLiteralClass:
 239   case Stmt::ObjCBoxedExprClass:
 240   case Stmt::ObjCSubscriptRefExprClass:
 241     K = CXCursor_UnexposedExpr;
 242     break;
 243
 244   case Stmt::OpaqueValueExprClass:
 245     if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr())
 246       return MakeCXCursor(Src, Parent, TU, RegionOfInterest);
 247     K = CXCursor_UnexposedExpr;
 248     break;
 249
 250   case Stmt::PseudoObjectExprClass:
 251     return MakeCXCursor(cast<PseudoObjectExpr>(S)->getSyntacticForm(),
 252                         Parent, TU, RegionOfInterest);
 253
 254   case Stmt::CompoundStmtClass:
 255     K = CXCursor_CompoundStmt;
 256     break;
 257
 258   case Stmt::NullStmtClass:
 259     K = CXCursor_NullStmt;
 260     break;
 261
 262   case Stmt::LabelStmtClass:
 263     K = CXCursor_LabelStmt;
 264     break;
 265
 266   case Stmt::AttributedStmtClass:
 267     K = CXCursor_UnexposedStmt;
 268     break;
 269
 270   case Stmt::DeclStmtClass:
 271     K = CXCursor_DeclStmt;
 272     break;
 273
 274   case Stmt::CapturedStmtClass:
 275     K = CXCursor_UnexposedStmt;
 276     break;
 277
 278   case Stmt::IntegerLiteralClass:
 279     K = CXCursor_IntegerLiteral;
 280     break;
 281
 282   case Stmt::FloatingLiteralClass:
 283     K = CXCursor_FloatingLiteral;
 284     break;
 285
 286   case Stmt::ImaginaryLiteralClass:
 287     K = CXCursor_ImaginaryLiteral;
 288     break;
 289
 290   case Stmt::StringLiteralClass:
 291     K = CXCursor_StringLiteral;
 292     break;
 293
 294   case Stmt::CharacterLiteralClass:
 295     K = CXCursor_CharacterLiteral;
 296     break;
 297
 298   case Stmt::ParenExprClass:
 299     K = CXCursor_ParenExpr;
 300     break;
 301
 302   case Stmt::UnaryOperatorClass:
 303     K = CXCursor_UnaryOperator;
 304     break;
 305
 306   case Stmt::CXXNoexceptExprClass:
 307     K = CXCursor_UnaryExpr;
 308     break;
 309
 310   case Stmt::ArraySubscriptExprClass:
 311     K = CXCursor_ArraySubscriptExpr;
 312     break;
 313
 314   case Stmt::BinaryOperatorClass:
 315     K = CXCursor_BinaryOperator;
 316     break;
 317
 318   case Stmt::CompoundAssignOperatorClass:
 319     K = CXCursor_CompoundAssignOperator;
 320     break;
 321
 322   case Stmt::ConditionalOperatorClass:
 323     K = CXCursor_ConditionalOperator;
 324     break;
 325
 326   case Stmt::CStyleCastExprClass:
 327     K = CXCursor_CStyleCastExpr;
 328     break;
 329
 330   case Stmt::CompoundLiteralExprClass:
 331     K = CXCursor_CompoundLiteralExpr;
 332     break;
 333
 334   case Stmt::InitListExprClass:
 335     K = CXCursor_InitListExpr;
 336     break;
 337
 338   case Stmt::AddrLabelExprClass:
 339     K = CXCursor_AddrLabelExpr;
 340     break;
 341
 342   case Stmt::StmtExprClass:
 343     K = CXCursor_StmtExpr;
 344     break;
 345
 346   case Stmt::GenericSelectionExprClass:
 347     K = CXCursor_GenericSelectionExpr;
 348     break;
 349
 350   case Stmt::GNUNullExprClass:
 351     K = CXCursor_GNUNullExpr;
 352     break;
 353
 354   case Stmt::CXXStaticCastExprClass:
 355     K = CXCursor_CXXStaticCastExpr;
 356     break;
 357
 358   case Stmt::CXXDynamicCastExprClass:
 359     K = CXCursor_CXXDynamicCastExpr;
 360     break;
 361
 362   case Stmt::CXXReinterpretCastExprClass:
 363     K = CXCursor_CXXReinterpretCastExpr;
 364     break;
 365
 366   case Stmt::CXXConstCastExprClass:
 367     K = CXCursor_CXXConstCastExpr;
 368     break;
 369
 370   case Stmt::CXXFunctionalCastExprClass:
 371     K = CXCursor_CXXFunctionalCastExpr;
 372     break;
 373
 374   case Stmt::CXXTypeidExprClass:
 375     K = CXCursor_CXXTypeidExpr;
 376     break;
 377
 378   case Stmt::CXXBoolLiteralExprClass:
 379     K = CXCursor_CXXBoolLiteralExpr;
 380     break;
 381
 382   case Stmt::CXXNullPtrLiteralExprClass:
 383     K = CXCursor_CXXNullPtrLiteralExpr;
 384     break;
 385
 386   case Stmt::CXXThisExprClass:
 387     K = CXCursor_CXXThisExpr;
 388     break;
 389
 390   case Stmt::CXXThrowExprClass:
 391     K = CXCursor_CXXThrowExpr;
 392     break;
 393
 394   case Stmt::CXXNewExprClass:
 395     K = CXCursor_CXXNewExpr;
 396     break;
 397
 398   case Stmt::CXXDeleteExprClass:
 399     K = CXCursor_CXXDeleteExpr;
 400     break;
 401
 402   case Stmt::ObjCStringLiteralClass:
 403     K = CXCursor_ObjCStringLiteral;
 404     break;
 405
 406   case Stmt::ObjCEncodeExprClass:
 407     K = CXCursor_ObjCEncodeExpr;
 408     break;
 409
 410   case Stmt::ObjCSelectorExprClass:
 411     K = CXCursor_ObjCSelectorExpr;
 412     break;
 413
 414   case Stmt::ObjCProtocolExprClass:
 415     K = CXCursor_ObjCProtocolExpr;
 416     break;
 417
 418   case Stmt::ObjCBoolLiteralExprClass:
 419     K = CXCursor_ObjCBoolLiteralExpr;
 420     break;
 421
 422   case Stmt::ObjCBridgedCastExprClass:
 423     K = CXCursor_ObjCBridgedCastExpr;
 424     break;
 425
 426   case Stmt::BlockExprClass:
 427     K = CXCursor_BlockExpr;
 428     break;
 429
 430   case Stmt::PackExpansionExprClass:
 431     K = CXCursor_PackExpansionExpr;
 432     break;
 433
 434   case Stmt::SizeOfPackExprClass:
 435     K = CXCursor_SizeOfPackExpr;
 436     break;
 437
 438   case Stmt::DeclRefExprClass:
 439     if (const ImplicitParamDecl *IPD =
 440          dyn_cast_or_null<ImplicitParamDecl>(cast<DeclRefExpr>(S)->getDecl())) {
 441       if (const ObjCMethodDecl *MD =
 442             dyn_cast<ObjCMethodDecl>(IPD->getDeclContext())) {
 443         if (MD->getSelfDecl() == IPD) {
 444           K = CXCursor_ObjCSelfExpr;
 445           break;
 446         }
 447       }
 448     }
 449
 450     K = CXCursor_DeclRefExpr;
 451     break;
 452
 453   case Stmt::DependentScopeDeclRefExprClass:
 454   case Stmt::SubstNonTypeTemplateParmExprClass:
 455   case Stmt::SubstNonTypeTemplateParmPackExprClass:
 456   case Stmt::FunctionParmPackExprClass:
 457   case Stmt::UnresolvedLookupExprClass:
 458     K = CXCursor_DeclRefExpr;
 459     break;
 460
 461   case Stmt::CXXDependentScopeMemberExprClass:
 462   case Stmt::CXXPseudoDestructorExprClass:
 463   case Stmt::MemberExprClass:
 464   case Stmt::MSPropertyRefExprClass:
 465   case Stmt::ObjCIsaExprClass:
 466   case Stmt::ObjCIvarRefExprClass:
 467   case Stmt::ObjCPropertyRefExprClass:
 468   case Stmt::UnresolvedMemberExprClass:
 469     K = CXCursor_MemberRefExpr;
 470     break;
 471
 472   case Stmt::CallExprClass:
 473   case Stmt::CXXOperatorCallExprClass:
 474   case Stmt::CXXMemberCallExprClass:
 475   case Stmt::CUDAKernelCallExprClass:
 476   case Stmt::CXXConstructExprClass:
 477   case Stmt::CXXTemporaryObjectExprClass:
 478   case Stmt::CXXUnresolvedConstructExprClass:
 479   case Stmt::UserDefinedLiteralClass:
 480     K = CXCursor_CallExpr;
 481     break;
 482
 483   case Stmt::LambdaExprClass:
 484     K = CXCursor_LambdaExpr;
 485     break;
 486
 487   case Stmt::ObjCMessageExprClass: {
 488     K = CXCursor_ObjCMessageExpr;
 489     int SelectorIdIndex = -1;
 490     // Check if cursor points to a selector id.
 491     if (RegionOfInterest.isValid() &&
 492         RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) {
 493       SmallVector<SourceLocation, 16> SelLocs;
 494       cast<ObjCMessageExpr>(S)->getSelectorLocs(SelLocs);
 495       SmallVector<SourceLocation, 16>::iterator
 496         I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin());
 497       if (I != SelLocs.end())
 498         SelectorIdIndex = I - SelLocs.begin();
 499     }
 500     CXCursor C = { K, 0, { Parent, S, TU } };
 501     return getSelectorIdentifierCursor(SelectorIdIndex, C);
 502   }
 503
 504   case Stmt::MSDependentExistsStmtClass:
 505     K = CXCursor_UnexposedStmt;
 506     break;
 507   }
 508
 509   CXCursor C = { K, 0, { Parent, S, TU } };
 510   return C;
 511 }
 512
 513 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
 514                                                SourceLocation Loc,
 515                                                CXTranslationUnit TU) {
 516   assert(Super && TU && "Invalid arguments!");
 517   void *RawLoc = Loc.getPtrEncoding();
 518   CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } };
 519   return C;
 520 }
 521
 522 std::pair<const ObjCInterfaceDecl *, SourceLocation>
 523 cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
 524   assert(C.kind == CXCursor_ObjCSuperClassRef);
 525   return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]),
 526                         SourceLocation::getFromPtrEncoding(C.data[1]));
 527 }
 528
 529 CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto,
 530                                              SourceLocation Loc,
 531                                              CXTranslationUnit TU) {
 532   assert(Proto && TU && "Invalid arguments!");
 533   void *RawLoc = Loc.getPtrEncoding();
 534   CXCursor C = { CXCursor_ObjCProtocolRef, 0, { Proto, RawLoc, TU } };
 535   return C;
 536 }
 537
 538 std::pair<const ObjCProtocolDecl *, SourceLocation>
 539 cxcursor::getCursorObjCProtocolRef(CXCursor C) {
 540   assert(C.kind == CXCursor_ObjCProtocolRef);
 541   return std::make_pair(static_cast<const ObjCProtocolDecl *>(C.data[0]),
 542                         SourceLocation::getFromPtrEncoding(C.data[1]));
 543 }
 544
 545 CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class,
 546                                           SourceLocation Loc,
 547                                           CXTranslationUnit TU) {
 548   // 'Class' can be null for invalid code.
 549   if (!Class)
 550     return MakeCXCursorInvalid(CXCursor_InvalidCode);
 551   assert(TU && "Invalid arguments!");
 552   void *RawLoc = Loc.getPtrEncoding();
 553   CXCursor C = { CXCursor_ObjCClassRef, 0, { Class, RawLoc, TU } };
 554   return C;
 555 }
 556
 557 std::pair<const ObjCInterfaceDecl *, SourceLocation>
 558 cxcursor::getCursorObjCClassRef(CXCursor C) {
 559   assert(C.kind == CXCursor_ObjCClassRef);
 560   return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]),
 561                         SourceLocation::getFromPtrEncoding(C.data[1]));
 562 }
 563
 564 CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc,
 565                                      CXTranslationUnit TU) {
 566   assert(Type && TU && "Invalid arguments!");
 567   void *RawLoc = Loc.getPtrEncoding();
 568   CXCursor C = { CXCursor_TypeRef, 0, { Type, RawLoc, TU } };
 569   return C;
 570 }
 571
 572 std::pair<const TypeDecl *, SourceLocation>
 573 cxcursor::getCursorTypeRef(CXCursor C) {
 574   assert(C.kind == CXCursor_TypeRef);
 575   return std::make_pair(static_cast<const TypeDecl *>(C.data[0]),
 576                         SourceLocation::getFromPtrEncoding(C.data[1]));
 577 }
 578
 579 CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template,
 580                                          SourceLocation Loc,
 581                                          CXTranslationUnit TU) {
 582   assert(Template && TU && "Invalid arguments!");
 583   void *RawLoc = Loc.getPtrEncoding();
 584   CXCursor C = { CXCursor_TemplateRef, 0, { Template, RawLoc, TU } };
 585   return C;
 586 }
 587
 588 std::pair<const TemplateDecl *, SourceLocation>
 589 cxcursor::getCursorTemplateRef(CXCursor C) {
 590   assert(C.kind == CXCursor_TemplateRef);
 591   return std::make_pair(static_cast<const TemplateDecl *>(C.data[0]),
 592                         SourceLocation::getFromPtrEncoding(C.data[1]));
 593 }
 594
 595 CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS,
 596                                           SourceLocation Loc,
 597                                           CXTranslationUnit TU) {
 598
 599   assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
 600          "Invalid arguments!");
 601   void *RawLoc = Loc.getPtrEncoding();
 602   CXCursor C = { CXCursor_NamespaceRef, 0, { NS, RawLoc, TU } };
 603   return C;
 604 }
 605
 606 std::pair<const NamedDecl *, SourceLocation>
 607 cxcursor::getCursorNamespaceRef(CXCursor C) {
 608   assert(C.kind == CXCursor_NamespaceRef);
 609   return std::make_pair(static_cast<const NamedDecl *>(C.data[0]),
 610                         SourceLocation::getFromPtrEncoding(C.data[1]));
 611 }
 612
 613 CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc,
 614                                          CXTranslationUnit TU) {
 615
 616   assert(Var && TU && "Invalid arguments!");
 617   void *RawLoc = Loc.getPtrEncoding();
 618   CXCursor C = { CXCursor_VariableRef, 0, { Var, RawLoc, TU } };
 619   return C;
 620 }
 621
 622 std::pair<const VarDecl *, SourceLocation>
 623 cxcursor::getCursorVariableRef(CXCursor C) {
 624   assert(C.kind == CXCursor_VariableRef);
 625   return std::make_pair(static_cast<const VarDecl *>(C.data[0]),
 626                         SourceLocation::getFromPtrEncoding(C.data[1]));
 627 }
 628
 629 CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc,
 630                                        CXTranslationUnit TU) {
 631
 632   assert(Field && TU && "Invalid arguments!");
 633   void *RawLoc = Loc.getPtrEncoding();
 634   CXCursor C = { CXCursor_MemberRef, 0, { Field, RawLoc, TU } };
 635   return C;
 636 }
 637
 638 std::pair<const FieldDecl *, SourceLocation>
 639 cxcursor::getCursorMemberRef(CXCursor C) {
 640   assert(C.kind == CXCursor_MemberRef);
 641   return std::make_pair(static_cast<const FieldDecl *>(C.data[0]),
 642                         SourceLocation::getFromPtrEncoding(C.data[1]));
 643 }
 644
 645 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B,
 646                                               CXTranslationUnit TU){
 647   CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, 0, TU } };
 648   return C;
 649 }
 650
 651 const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
 652   assert(C.kind == CXCursor_CXXBaseSpecifier);
 653   return static_cast<const CXXBaseSpecifier*>(C.data[0]);
 654 }
 655
 656 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
 657                                                     CXTranslationUnit TU) {
 658   CXCursor C = { CXCursor_PreprocessingDirective, 0,
 659                  { Range.getBegin().getPtrEncoding(),
 660                    Range.getEnd().getPtrEncoding(),
 661                    TU }
 662                };
 663   return C;
 664 }
 665
 666 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
 667   assert(C.kind == CXCursor_PreprocessingDirective);
 668   SourceRange Range(SourceLocation::getFromPtrEncoding(C.data[0]),
 669                     SourceLocation::getFromPtrEncoding(C.data[1]));
 670   ASTUnit *TU = getCursorASTUnit(C);
 671   return TU->mapRangeFromPreamble(Range);
 672 }
 673
 674 CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinition *MI,
 675                                              CXTranslationUnit TU) {
 676   CXCursor C = { CXCursor_MacroDefinition, 0, { MI, 0, TU } };
 677   return C;
 678 }
 679
 680 const MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) {
 681   assert(C.kind == CXCursor_MacroDefinition);
 682   return static_cast<const MacroDefinition *>(C.data[0]);
 683 }
 684
 685 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
 686                                             CXTranslationUnit TU) {
 687   CXCursor C = { CXCursor_MacroExpansion, 0, { MI, 0, TU } };
 688   return C;
 689 }
 690
 691 CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinition *MI,
 692                                             SourceLocation Loc,
 693                                             CXTranslationUnit TU) {
 694   assert(Loc.isValid());
 695   CXCursor C = { CXCursor_MacroExpansion, 0, { MI, Loc.getPtrEncoding(), TU } };
 696   return C;
 697 }
 698
 699 const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const {
 700   if (isPseudo())
 701     return getAsMacroDefinition()->getName();
 702   return getAsMacroExpansion()->getName();
 703 }
 704 const MacroDefinition *cxcursor::MacroExpansionCursor::getDefinition() const {
 705   if (isPseudo())
 706     return getAsMacroDefinition();
 707   return getAsMacroExpansion()->getDefinition();
 708 }
 709 SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const {
 710   if (isPseudo())
 711     return getPseudoLoc();
 712   return getAsMacroExpansion()->getSourceRange();
 713 }
 714
 715 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
 716                                                 CXTranslationUnit TU) {
 717   CXCursor C = { CXCursor_InclusionDirective, 0, { ID, 0, TU } };
 718   return C;
 719 }
 720
 721 const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
 722   assert(C.kind == CXCursor_InclusionDirective);
 723   return static_cast<const InclusionDirective *>(C.data[0]);
 724 }
 725
 726 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
 727                                       CXTranslationUnit TU) {
 728
 729   assert(Label && TU && "Invalid arguments!");
 730   void *RawLoc = Loc.getPtrEncoding();
 731   CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } };
 732   return C;
 733 }
 734
 735 std::pair<const LabelStmt *, SourceLocation>
 736 cxcursor::getCursorLabelRef(CXCursor C) {
 737   assert(C.kind == CXCursor_LabelRef);
 738   return std::make_pair(static_cast<const LabelStmt *>(C.data[0]),
 739                         SourceLocation::getFromPtrEncoding(C.data[1]));
 740 }
 741
 742 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E,
 743                                                CXTranslationUnit TU) {
 744   assert(E && TU && "Invalid arguments!");
 745   OverloadedDeclRefStorage Storage(E);
 746   void *RawLoc = E->getNameLoc().getPtrEncoding();
 747   CXCursor C = {
 748                  CXCursor_OverloadedDeclRef, 0,
 749                  { Storage.getOpaqueValue(), RawLoc, TU }
 750                };
 751   return C;
 752 }
 753
 754 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D,
 755                                                SourceLocation Loc,
 756                                                CXTranslationUnit TU) {
 757   assert(D && TU && "Invalid arguments!");
 758   void *RawLoc = Loc.getPtrEncoding();
 759   OverloadedDeclRefStorage Storage(D);
 760   CXCursor C = {
 761     CXCursor_OverloadedDeclRef, 0,
 762     { Storage.getOpaqueValue(), RawLoc, TU }
 763   };
 764   return C;
 765 }
 766
 767 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
 768                                                SourceLocation Loc,
 769                                                CXTranslationUnit TU) {
 770   assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
 771   void *RawLoc = Loc.getPtrEncoding();
 772   OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
 773   CXCursor C = {
 774     CXCursor_OverloadedDeclRef, 0,
 775     { Storage.getOpaqueValue(), RawLoc, TU }
 776   };
 777   return C;
 778 }
 779
 780 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
 781 cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
 782   assert(C.kind == CXCursor_OverloadedDeclRef);
 783   return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(
 784                                        const_cast<void *>(C.data[0])),
 785                         SourceLocation::getFromPtrEncoding(C.data[1]));
 786 }
 787
 788 const Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
 789   return static_cast<const Decl *>(Cursor.data[0]);
 790 }
 791
 792 const Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
 793   return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
 794 }
 795
 796 const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
 797   if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
 798       Cursor.kind == CXCursor_ObjCProtocolRef ||
 799       Cursor.kind == CXCursor_ObjCClassRef)
 800     return 0;
 801
 802   return static_cast<const Stmt *>(Cursor.data[1]);
 803 }
 804
 805 const Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
 806   return static_cast<const Attr *>(Cursor.data[1]);
 807 }
 808
 809 const Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) {
 810   return static_cast<const Decl *>(Cursor.data[0]);
 811 }
 812
 813 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
 814   return getCursorASTUnit(Cursor)->getASTContext();
 815 }
 816
 817 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
 818   CXTranslationUnit TU = getCursorTU(Cursor);
 819   if (!TU)
 820     return 0;
 821   return cxtu::getASTUnit(TU);
 822 }
 823
 824 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
 825   return static_cast<CXTranslationUnit>(const_cast<void*>(Cursor.data[2]));
 826 }
 827
 828 void cxcursor::getOverriddenCursors(CXCursor cursor,
 829                                     SmallVectorImpl<CXCursor> &overridden) {
 830   assert(clang_isDeclaration(cursor.kind));
 831   const NamedDecl *D = dyn_cast_or_null<NamedDecl>(getCursorDecl(cursor));
 832   if (!D)
 833     return;
 834
 835   CXTranslationUnit TU = getCursorTU(cursor);
 836   SmallVector<const NamedDecl *, 8> OverDecls;
 837   D->getASTContext().getOverriddenMethods(D, OverDecls);
 838
 839   for (SmallVector<const NamedDecl *, 8>::iterator
 840          I = OverDecls.begin(), E = OverDecls.end(); I != E; ++I) {
 841     overridden.push_back(MakeCXCursor(*I, TU));
 842   }
 843 }
 844
 845 std::pair<int, SourceLocation>
 846 cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) {
 847   if (cursor.kind == CXCursor_ObjCMessageExpr) {
 848     if (cursor.xdata != -1)
 849       return std::make_pair(cursor.xdata,
 850                             cast<ObjCMessageExpr>(getCursorExpr(cursor))
 851                                                 ->getSelectorLoc(cursor.xdata));
 852   } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
 853              cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
 854     if (cursor.xdata != -1)
 855       return std::make_pair(cursor.xdata,
 856                             cast<ObjCMethodDecl>(getCursorDecl(cursor))
 857                                                 ->getSelectorLoc(cursor.xdata));
 858   }
 859
 860   return std::make_pair(-1, SourceLocation());
 861 }
 862
 863 CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) {
 864   CXCursor newCursor = cursor;
 865
 866   if (cursor.kind == CXCursor_ObjCMessageExpr) {
 867     if (SelIdx == -1 ||
 868         unsigned(SelIdx) >= cast<ObjCMessageExpr>(getCursorExpr(cursor))
 869                                                          ->getNumSelectorLocs())
 870       newCursor.xdata = -1;
 871     else
 872       newCursor.xdata = SelIdx;
 873   } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
 874              cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
 875     if (SelIdx == -1 ||
 876         unsigned(SelIdx) >= cast<ObjCMethodDecl>(getCursorDecl(cursor))
 877                                                          ->getNumSelectorLocs())
 878       newCursor.xdata = -1;
 879     else
 880       newCursor.xdata = SelIdx;
 881   }
 882
 883   return newCursor;
 884 }
 885
 886 CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) {
 887   if (cursor.kind != CXCursor_CallExpr)
 888     return cursor;
 889
 890   if (cursor.xdata == 0)
 891     return cursor;
 892
 893   const Expr *E = getCursorExpr(cursor);
 894   TypeSourceInfo *Type = 0;
 895   if (const CXXUnresolvedConstructExpr *
 896         UnCtor = dyn_cast<CXXUnresolvedConstructExpr>(E)) {
 897     Type = UnCtor->getTypeSourceInfo();
 898   } else if (const CXXTemporaryObjectExpr *Tmp =
 899                  dyn_cast<CXXTemporaryObjectExpr>(E)){
 900     Type = Tmp->getTypeSourceInfo();
 901   }
 902
 903   if (!Type)
 904     return cursor;
 905
 906   CXTranslationUnit TU = getCursorTU(cursor);
 907   QualType Ty = Type->getType();
 908   TypeLoc TL = Type->getTypeLoc();
 909   SourceLocation Loc = TL.getBeginLoc();
 910
 911   if (const ElaboratedType *ElabT = Ty->getAs<ElaboratedType>()) {
 912     Ty = ElabT->getNamedType();
 913     ElaboratedTypeLoc ElabTL = TL.castAs<ElaboratedTypeLoc>();
 914     Loc = ElabTL.getNamedTypeLoc().getBeginLoc();
 915   }
 916
 917   if (const TypedefType *Typedef = Ty->getAs<TypedefType>())
 918     return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU);
 919   if (const TagType *Tag = Ty->getAs<TagType>())
 920     return MakeCursorTypeRef(Tag->getDecl(), Loc, TU);
 921   if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>())
 922     return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU);
 923
 924   return cursor;
 925 }
 926
 927 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
 928   return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
 929          X.data[2] == Y.data[2];
 930 }
 931
 932 // FIXME: Remove once we can model DeclGroups and their appropriate ranges
 933 // properly in the ASTs.
 934 bool cxcursor::isFirstInDeclGroup(CXCursor C) {
 935   assert(clang_isDeclaration(C.kind));
 936   return ((uintptr_t) (C.data[1])) != 0;
 937 }
 938
 939 //===----------------------------------------------------------------------===//
 940 // libclang CXCursor APIs
 941 //===----------------------------------------------------------------------===//
 942
 943 extern "C" {
 944
 945 int clang_Cursor_isNull(CXCursor cursor) {
 946   return clang_equalCursors(cursor, clang_getNullCursor());
 947 }
 948
 949 CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) {
 950   return getCursorTU(cursor);
 951 }
 952
 953 int clang_Cursor_getNumArguments(CXCursor C) {
 954   if (clang_isDeclaration(C.kind)) {
 955     const Decl *D = cxcursor::getCursorDecl(C);
 956     if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
 957       return MD->param_size();
 958     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
 959       return FD->param_size();
 960   }
 961
 962   if (clang_isExpression(C.kind)) {
 963     const Expr *E = cxcursor::getCursorExpr(C);
 964     if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
 965       return CE->getNumArgs();
 966     }
 967   }
 968
 969   return -1;
 970 }
 971
 972 CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) {
 973   if (clang_isDeclaration(C.kind)) {
 974     const Decl *D = cxcursor::getCursorDecl(C);
 975     if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
 976       if (i < MD->param_size())
 977         return cxcursor::MakeCXCursor(MD->param_begin()[i],
 978                                       cxcursor::getCursorTU(C));
 979     } else if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
 980       if (i < FD->param_size())
 981         return cxcursor::MakeCXCursor(FD->param_begin()[i],
 982                                       cxcursor::getCursorTU(C));
 983     }
 984   }
 985
 986   if (clang_isExpression(C.kind)) {
 987     const Expr *E = cxcursor::getCursorExpr(C);
 988     if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
 989       if (i < CE->getNumArgs()) {
 990         return cxcursor::MakeCXCursor(CE->getArg(i),
 991                                       getCursorDecl(C),
 992                                       cxcursor::getCursorTU(C));
 993       }
 994     }
 995   }
 996
 997   return clang_getNullCursor();
 998 }
 999
1000 } // end: extern "C"
1001
1002 //===----------------------------------------------------------------------===//
1003 // CXCursorSet.
1004 //===----------------------------------------------------------------------===//
1005
1006 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
1007
1008 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
1009   return (CXCursorSet) setImpl;
1010 }
1011 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
1012   return (CXCursorSet_Impl*) set;
1013 }
1014 namespace llvm {
1015 template<> struct DenseMapInfo<CXCursor> {
1016 public:
1017   static inline CXCursor getEmptyKey() {
1018     return MakeCXCursorInvalid(CXCursor_InvalidFile);
1019   }
1020   static inline CXCursor getTombstoneKey() {
1021     return MakeCXCursorInvalid(CXCursor_NoDeclFound);
1022   }
1023   static inline unsigned getHashValue(const CXCursor &cursor) {
1024     return llvm::DenseMapInfo<std::pair<const void *, const void *> >
1025       ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1]));
1026   }
1027   static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
1028     return x.kind == y.kind &&
1029            x.data[0] == y.data[0] &&
1030            x.data[1] == y.data[1];
1031   }
1032 };
1033 }
1034
1035 extern "C" {
1036 CXCursorSet clang_createCXCursorSet() {
1037   return packCXCursorSet(new CXCursorSet_Impl());
1038 }
1039
1040 void clang_disposeCXCursorSet(CXCursorSet set) {
1041   delete unpackCXCursorSet(set);
1042 }
1043
1044 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
1045   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1046   if (!setImpl)
1047     return 0;
1048   return setImpl->find(cursor) != setImpl->end();
1049 }
1050
1051 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
1052   // Do not insert invalid cursors into the set.
1053   if (cursor.kind >= CXCursor_FirstInvalid &&
1054       cursor.kind <= CXCursor_LastInvalid)
1055     return 1;
1056
1057   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1058   if (!setImpl)
1059     return 1;
1060   unsigned &entry = (*setImpl)[cursor];
1061   unsigned flag = entry == 0 ? 1 : 0;
1062   entry = 1;
1063   return flag;
1064 }
1065
1066 CXCompletionString clang_getCursorCompletionString(CXCursor cursor) {
1067   enum CXCursorKind kind = clang_getCursorKind(cursor);
1068   if (clang_isDeclaration(kind)) {
1069     const Decl *decl = getCursorDecl(cursor);
1070     if (const NamedDecl *namedDecl = dyn_cast_or_null<NamedDecl>(decl)) {
1071       ASTUnit *unit = getCursorASTUnit(cursor);
1072       CodeCompletionResult Result(namedDecl, CCP_Declaration);
1073       CodeCompletionString *String
1074         = Result.CreateCodeCompletionString(unit->getASTContext(),
1075                                             unit->getPreprocessor(),
1076                                  unit->getCodeCompletionTUInfo().getAllocator(),
1077                                  unit->getCodeCompletionTUInfo(),
1078                                  true);
1079       return String;
1080     }
1081   }
1082   else if (kind == CXCursor_MacroDefinition) {
1083     const MacroDefinition *definition = getCursorMacroDefinition(cursor);
1084     const IdentifierInfo *MacroInfo = definition->getName();
1085     ASTUnit *unit = getCursorASTUnit(cursor);
1086     CodeCompletionResult Result(MacroInfo);
1087     CodeCompletionString *String
1088       = Result.CreateCodeCompletionString(unit->getASTContext(),
1089                                           unit->getPreprocessor(),
1090                                  unit->getCodeCompletionTUInfo().getAllocator(),
1091                                  unit->getCodeCompletionTUInfo(),
1092                                  false);
1093     return String;
1094   }
1095   return NULL;
1096 }
1097 } // end: extern C.
1098
1099 namespace {
1100   struct OverridenCursorsPool {
1101     typedef SmallVector<CXCursor, 2> CursorVec;
1102     std::vector<CursorVec*> AllCursors;
1103     std::vector<CursorVec*> AvailableCursors;
1104
1105     ~OverridenCursorsPool() {
1106       for (std::vector<CursorVec*>::iterator I = AllCursors.begin(),
1107            E = AllCursors.end(); I != E; ++I) {
1108         delete *I;
1109       }
1110     }
1111   };
1112 }
1113
1114 void *cxcursor::createOverridenCXCursorsPool() {
1115   return new OverridenCursorsPool();
1116 }
1117
1118 void cxcursor::disposeOverridenCXCursorsPool(void *pool) {
1119   delete static_cast<OverridenCursorsPool*>(pool);
1120 }
1121
1122 extern "C" {
1123 void clang_getOverriddenCursors(CXCursor cursor,
1124                                 CXCursor **overridden,
1125                                 unsigned *num_overridden) {
1126   if (overridden)
1127     *overridden = 0;
1128   if (num_overridden)
1129     *num_overridden = 0;
1130
1131   CXTranslationUnit TU = cxcursor::getCursorTU(cursor);
1132
1133   if (!overridden || !num_overridden || !TU)
1134     return;
1135
1136   if (!clang_isDeclaration(cursor.kind))
1137     return;
1138
1139   OverridenCursorsPool &pool =
1140     *static_cast<OverridenCursorsPool*>(TU->OverridenCursorsPool);
1141
1142   OverridenCursorsPool::CursorVec *Vec = 0;
1143
1144   if (!pool.AvailableCursors.empty()) {
1145     Vec = pool.AvailableCursors.back();
1146     pool.AvailableCursors.pop_back();
1147   }
1148   else {
1149     Vec = new OverridenCursorsPool::CursorVec();
1150     pool.AllCursors.push_back(Vec);
1151   }
1152
1153   // Clear out the vector, but don't free the memory contents.  This
1154   // reduces malloc() traffic.
1155   Vec->clear();
1156
1157   // Use the first entry to contain a back reference to the vector.
1158   // This is a complete hack.
1159   CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU);
1160   backRefCursor.data[0] = Vec;
1161   assert(cxcursor::getCursorTU(backRefCursor) == TU);
1162   Vec->push_back(backRefCursor);
1163
1164   // Get the overriden cursors.
1165   cxcursor::getOverriddenCursors(cursor, *Vec);
1166
1167   // Did we get any overriden cursors?  If not, return Vec to the pool
1168   // of available cursor vectors.
1169   if (Vec->size() == 1) {
1170     pool.AvailableCursors.push_back(Vec);
1171     return;
1172   }
1173
1174   // Now tell the caller about the overriden cursors.
1175   assert(Vec->size() > 1);
1176   *overridden = &((*Vec)[1]);
1177   *num_overridden = Vec->size() - 1;
1178 }
1179
1180 void clang_disposeOverriddenCursors(CXCursor *overridden) {
1181   if (!overridden)
1182     return;
1183
1184   // Use pointer arithmetic to get back the first faux entry
1185   // which has a back-reference to the TU and the vector.
1186   --overridden;
1187   OverridenCursorsPool::CursorVec *Vec =
1188       static_cast<OverridenCursorsPool::CursorVec *>(
1189           const_cast<void *>(overridden->data[0]));
1190   CXTranslationUnit TU = getCursorTU(*overridden);
1191
1192   assert(Vec && TU);
1193
1194   OverridenCursorsPool &pool =
1195     *static_cast<OverridenCursorsPool*>(TU->OverridenCursorsPool);
1196
1197   pool.AvailableCursors.push_back(Vec);
1198 }
1199
1200 int clang_Cursor_isDynamicCall(CXCursor C) {
1201   const Expr *E = 0;
1202   if (clang_isExpression(C.kind))
1203     E = getCursorExpr(C);
1204   if (!E)
1205     return 0;
1206
1207   if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E))
1208     return MsgE->getReceiverKind() == ObjCMessageExpr::Instance;
1209
1210   const MemberExpr *ME = 0;
1211   if (isa<MemberExpr>(E))
1212     ME = cast<MemberExpr>(E);
1213   else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
1214     ME = dyn_cast_or_null<MemberExpr>(CE->getCallee());
1215
1216   if (ME) {
1217     if (const CXXMethodDecl *
1218           MD = dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl()))
1219       return MD->isVirtual() && !ME->hasQualifier();
1220   }
1221
1222   return 0;
1223 }
1224
1225 CXType clang_Cursor_getReceiverType(CXCursor C) {
1226   CXTranslationUnit TU = cxcursor::getCursorTU(C);
1227   const Expr *E = 0;
1228   if (clang_isExpression(C.kind))
1229     E = getCursorExpr(C);
1230
1231   if (const ObjCMessageExpr *MsgE = dyn_cast_or_null<ObjCMessageExpr>(E))
1232     return cxtype::MakeCXType(MsgE->getReceiverType(), TU);
1233
1234   return cxtype::MakeCXType(QualType(), TU);
1235 }
1236
1237 } // end: extern "C"