xref: /llvm-project/clang/tools/libclang/CXCursor.cpp (revision 4c362d53105628e867452a29a0b0e5c5ff3ee60c) 
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::CaseStmtClass:
77     K = CXCursor_CaseStmt;
78     break;
79 
80   case Stmt::DefaultStmtClass:
81     K = CXCursor_DefaultStmt;
82     break;
83 
84   case Stmt::IfStmtClass:
85     K = CXCursor_IfStmt;
86     break;
87 
88   case Stmt::SwitchStmtClass:
89     K = CXCursor_SwitchStmt;
90     break;
91 
92   case Stmt::WhileStmtClass:
93     K = CXCursor_WhileStmt;
94     break;
95 
96   case Stmt::DoStmtClass:
97     K = CXCursor_DoStmt;
98     break;
99 
100   case Stmt::ForStmtClass:
101     K = CXCursor_ForStmt;
102     break;
103 
104   case Stmt::GotoStmtClass:
105     K = CXCursor_GotoStmt;
106     break;
107 
108   case Stmt::IndirectGotoStmtClass:
109     K = CXCursor_IndirectGotoStmt;
110     break;
111 
112   case Stmt::ContinueStmtClass:
113     K = CXCursor_ContinueStmt;
114     break;
115 
116   case Stmt::BreakStmtClass:
117     K = CXCursor_BreakStmt;
118     break;
119 
120   case Stmt::ReturnStmtClass:
121     K = CXCursor_ReturnStmt;
122     break;
123 
124   case Stmt::AsmStmtClass:
125     K = CXCursor_AsmStmt;
126     break;
127 
128   case Stmt::ObjCAtTryStmtClass:
129     K = CXCursor_ObjCAtTryStmt;
130     break;
131 
132   case Stmt::ObjCAtCatchStmtClass:
133     K = CXCursor_ObjCAtCatchStmt;
134     break;
135 
136   case Stmt::ObjCAtFinallyStmtClass:
137     K = CXCursor_ObjCAtFinallyStmt;
138     break;
139 
140   case Stmt::ObjCAtThrowStmtClass:
141     K = CXCursor_ObjCAtThrowStmt;
142     break;
143 
144   case Stmt::ObjCAtSynchronizedStmtClass:
145     K = CXCursor_ObjCAtSynchronizedStmt;
146     break;
147 
148   case Stmt::ObjCAutoreleasePoolStmtClass:
149     K = CXCursor_ObjCAutoreleasePoolStmt;
150     break;
151 
152   case Stmt::ObjCForCollectionStmtClass:
153     K = CXCursor_ObjCForCollectionStmt;
154     break;
155 
156   case Stmt::CXXCatchStmtClass:
157     K = CXCursor_CXXCatchStmt;
158     break;
159 
160   case Stmt::CXXTryStmtClass:
161     K = CXCursor_CXXTryStmt;
162     break;
163 
164   case Stmt::CXXForRangeStmtClass:
165     K = CXCursor_CXXForRangeStmt;
166     break;
167 
168   case Stmt::SEHTryStmtClass:
169     K = CXCursor_SEHTryStmt;
170     break;
171 
172   case Stmt::SEHExceptStmtClass:
173     K = CXCursor_SEHExceptStmt;
174     break;
175 
176   case Stmt::SEHFinallyStmtClass:
177     K = CXCursor_SEHFinallyStmt;
178     break;
179 
180   case Stmt::ArrayTypeTraitExprClass:
181   case Stmt::AsTypeExprClass:
182   case Stmt::BinaryConditionalOperatorClass:
183   case Stmt::BinaryTypeTraitExprClass:
184   case Stmt::CXXBindTemporaryExprClass:
185   case Stmt::CXXDefaultArgExprClass:
186   case Stmt::CXXScalarValueInitExprClass:
187   case Stmt::CXXUuidofExprClass:
188   case Stmt::ChooseExprClass:
189   case Stmt::DesignatedInitExprClass:
190   case Stmt::ExprWithCleanupsClass:
191   case Stmt::ExpressionTraitExprClass:
192   case Stmt::ExtVectorElementExprClass:
193   case Stmt::ImplicitCastExprClass:
194   case Stmt::ImplicitValueInitExprClass:
195   case Stmt::MaterializeTemporaryExprClass:
196   case Stmt::ObjCIndirectCopyRestoreExprClass:
197   case Stmt::OffsetOfExprClass:
198   case Stmt::OpaqueValueExprClass:
199   case Stmt::ParenListExprClass:
200   case Stmt::PredefinedExprClass:
201   case Stmt::ShuffleVectorExprClass:
202   case Stmt::UnaryExprOrTypeTraitExprClass:
203   case Stmt::UnaryTypeTraitExprClass:
204   case Stmt::VAArgExprClass:
205     K = CXCursor_UnexposedExpr;
206     break;
207 
208   case Stmt::CompoundStmtClass:
209     K = CXCursor_CompoundStmt;
210     break;
211 
212   case Stmt::NullStmtClass:
213     K = CXCursor_NullStmt;
214     break;
215 
216   case Stmt::LabelStmtClass:
217     K = CXCursor_LabelStmt;
218     break;
219 
220   case Stmt::DeclStmtClass:
221     K = CXCursor_DeclStmt;
222     break;
223 
224   case Stmt::IntegerLiteralClass:
225     K = CXCursor_IntegerLiteral;
226     break;
227 
228   case Stmt::FloatingLiteralClass:
229     K = CXCursor_FloatingLiteral;
230     break;
231 
232   case Stmt::ImaginaryLiteralClass:
233     K = CXCursor_ImaginaryLiteral;
234     break;
235 
236   case Stmt::StringLiteralClass:
237     K = CXCursor_StringLiteral;
238     break;
239 
240   case Stmt::CharacterLiteralClass:
241     K = CXCursor_CharacterLiteral;
242     break;
243 
244   case Stmt::ParenExprClass:
245     K = CXCursor_ParenExpr;
246     break;
247 
248   case Stmt::UnaryOperatorClass:
249     K = CXCursor_UnaryOperator;
250     break;
251 
252   case Stmt::CXXNoexceptExprClass:
253     K = CXCursor_UnaryExpr;
254     break;
255 
256   case Stmt::ArraySubscriptExprClass:
257     K = CXCursor_ArraySubscriptExpr;
258     break;
259 
260   case Stmt::BinaryOperatorClass:
261     K = CXCursor_BinaryOperator;
262     break;
263 
264   case Stmt::CompoundAssignOperatorClass:
265     K = CXCursor_CompoundAssignOperator;
266     break;
267 
268   case Stmt::ConditionalOperatorClass:
269     K = CXCursor_ConditionalOperator;
270     break;
271 
272   case Stmt::CStyleCastExprClass:
273     K = CXCursor_CStyleCastExpr;
274     break;
275 
276   case Stmt::CompoundLiteralExprClass:
277     K = CXCursor_CompoundLiteralExpr;
278     break;
279 
280   case Stmt::InitListExprClass:
281     K = CXCursor_InitListExpr;
282     break;
283 
284   case Stmt::AddrLabelExprClass:
285     K = CXCursor_AddrLabelExpr;
286     break;
287 
288   case Stmt::StmtExprClass:
289     K = CXCursor_StmtExpr;
290     break;
291 
292   case Stmt::GenericSelectionExprClass:
293     K = CXCursor_GenericSelectionExpr;
294     break;
295 
296   case Stmt::GNUNullExprClass:
297     K = CXCursor_GNUNullExpr;
298     break;
299 
300   case Stmt::CXXStaticCastExprClass:
301     K = CXCursor_CXXStaticCastExpr;
302     break;
303 
304   case Stmt::CXXDynamicCastExprClass:
305     K = CXCursor_CXXDynamicCastExpr;
306     break;
307 
308   case Stmt::CXXReinterpretCastExprClass:
309     K = CXCursor_CXXReinterpretCastExpr;
310     break;
311 
312   case Stmt::CXXConstCastExprClass:
313     K = CXCursor_CXXConstCastExpr;
314     break;
315 
316   case Stmt::CXXFunctionalCastExprClass:
317     K = CXCursor_CXXFunctionalCastExpr;
318     break;
319 
320   case Stmt::CXXTypeidExprClass:
321     K = CXCursor_CXXTypeidExpr;
322     break;
323 
324   case Stmt::CXXBoolLiteralExprClass:
325     K = CXCursor_CXXBoolLiteralExpr;
326     break;
327 
328   case Stmt::CXXNullPtrLiteralExprClass:
329     K = CXCursor_CXXNullPtrLiteralExpr;
330     break;
331 
332   case Stmt::CXXThisExprClass:
333     K = CXCursor_CXXThisExpr;
334     break;
335 
336   case Stmt::CXXThrowExprClass:
337     K = CXCursor_CXXThrowExpr;
338     break;
339 
340   case Stmt::CXXNewExprClass:
341     K = CXCursor_CXXNewExpr;
342     break;
343 
344   case Stmt::CXXDeleteExprClass:
345     K = CXCursor_CXXDeleteExpr;
346     break;
347 
348   case Stmt::ObjCStringLiteralClass:
349     K = CXCursor_ObjCStringLiteral;
350     break;
351 
352   case Stmt::ObjCEncodeExprClass:
353     K = CXCursor_ObjCEncodeExpr;
354     break;
355 
356   case Stmt::ObjCSelectorExprClass:
357     K = CXCursor_ObjCSelectorExpr;
358     break;
359 
360   case Stmt::ObjCProtocolExprClass:
361     K = CXCursor_ObjCProtocolExpr;
362     break;
363 
364   case Stmt::ObjCBridgedCastExprClass:
365     K = CXCursor_ObjCBridgedCastExpr;
366     break;
367 
368   case Stmt::BlockExprClass:
369     K = CXCursor_BlockExpr;
370     break;
371 
372   case Stmt::PackExpansionExprClass:
373     K = CXCursor_PackExpansionExpr;
374     break;
375 
376   case Stmt::SizeOfPackExprClass:
377     K = CXCursor_SizeOfPackExpr;
378     break;
379 
380   case Stmt::BlockDeclRefExprClass:
381   case Stmt::DeclRefExprClass:
382   case Stmt::DependentScopeDeclRefExprClass:
383   case Stmt::SubstNonTypeTemplateParmExprClass:
384   case Stmt::SubstNonTypeTemplateParmPackExprClass:
385   case Stmt::UnresolvedLookupExprClass:
386     K = CXCursor_DeclRefExpr;
387     break;
388 
389   case Stmt::CXXDependentScopeMemberExprClass:
390   case Stmt::CXXPseudoDestructorExprClass:
391   case Stmt::MemberExprClass:
392   case Stmt::ObjCIsaExprClass:
393   case Stmt::ObjCIvarRefExprClass:
394   case Stmt::ObjCPropertyRefExprClass:
395   case Stmt::UnresolvedMemberExprClass:
396     K = CXCursor_MemberRefExpr;
397     break;
398 
399   case Stmt::CallExprClass:
400   case Stmt::CXXOperatorCallExprClass:
401   case Stmt::CXXMemberCallExprClass:
402   case Stmt::CUDAKernelCallExprClass:
403   case Stmt::CXXConstructExprClass:
404   case Stmt::CXXTemporaryObjectExprClass:
405   case Stmt::CXXUnresolvedConstructExprClass:
406     K = CXCursor_CallExpr;
407     break;
408 
409   case Stmt::ObjCMessageExprClass:
410     K = CXCursor_ObjCMessageExpr;
411     break;
412   }
413 
414   CXCursor C = { K, { Parent, S, TU } };
415   return C;
416 }
417 
418 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
419                                                SourceLocation Loc,
420                                                CXTranslationUnit TU) {
421   assert(Super && TU && "Invalid arguments!");
422   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
423   CXCursor C = { CXCursor_ObjCSuperClassRef, { Super, RawLoc, TU } };
424   return C;
425 }
426 
427 std::pair<ObjCInterfaceDecl *, SourceLocation>
428 cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
429   assert(C.kind == CXCursor_ObjCSuperClassRef);
430   return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
431            SourceLocation::getFromRawEncoding(
432                                       reinterpret_cast<uintptr_t>(C.data[1])));
433 }
434 
435 CXCursor cxcursor::MakeCursorObjCProtocolRef(ObjCProtocolDecl *Super,
436                                              SourceLocation Loc,
437                                              CXTranslationUnit TU) {
438   assert(Super && TU && "Invalid arguments!");
439   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
440   CXCursor C = { CXCursor_ObjCProtocolRef, { Super, RawLoc, TU } };
441   return C;
442 }
443 
444 std::pair<ObjCProtocolDecl *, SourceLocation>
445 cxcursor::getCursorObjCProtocolRef(CXCursor C) {
446   assert(C.kind == CXCursor_ObjCProtocolRef);
447   return std::make_pair(static_cast<ObjCProtocolDecl *>(C.data[0]),
448            SourceLocation::getFromRawEncoding(
449                                       reinterpret_cast<uintptr_t>(C.data[1])));
450 }
451 
452 CXCursor cxcursor::MakeCursorObjCClassRef(ObjCInterfaceDecl *Class,
453                                           SourceLocation Loc,
454                                           CXTranslationUnit TU) {
455   // 'Class' can be null for invalid code.
456   if (!Class)
457     return MakeCXCursorInvalid(CXCursor_InvalidCode);
458   assert(TU && "Invalid arguments!");
459   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
460   CXCursor C = { CXCursor_ObjCClassRef, { Class, RawLoc, TU } };
461   return C;
462 }
463 
464 std::pair<ObjCInterfaceDecl *, SourceLocation>
465 cxcursor::getCursorObjCClassRef(CXCursor C) {
466   assert(C.kind == CXCursor_ObjCClassRef);
467   return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
468            SourceLocation::getFromRawEncoding(
469                                       reinterpret_cast<uintptr_t>(C.data[1])));
470 }
471 
472 CXCursor cxcursor::MakeCursorTypeRef(TypeDecl *Type, SourceLocation Loc,
473                                      CXTranslationUnit TU) {
474   assert(Type && TU && "Invalid arguments!");
475   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
476   CXCursor C = { CXCursor_TypeRef, { Type, RawLoc, TU } };
477   return C;
478 }
479 
480 std::pair<TypeDecl *, SourceLocation>
481 cxcursor::getCursorTypeRef(CXCursor C) {
482   assert(C.kind == CXCursor_TypeRef);
483   return std::make_pair(static_cast<TypeDecl *>(C.data[0]),
484            SourceLocation::getFromRawEncoding(
485                                       reinterpret_cast<uintptr_t>(C.data[1])));
486 }
487 
488 CXCursor cxcursor::MakeCursorTemplateRef(TemplateDecl *Template,
489                                          SourceLocation Loc,
490                                          CXTranslationUnit TU) {
491   assert(Template && TU && "Invalid arguments!");
492   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
493   CXCursor C = { CXCursor_TemplateRef, { Template, RawLoc, TU } };
494   return C;
495 }
496 
497 std::pair<TemplateDecl *, SourceLocation>
498 cxcursor::getCursorTemplateRef(CXCursor C) {
499   assert(C.kind == CXCursor_TemplateRef);
500   return std::make_pair(static_cast<TemplateDecl *>(C.data[0]),
501                         SourceLocation::getFromRawEncoding(
502                                        reinterpret_cast<uintptr_t>(C.data[1])));
503 }
504 
505 CXCursor cxcursor::MakeCursorNamespaceRef(NamedDecl *NS, SourceLocation Loc,
506                                           CXTranslationUnit TU) {
507 
508   assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
509          "Invalid arguments!");
510   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
511   CXCursor C = { CXCursor_NamespaceRef, { NS, RawLoc, TU } };
512   return C;
513 }
514 
515 std::pair<NamedDecl *, SourceLocation>
516 cxcursor::getCursorNamespaceRef(CXCursor C) {
517   assert(C.kind == CXCursor_NamespaceRef);
518   return std::make_pair(static_cast<NamedDecl *>(C.data[0]),
519                         SourceLocation::getFromRawEncoding(
520                                        reinterpret_cast<uintptr_t>(C.data[1])));
521 }
522 
523 CXCursor cxcursor::MakeCursorMemberRef(FieldDecl *Field, SourceLocation Loc,
524                                        CXTranslationUnit TU) {
525 
526   assert(Field && TU && "Invalid arguments!");
527   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
528   CXCursor C = { CXCursor_MemberRef, { Field, RawLoc, TU } };
529   return C;
530 }
531 
532 std::pair<FieldDecl *, SourceLocation>
533 cxcursor::getCursorMemberRef(CXCursor C) {
534   assert(C.kind == CXCursor_MemberRef);
535   return std::make_pair(static_cast<FieldDecl *>(C.data[0]),
536                         SourceLocation::getFromRawEncoding(
537                                        reinterpret_cast<uintptr_t>(C.data[1])));
538 }
539 
540 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(CXXBaseSpecifier *B,
541                                               CXTranslationUnit TU){
542   CXCursor C = { CXCursor_CXXBaseSpecifier, { B, 0, TU } };
543   return C;
544 }
545 
546 CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
547   assert(C.kind == CXCursor_CXXBaseSpecifier);
548   return static_cast<CXXBaseSpecifier*>(C.data[0]);
549 }
550 
551 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
552                                                     CXTranslationUnit TU) {
553   CXCursor C = { CXCursor_PreprocessingDirective,
554                  { reinterpret_cast<void *>(Range.getBegin().getRawEncoding()),
555                    reinterpret_cast<void *>(Range.getEnd().getRawEncoding()),
556                    TU }
557                };
558   return C;
559 }
560 
561 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
562   assert(C.kind == CXCursor_PreprocessingDirective);
563   SourceRange Range = SourceRange(SourceLocation::getFromRawEncoding(
564                                       reinterpret_cast<uintptr_t> (C.data[0])),
565                      SourceLocation::getFromRawEncoding(
566                                       reinterpret_cast<uintptr_t> (C.data[1])));
567   ASTUnit *TU = getCursorASTUnit(C);
568   return TU->mapRangeFromPreamble(Range);
569 }
570 
571 CXCursor cxcursor::MakeMacroDefinitionCursor(MacroDefinition *MI,
572                                              CXTranslationUnit TU) {
573   CXCursor C = { CXCursor_MacroDefinition, { MI, 0, TU } };
574   return C;
575 }
576 
577 MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) {
578   assert(C.kind == CXCursor_MacroDefinition);
579   return static_cast<MacroDefinition *>(C.data[0]);
580 }
581 
582 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
583                                             CXTranslationUnit TU) {
584   CXCursor C = { CXCursor_MacroExpansion, { MI, 0, TU } };
585   return C;
586 }
587 
588 MacroExpansion *cxcursor::getCursorMacroExpansion(CXCursor C) {
589   assert(C.kind == CXCursor_MacroExpansion);
590   return static_cast<MacroExpansion *>(C.data[0]);
591 }
592 
593 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
594                                                 CXTranslationUnit TU) {
595   CXCursor C = { CXCursor_InclusionDirective, { ID, 0, TU } };
596   return C;
597 }
598 
599 InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
600   assert(C.kind == CXCursor_InclusionDirective);
601   return static_cast<InclusionDirective *>(C.data[0]);
602 }
603 
604 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
605                                       CXTranslationUnit TU) {
606 
607   assert(Label && TU && "Invalid arguments!");
608   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
609   CXCursor C = { CXCursor_LabelRef, { Label, RawLoc, TU } };
610   return C;
611 }
612 
613 std::pair<LabelStmt*, SourceLocation>
614 cxcursor::getCursorLabelRef(CXCursor C) {
615   assert(C.kind == CXCursor_LabelRef);
616   return std::make_pair(static_cast<LabelStmt *>(C.data[0]),
617                         SourceLocation::getFromRawEncoding(
618                                        reinterpret_cast<uintptr_t>(C.data[1])));
619 }
620 
621 CXCursor cxcursor::MakeCursorOverloadedDeclRef(OverloadExpr *E,
622                                                CXTranslationUnit TU) {
623   assert(E && TU && "Invalid arguments!");
624   OverloadedDeclRefStorage Storage(E);
625   void *RawLoc = reinterpret_cast<void *>(E->getNameLoc().getRawEncoding());
626   CXCursor C = {
627                  CXCursor_OverloadedDeclRef,
628                  { Storage.getOpaqueValue(), RawLoc, TU }
629                };
630   return C;
631 }
632 
633 CXCursor cxcursor::MakeCursorOverloadedDeclRef(Decl *D,
634                                                SourceLocation Loc,
635                                                CXTranslationUnit TU) {
636   assert(D && TU && "Invalid arguments!");
637   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
638   OverloadedDeclRefStorage Storage(D);
639   CXCursor C = {
640     CXCursor_OverloadedDeclRef,
641     { Storage.getOpaqueValue(), RawLoc, TU }
642   };
643   return C;
644 }
645 
646 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
647                                                SourceLocation Loc,
648                                                CXTranslationUnit TU) {
649   assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
650   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
651   OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
652   CXCursor C = {
653     CXCursor_OverloadedDeclRef,
654     { Storage.getOpaqueValue(), RawLoc, TU }
655   };
656   return C;
657 }
658 
659 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
660 cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
661   assert(C.kind == CXCursor_OverloadedDeclRef);
662   return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(C.data[0]),
663                         SourceLocation::getFromRawEncoding(
664                                        reinterpret_cast<uintptr_t>(C.data[1])));
665 }
666 
667 Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
668   return (Decl *)Cursor.data[0];
669 }
670 
671 Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
672   return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
673 }
674 
675 Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
676   if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
677       Cursor.kind == CXCursor_ObjCProtocolRef ||
678       Cursor.kind == CXCursor_ObjCClassRef)
679     return 0;
680 
681   return (Stmt *)Cursor.data[1];
682 }
683 
684 Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
685   return (Attr *)Cursor.data[1];
686 }
687 
688 Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) {
689   return (Decl *)Cursor.data[0];
690 }
691 
692 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
693   return getCursorASTUnit(Cursor)->getASTContext();
694 }
695 
696 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
697   return static_cast<ASTUnit *>(static_cast<CXTranslationUnit>(Cursor.data[2])
698                                   ->TUData);
699 }
700 
701 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
702   return static_cast<CXTranslationUnit>(Cursor.data[2]);
703 }
704 
705 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
706   return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
707          X.data[2] == Y.data[2];
708 }
709 
710 // FIXME: Remove once we can model DeclGroups and their appropriate ranges
711 // properly in the ASTs.
712 bool cxcursor::isFirstInDeclGroup(CXCursor C) {
713   assert(clang_isDeclaration(C.kind));
714   return ((uintptr_t) (C.data[1])) != 0;
715 }
716 
717 //===----------------------------------------------------------------------===//
718 // libclang CXCursor APIs
719 //===----------------------------------------------------------------------===//
720 
721 extern "C" {
722 
723 int clang_Cursor_isNull(CXCursor cursor) {
724   return clang_equalCursors(cursor, clang_getNullCursor());
725 }
726 
727 CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) {
728   return getCursorTU(cursor);
729 }
730 
731 } // end: extern "C"
732 
733 //===----------------------------------------------------------------------===//
734 // CXCursorSet.
735 //===----------------------------------------------------------------------===//
736 
737 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
738 
739 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
740   return (CXCursorSet) setImpl;
741 }
742 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
743   return (CXCursorSet_Impl*) set;
744 }
745 namespace llvm {
746 template<> struct DenseMapInfo<CXCursor> {
747 public:
748   static inline CXCursor getEmptyKey() {
749     return MakeCXCursorInvalid(CXCursor_InvalidFile);
750   }
751   static inline CXCursor getTombstoneKey() {
752     return MakeCXCursorInvalid(CXCursor_NoDeclFound);
753   }
754   static inline unsigned getHashValue(const CXCursor &cursor) {
755     return llvm::DenseMapInfo<std::pair<void*,void*> >
756       ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1]));
757   }
758   static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
759     return x.kind == y.kind &&
760            x.data[0] == y.data[0] &&
761            x.data[1] == y.data[1];
762   }
763 };
764 }
765 
766 extern "C" {
767 CXCursorSet clang_createCXCursorSet() {
768   return packCXCursorSet(new CXCursorSet_Impl());
769 }
770 
771 void clang_disposeCXCursorSet(CXCursorSet set) {
772   delete unpackCXCursorSet(set);
773 }
774 
775 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
776   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
777   if (!setImpl)
778     return 0;
779   return setImpl->find(cursor) == setImpl->end();
780 }
781 
782 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
783   // Do not insert invalid cursors into the set.
784   if (cursor.kind >= CXCursor_FirstInvalid &&
785       cursor.kind <= CXCursor_LastInvalid)
786     return 1;
787 
788   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
789   if (!setImpl)
790     return 1;
791   unsigned &entry = (*setImpl)[cursor];
792   unsigned flag = entry == 0 ? 1 : 0;
793   entry = 1;
794   return flag;
795 }
796 
797 CXCompletionString clang_getCursorCompletionString(CXCursor cursor) {
798   enum CXCursorKind kind = clang_getCursorKind(cursor);
799   if (clang_isDeclaration(kind)) {
800     Decl *decl = getCursorDecl(cursor);
801     if (isa<NamedDecl>(decl)) {
802       NamedDecl *namedDecl = (NamedDecl *)decl;
803       ASTUnit *unit = getCursorASTUnit(cursor);
804       if (unit->hasSema()) {
805         Sema &S = unit->getSema();
806         CodeCompletionAllocator *Allocator
807           = unit->getCursorCompletionAllocator().getPtr();
808         CodeCompletionResult Result(namedDecl);
809         CodeCompletionString *String
810           = Result.CreateCodeCompletionString(S, *Allocator);
811         return String;
812       }
813     }
814   }
815   else if (kind == CXCursor_MacroDefinition) {
816     MacroDefinition *definition = getCursorMacroDefinition(cursor);
817     const IdentifierInfo *MacroInfo = definition->getName();
818     ASTUnit *unit = getCursorASTUnit(cursor);
819     if (unit->hasSema()) {
820       Sema &S = unit->getSema();
821       CodeCompletionAllocator *Allocator
822         = unit->getCursorCompletionAllocator().getPtr();
823       CodeCompletionResult Result(const_cast<IdentifierInfo *>(MacroInfo));
824       CodeCompletionString *String
825         = Result.CreateCodeCompletionString(S, *Allocator);
826       return String;
827     }
828   }
829   return NULL;
830 }
831 
832 } // end: extern "C"
833