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