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