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 "clang/Frontend/ASTUnit.h"
     20 #include "clang/AST/Decl.h"
     21 #include "clang/AST/DeclCXX.h"
     22 #include "clang/AST/DeclObjC.h"
     23 #include "clang/AST/Expr.h"
     24 #include "clang/AST/ExprCXX.h"
     25 #include "clang-c/Index.h"
     26 #include "llvm/Support/ErrorHandling.h"
     27 
     28 using namespace clang;
     29 using namespace cxcursor;
     30 
     31 CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K) {
     32   assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid);
     33   CXCursor C = { K, { 0, 0, 0 } };
     34   return C;
     35 }
     36 
     37 static CXCursorKind GetCursorKind(const Attr *A) {
     38   assert(A && "Invalid arguments!");
     39   switch (A->getKind()) {
     40     default: break;
     41     case attr::IBAction: return CXCursor_IBActionAttr;
     42     case attr::IBOutlet: return CXCursor_IBOutletAttr;
     43     case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr;
     44   }
     45 
     46   return CXCursor_UnexposedAttr;
     47 }
     48 
     49 CXCursor cxcursor::MakeCXCursor(const Attr *A, Decl *Parent,
     50                                 CXTranslationUnit TU) {
     51   assert(A && Parent && TU && "Invalid arguments!");
     52   CXCursor C = { GetCursorKind(A), { Parent, (void*)A, TU } };
     53   return C;
     54 }
     55 
     56 CXCursor cxcursor::MakeCXCursor(Decl *D, CXTranslationUnit TU,
     57                                 bool FirstInDeclGroup) {
     58   assert(D && TU && "Invalid arguments!");
     59   CXCursor C = { getCursorKindForDecl(D),
     60                  { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }
     61                };
     62   return C;
     63 }
     64 
     65 CXCursor cxcursor::MakeCXCursor(Stmt *S, Decl *Parent,
     66                                 CXTranslationUnit TU) {
     67   assert(S && TU && "Invalid arguments!");
     68   CXCursorKind K = CXCursor_NotImplemented;
     69 
     70   switch (S->getStmtClass()) {
     71   case Stmt::NoStmtClass:
     72     break;
     73 
     74   case Stmt::NullStmtClass:
     75   case Stmt::CompoundStmtClass:
     76   case Stmt::CaseStmtClass:
     77   case Stmt::DefaultStmtClass:
     78   case Stmt::IfStmtClass:
     79   case Stmt::SwitchStmtClass:
     80   case Stmt::WhileStmtClass:
     81   case Stmt::DoStmtClass:
     82   case Stmt::ForStmtClass:
     83   case Stmt::GotoStmtClass:
     84   case Stmt::IndirectGotoStmtClass:
     85   case Stmt::ContinueStmtClass:
     86   case Stmt::BreakStmtClass:
     87   case Stmt::ReturnStmtClass:
     88   case Stmt::DeclStmtClass:
     89   case Stmt::AsmStmtClass:
     90   case Stmt::ObjCAtTryStmtClass:
     91   case Stmt::ObjCAtCatchStmtClass:
     92   case Stmt::ObjCAtFinallyStmtClass:
     93   case Stmt::ObjCAtThrowStmtClass:
     94   case Stmt::ObjCAtSynchronizedStmtClass:
     95   case Stmt::ObjCAutoreleasePoolStmtClass:
     96   case Stmt::ObjCForCollectionStmtClass:
     97   case Stmt::CXXCatchStmtClass:
     98   case Stmt::CXXTryStmtClass:
     99   case Stmt::CXXForRangeStmtClass:
    100   case Stmt::SEHTryStmtClass:
    101   case Stmt::SEHExceptStmtClass:
    102   case Stmt::SEHFinallyStmtClass:
    103   case Stmt::MaterializeTemporaryExprClass:
    104     K = CXCursor_UnexposedStmt;
    105     break;
    106 
    107   case Stmt::LabelStmtClass:
    108     K = CXCursor_LabelStmt;
    109     break;
    110 
    111   case Stmt::PredefinedExprClass:
    112   case Stmt::IntegerLiteralClass:
    113   case Stmt::FloatingLiteralClass:
    114   case Stmt::ImaginaryLiteralClass:
    115   case Stmt::StringLiteralClass:
    116   case Stmt::CharacterLiteralClass:
    117   case Stmt::ParenExprClass:
    118   case Stmt::UnaryOperatorClass:
    119   case Stmt::OffsetOfExprClass:
    120   case Stmt::UnaryExprOrTypeTraitExprClass:
    121   case Stmt::ArraySubscriptExprClass:
    122   case Stmt::BinaryOperatorClass:
    123   case Stmt::CompoundAssignOperatorClass:
    124   case Stmt::ConditionalOperatorClass:
    125   case Stmt::BinaryConditionalOperatorClass:
    126   case Stmt::ImplicitCastExprClass:
    127   case Stmt::CStyleCastExprClass:
    128   case Stmt::CompoundLiteralExprClass:
    129   case Stmt::ExtVectorElementExprClass:
    130   case Stmt::InitListExprClass:
    131   case Stmt::DesignatedInitExprClass:
    132   case Stmt::ImplicitValueInitExprClass:
    133   case Stmt::ParenListExprClass:
    134   case Stmt::VAArgExprClass:
    135   case Stmt::AddrLabelExprClass:
    136   case Stmt::StmtExprClass:
    137   case Stmt::ChooseExprClass:
    138   case Stmt::GenericSelectionExprClass:
    139   case Stmt::GNUNullExprClass:
    140   case Stmt::CXXStaticCastExprClass:
    141   case Stmt::CXXDynamicCastExprClass:
    142   case Stmt::CXXReinterpretCastExprClass:
    143   case Stmt::CXXConstCastExprClass:
    144   case Stmt::CXXFunctionalCastExprClass:
    145   case Stmt::CXXTypeidExprClass:
    146   case Stmt::CXXUuidofExprClass:
    147   case Stmt::CXXBoolLiteralExprClass:
    148   case Stmt::CXXNullPtrLiteralExprClass:
    149   case Stmt::CXXThisExprClass:
    150   case Stmt::CXXThrowExprClass:
    151   case Stmt::CXXDefaultArgExprClass:
    152   case Stmt::CXXScalarValueInitExprClass:
    153   case Stmt::CXXNewExprClass:
    154   case Stmt::CXXDeleteExprClass:
    155   case Stmt::CXXPseudoDestructorExprClass:
    156   case Stmt::UnresolvedLookupExprClass:
    157   case Stmt::UnaryTypeTraitExprClass:
    158   case Stmt::BinaryTypeTraitExprClass:
    159   case Stmt::ArrayTypeTraitExprClass:
    160   case Stmt::ExpressionTraitExprClass:
    161   case Stmt::DependentScopeDeclRefExprClass:
    162   case Stmt::CXXBindTemporaryExprClass:
    163   case Stmt::ExprWithCleanupsClass:
    164   case Stmt::CXXUnresolvedConstructExprClass:
    165   case Stmt::CXXDependentScopeMemberExprClass:
    166   case Stmt::UnresolvedMemberExprClass:
    167   case Stmt::CXXNoexceptExprClass:
    168   case Stmt::ObjCStringLiteralClass:
    169   case Stmt::ObjCEncodeExprClass:
    170   case Stmt::ObjCSelectorExprClass:
    171   case Stmt::ObjCProtocolExprClass:
    172   case Stmt::ObjCIsaExprClass:
    173   case Stmt::ObjCIndirectCopyRestoreExprClass:
    174   case Stmt::ObjCBridgedCastExprClass:
    175   case Stmt::ShuffleVectorExprClass:
    176   case Stmt::BlockExprClass:
    177   case Stmt::OpaqueValueExprClass:
    178   case Stmt::PackExpansionExprClass:
    179   case Stmt::SizeOfPackExprClass:
    180   case Stmt::AsTypeExprClass:
    181     K = CXCursor_UnexposedExpr;
    182     break;
    183 
    184   case Stmt::DeclRefExprClass:
    185   case Stmt::BlockDeclRefExprClass:
    186   case Stmt::SubstNonTypeTemplateParmExprClass:
    187   case Stmt::SubstNonTypeTemplateParmPackExprClass:
    188     // FIXME: UnresolvedLookupExpr?
    189     // FIXME: DependentScopeDeclRefExpr?
    190     K = CXCursor_DeclRefExpr;
    191     break;
    192 
    193   case Stmt::MemberExprClass:
    194   case Stmt::ObjCIvarRefExprClass:
    195   case Stmt::ObjCPropertyRefExprClass:
    196     // FIXME: UnresolvedMemberExpr?
    197     // FIXME: CXXDependentScopeMemberExpr?
    198     K = CXCursor_MemberRefExpr;
    199     break;
    200 
    201   case Stmt::CallExprClass:
    202   case Stmt::CXXOperatorCallExprClass:
    203   case Stmt::CXXMemberCallExprClass:
    204   case Stmt::CUDAKernelCallExprClass:
    205   case Stmt::CXXConstructExprClass:
    206   case Stmt::CXXTemporaryObjectExprClass:
    207     // FIXME: CXXUnresolvedConstructExpr
    208     K = CXCursor_CallExpr;
    209     break;
    210 
    211   case Stmt::ObjCMessageExprClass:
    212     K = CXCursor_ObjCMessageExpr;
    213     break;
    214   }
    215 
    216   CXCursor C = { K, { Parent, S, TU } };
    217   return C;
    218 }
    219 
    220 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
    221                                                SourceLocation Loc,
    222                                                CXTranslationUnit TU) {
    223   assert(Super && TU && "Invalid arguments!");
    224   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    225   CXCursor C = { CXCursor_ObjCSuperClassRef, { Super, RawLoc, TU } };
    226   return C;
    227 }
    228 
    229 std::pair<ObjCInterfaceDecl *, SourceLocation>
    230 cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
    231   assert(C.kind == CXCursor_ObjCSuperClassRef);
    232   return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
    233            SourceLocation::getFromRawEncoding(
    234                                       reinterpret_cast<uintptr_t>(C.data[1])));
    235 }
    236 
    237 CXCursor cxcursor::MakeCursorObjCProtocolRef(ObjCProtocolDecl *Super,
    238                                              SourceLocation Loc,
    239                                              CXTranslationUnit TU) {
    240   assert(Super && TU && "Invalid arguments!");
    241   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    242   CXCursor C = { CXCursor_ObjCProtocolRef, { Super, RawLoc, TU } };
    243   return C;
    244 }
    245 
    246 std::pair<ObjCProtocolDecl *, SourceLocation>
    247 cxcursor::getCursorObjCProtocolRef(CXCursor C) {
    248   assert(C.kind == CXCursor_ObjCProtocolRef);
    249   return std::make_pair(static_cast<ObjCProtocolDecl *>(C.data[0]),
    250            SourceLocation::getFromRawEncoding(
    251                                       reinterpret_cast<uintptr_t>(C.data[1])));
    252 }
    253 
    254 CXCursor cxcursor::MakeCursorObjCClassRef(ObjCInterfaceDecl *Class,
    255                                           SourceLocation Loc,
    256                                           CXTranslationUnit TU) {
    257   // 'Class' can be null for invalid code.
    258   if (!Class)
    259     return MakeCXCursorInvalid(CXCursor_InvalidCode);
    260   assert(TU && "Invalid arguments!");
    261   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    262   CXCursor C = { CXCursor_ObjCClassRef, { Class, RawLoc, TU } };
    263   return C;
    264 }
    265 
    266 std::pair<ObjCInterfaceDecl *, SourceLocation>
    267 cxcursor::getCursorObjCClassRef(CXCursor C) {
    268   assert(C.kind == CXCursor_ObjCClassRef);
    269   return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
    270            SourceLocation::getFromRawEncoding(
    271                                       reinterpret_cast<uintptr_t>(C.data[1])));
    272 }
    273 
    274 CXCursor cxcursor::MakeCursorTypeRef(TypeDecl *Type, SourceLocation Loc,
    275                                      CXTranslationUnit TU) {
    276   assert(Type && TU && "Invalid arguments!");
    277   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    278   CXCursor C = { CXCursor_TypeRef, { Type, RawLoc, TU } };
    279   return C;
    280 }
    281 
    282 std::pair<TypeDecl *, SourceLocation>
    283 cxcursor::getCursorTypeRef(CXCursor C) {
    284   assert(C.kind == CXCursor_TypeRef);
    285   return std::make_pair(static_cast<TypeDecl *>(C.data[0]),
    286            SourceLocation::getFromRawEncoding(
    287                                       reinterpret_cast<uintptr_t>(C.data[1])));
    288 }
    289 
    290 CXCursor cxcursor::MakeCursorTemplateRef(TemplateDecl *Template,
    291                                          SourceLocation Loc,
    292                                          CXTranslationUnit TU) {
    293   assert(Template && TU && "Invalid arguments!");
    294   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    295   CXCursor C = { CXCursor_TemplateRef, { Template, RawLoc, TU } };
    296   return C;
    297 }
    298 
    299 std::pair<TemplateDecl *, SourceLocation>
    300 cxcursor::getCursorTemplateRef(CXCursor C) {
    301   assert(C.kind == CXCursor_TemplateRef);
    302   return std::make_pair(static_cast<TemplateDecl *>(C.data[0]),
    303                         SourceLocation::getFromRawEncoding(
    304                                        reinterpret_cast<uintptr_t>(C.data[1])));
    305 }
    306 
    307 CXCursor cxcursor::MakeCursorNamespaceRef(NamedDecl *NS, SourceLocation Loc,
    308                                           CXTranslationUnit TU) {
    309 
    310   assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
    311          "Invalid arguments!");
    312   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    313   CXCursor C = { CXCursor_NamespaceRef, { NS, RawLoc, TU } };
    314   return C;
    315 }
    316 
    317 std::pair<NamedDecl *, SourceLocation>
    318 cxcursor::getCursorNamespaceRef(CXCursor C) {
    319   assert(C.kind == CXCursor_NamespaceRef);
    320   return std::make_pair(static_cast<NamedDecl *>(C.data[0]),
    321                         SourceLocation::getFromRawEncoding(
    322                                        reinterpret_cast<uintptr_t>(C.data[1])));
    323 }
    324 
    325 CXCursor cxcursor::MakeCursorMemberRef(FieldDecl *Field, SourceLocation Loc,
    326                                        CXTranslationUnit TU) {
    327 
    328   assert(Field && TU && "Invalid arguments!");
    329   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    330   CXCursor C = { CXCursor_MemberRef, { Field, RawLoc, TU } };
    331   return C;
    332 }
    333 
    334 std::pair<FieldDecl *, SourceLocation>
    335 cxcursor::getCursorMemberRef(CXCursor C) {
    336   assert(C.kind == CXCursor_MemberRef);
    337   return std::make_pair(static_cast<FieldDecl *>(C.data[0]),
    338                         SourceLocation::getFromRawEncoding(
    339                                        reinterpret_cast<uintptr_t>(C.data[1])));
    340 }
    341 
    342 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(CXXBaseSpecifier *B,
    343                                               CXTranslationUnit TU){
    344   CXCursor C = { CXCursor_CXXBaseSpecifier, { B, 0, TU } };
    345   return C;
    346 }
    347 
    348 CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
    349   assert(C.kind == CXCursor_CXXBaseSpecifier);
    350   return static_cast<CXXBaseSpecifier*>(C.data[0]);
    351 }
    352 
    353 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
    354                                                     CXTranslationUnit TU) {
    355   CXCursor C = { CXCursor_PreprocessingDirective,
    356                  { reinterpret_cast<void *>(Range.getBegin().getRawEncoding()),
    357                    reinterpret_cast<void *>(Range.getEnd().getRawEncoding()),
    358                    TU }
    359                };
    360   return C;
    361 }
    362 
    363 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
    364   assert(C.kind == CXCursor_PreprocessingDirective);
    365   return SourceRange(SourceLocation::getFromRawEncoding(
    366                                       reinterpret_cast<uintptr_t> (C.data[0])),
    367                      SourceLocation::getFromRawEncoding(
    368                                       reinterpret_cast<uintptr_t> (C.data[1])));
    369 }
    370 
    371 CXCursor cxcursor::MakeMacroDefinitionCursor(MacroDefinition *MI,
    372                                              CXTranslationUnit TU) {
    373   CXCursor C = { CXCursor_MacroDefinition, { MI, 0, TU } };
    374   return C;
    375 }
    376 
    377 MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) {
    378   assert(C.kind == CXCursor_MacroDefinition);
    379   return static_cast<MacroDefinition *>(C.data[0]);
    380 }
    381 
    382 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
    383                                             CXTranslationUnit TU) {
    384   CXCursor C = { CXCursor_MacroExpansion, { MI, 0, TU } };
    385   return C;
    386 }
    387 
    388 MacroExpansion *cxcursor::getCursorMacroExpansion(CXCursor C) {
    389   assert(C.kind == CXCursor_MacroExpansion);
    390   return static_cast<MacroExpansion *>(C.data[0]);
    391 }
    392 
    393 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
    394                                                 CXTranslationUnit TU) {
    395   CXCursor C = { CXCursor_InclusionDirective, { ID, 0, TU } };
    396   return C;
    397 }
    398 
    399 InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
    400   assert(C.kind == CXCursor_InclusionDirective);
    401   return static_cast<InclusionDirective *>(C.data[0]);
    402 }
    403 
    404 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
    405                                       CXTranslationUnit TU) {
    406 
    407   assert(Label && TU && "Invalid arguments!");
    408   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    409   CXCursor C = { CXCursor_LabelRef, { Label, RawLoc, TU } };
    410   return C;
    411 }
    412 
    413 std::pair<LabelStmt*, SourceLocation>
    414 cxcursor::getCursorLabelRef(CXCursor C) {
    415   assert(C.kind == CXCursor_LabelRef);
    416   return std::make_pair(static_cast<LabelStmt *>(C.data[0]),
    417                         SourceLocation::getFromRawEncoding(
    418                                        reinterpret_cast<uintptr_t>(C.data[1])));
    419 }
    420 
    421 CXCursor cxcursor::MakeCursorOverloadedDeclRef(OverloadExpr *E,
    422                                                CXTranslationUnit TU) {
    423   assert(E && TU && "Invalid arguments!");
    424   OverloadedDeclRefStorage Storage(E);
    425   void *RawLoc = reinterpret_cast<void *>(E->getNameLoc().getRawEncoding());
    426   CXCursor C = {
    427                  CXCursor_OverloadedDeclRef,
    428                  { Storage.getOpaqueValue(), RawLoc, TU }
    429                };
    430   return C;
    431 }
    432 
    433 CXCursor cxcursor::MakeCursorOverloadedDeclRef(Decl *D,
    434                                                SourceLocation Loc,
    435                                                CXTranslationUnit TU) {
    436   assert(D && TU && "Invalid arguments!");
    437   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    438   OverloadedDeclRefStorage Storage(D);
    439   CXCursor C = {
    440     CXCursor_OverloadedDeclRef,
    441     { Storage.getOpaqueValue(), RawLoc, TU }
    442   };
    443   return C;
    444 }
    445 
    446 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
    447                                                SourceLocation Loc,
    448                                                CXTranslationUnit TU) {
    449   assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
    450   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
    451   OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
    452   CXCursor C = {
    453     CXCursor_OverloadedDeclRef,
    454     { Storage.getOpaqueValue(), RawLoc, TU }
    455   };
    456   return C;
    457 }
    458 
    459 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
    460 cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
    461   assert(C.kind == CXCursor_OverloadedDeclRef);
    462   return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(C.data[0]),
    463                         SourceLocation::getFromRawEncoding(
    464                                        reinterpret_cast<uintptr_t>(C.data[1])));
    465 }
    466 
    467 Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
    468   return (Decl *)Cursor.data[0];
    469 }
    470 
    471 Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
    472   return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
    473 }
    474 
    475 Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
    476   if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
    477       Cursor.kind == CXCursor_ObjCProtocolRef ||
    478       Cursor.kind == CXCursor_ObjCClassRef)
    479     return 0;
    480 
    481   return (Stmt *)Cursor.data[1];
    482 }
    483 
    484 Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
    485   return (Attr *)Cursor.data[1];
    486 }
    487 
    488 Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) {
    489   return (Decl *)Cursor.data[0];
    490 }
    491 
    492 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
    493   return getCursorASTUnit(Cursor)->getASTContext();
    494 }
    495 
    496 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
    497   return static_cast<ASTUnit *>(static_cast<CXTranslationUnit>(Cursor.data[2])
    498                                   ->TUData);
    499 }
    500 
    501 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
    502   return static_cast<CXTranslationUnit>(Cursor.data[2]);
    503 }
    504 
    505 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
    506   return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
    507          X.data[2] == Y.data[2];
    508 }
    509 
    510 // FIXME: Remove once we can model DeclGroups and their appropriate ranges
    511 // properly in the ASTs.
    512 bool cxcursor::isFirstInDeclGroup(CXCursor C) {
    513   assert(clang_isDeclaration(C.kind));
    514   return ((uintptr_t) (C.data[1])) != 0;
    515 }
    516 
    517 //===----------------------------------------------------------------------===//
    518 // CXCursorSet.
    519 //===----------------------------------------------------------------------===//
    520 
    521 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
    522 
    523 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
    524   return (CXCursorSet) setImpl;
    525 }
    526 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
    527   return (CXCursorSet_Impl*) set;
    528 }
    529 namespace llvm {
    530 template<> struct DenseMapInfo<CXCursor> {
    531 public:
    532   static inline CXCursor getEmptyKey() {
    533     return MakeCXCursorInvalid(CXCursor_InvalidFile);
    534   }
    535   static inline CXCursor getTombstoneKey() {
    536     return MakeCXCursorInvalid(CXCursor_NoDeclFound);
    537   }
    538   static inline unsigned getHashValue(const CXCursor &cursor) {
    539     return llvm::DenseMapInfo<std::pair<void*,void*> >
    540       ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1]));
    541   }
    542   static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
    543     return x.kind == y.kind &&
    544            x.data[0] == y.data[0] &&
    545            x.data[1] == y.data[1];
    546   }
    547 };
    548 }
    549 
    550 extern "C" {
    551 CXCursorSet clang_createCXCursorSet() {
    552   return packCXCursorSet(new CXCursorSet_Impl());
    553 }
    554 
    555 void clang_disposeCXCursorSet(CXCursorSet set) {
    556   delete unpackCXCursorSet(set);
    557 }
    558 
    559 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
    560   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
    561   if (!setImpl)
    562     return 0;
    563   return setImpl->find(cursor) == setImpl->end();
    564 }
    565 
    566 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
    567   // Do not insert invalid cursors into the set.
    568   if (cursor.kind >= CXCursor_FirstInvalid &&
    569       cursor.kind <= CXCursor_LastInvalid)
    570     return 1;
    571 
    572   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
    573   if (!setImpl)
    574     return 1;
    575   unsigned &entry = (*setImpl)[cursor];
    576   unsigned flag = entry == 0 ? 1 : 0;
    577   entry = 1;
    578   return flag;
    579 }
    580 } // end: extern "C"
    581