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