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