xref: /llvm-project/clang/tools/libclang/CXCursor.cpp (revision 29c42f2a25d6ce7008b9164be2cfc8f30e678ab9) 
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/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/ExprObjC.h"
27 #include "clang-c/Index.h"
28 #include "llvm/Support/ErrorHandling.h"
29 
30 using namespace clang;
31 using namespace cxcursor;
32 
33 CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K) {
34   assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid);
35   CXCursor C = { K, 0, { 0, 0, 0 } };
36   return C;
37 }
38 
39 static CXCursorKind GetCursorKind(const Attr *A) {
40   assert(A && "Invalid arguments!");
41   switch (A->getKind()) {
42     default: break;
43     case attr::IBAction: return CXCursor_IBActionAttr;
44     case attr::IBOutlet: return CXCursor_IBOutletAttr;
45     case attr::IBOutletCollection: return CXCursor_IBOutletCollectionAttr;
46     case attr::Final: return CXCursor_CXXFinalAttr;
47     case attr::Override: return CXCursor_CXXOverrideAttr;
48     case attr::Annotate: return CXCursor_AnnotateAttr;
49     case attr::AsmLabel: return CXCursor_AsmLabelAttr;
50   }
51 
52   return CXCursor_UnexposedAttr;
53 }
54 
55 CXCursor cxcursor::MakeCXCursor(const Attr *A, Decl *Parent,
56                                 CXTranslationUnit TU) {
57   assert(A && Parent && TU && "Invalid arguments!");
58   CXCursor C = { GetCursorKind(A), 0, { Parent, (void*)A, TU } };
59   return C;
60 }
61 
62 CXCursor cxcursor::MakeCXCursor(Decl *D, CXTranslationUnit TU,
63                                 SourceRange RegionOfInterest,
64                                 bool FirstInDeclGroup) {
65   assert(D && TU && "Invalid arguments!");
66 
67   CXCursorKind K = getCursorKindForDecl(D);
68 
69   if (K == CXCursor_ObjCClassMethodDecl ||
70       K == CXCursor_ObjCInstanceMethodDecl) {
71     int SelectorIdIndex = -1;
72     // Check if cursor points to a selector id.
73     if (RegionOfInterest.isValid() &&
74         RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) {
75       SmallVector<SourceLocation, 16> SelLocs;
76       cast<ObjCMethodDecl>(D)->getSelectorLocs(SelLocs);
77       SmallVector<SourceLocation, 16>::iterator
78         I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin());
79       if (I != SelLocs.end())
80         SelectorIdIndex = I - SelLocs.begin();
81     }
82     CXCursor C = { K, SelectorIdIndex,
83                    { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }};
84     return C;
85   }
86 
87   CXCursor C = { K, 0, { D, (void*)(intptr_t) (FirstInDeclGroup ? 1 : 0), TU }};
88   return C;
89 }
90 
91 CXCursor cxcursor::MakeCXCursor(Stmt *S, Decl *Parent, CXTranslationUnit TU,
92                                 SourceRange RegionOfInterest) {
93   assert(S && TU && "Invalid arguments!");
94   CXCursorKind K = CXCursor_NotImplemented;
95 
96   switch (S->getStmtClass()) {
97   case Stmt::NoStmtClass:
98     break;
99 
100   case Stmt::CaseStmtClass:
101     K = CXCursor_CaseStmt;
102     break;
103 
104   case Stmt::DefaultStmtClass:
105     K = CXCursor_DefaultStmt;
106     break;
107 
108   case Stmt::IfStmtClass:
109     K = CXCursor_IfStmt;
110     break;
111 
112   case Stmt::SwitchStmtClass:
113     K = CXCursor_SwitchStmt;
114     break;
115 
116   case Stmt::WhileStmtClass:
117     K = CXCursor_WhileStmt;
118     break;
119 
120   case Stmt::DoStmtClass:
121     K = CXCursor_DoStmt;
122     break;
123 
124   case Stmt::ForStmtClass:
125     K = CXCursor_ForStmt;
126     break;
127 
128   case Stmt::GotoStmtClass:
129     K = CXCursor_GotoStmt;
130     break;
131 
132   case Stmt::IndirectGotoStmtClass:
133     K = CXCursor_IndirectGotoStmt;
134     break;
135 
136   case Stmt::ContinueStmtClass:
137     K = CXCursor_ContinueStmt;
138     break;
139 
140   case Stmt::BreakStmtClass:
141     K = CXCursor_BreakStmt;
142     break;
143 
144   case Stmt::ReturnStmtClass:
145     K = CXCursor_ReturnStmt;
146     break;
147 
148   case Stmt::AsmStmtClass:
149     K = CXCursor_AsmStmt;
150     break;
151 
152   case Stmt::ObjCAtTryStmtClass:
153     K = CXCursor_ObjCAtTryStmt;
154     break;
155 
156   case Stmt::ObjCAtCatchStmtClass:
157     K = CXCursor_ObjCAtCatchStmt;
158     break;
159 
160   case Stmt::ObjCAtFinallyStmtClass:
161     K = CXCursor_ObjCAtFinallyStmt;
162     break;
163 
164   case Stmt::ObjCAtThrowStmtClass:
165     K = CXCursor_ObjCAtThrowStmt;
166     break;
167 
168   case Stmt::ObjCAtSynchronizedStmtClass:
169     K = CXCursor_ObjCAtSynchronizedStmt;
170     break;
171 
172   case Stmt::ObjCAutoreleasePoolStmtClass:
173     K = CXCursor_ObjCAutoreleasePoolStmt;
174     break;
175 
176   case Stmt::ObjCForCollectionStmtClass:
177     K = CXCursor_ObjCForCollectionStmt;
178     break;
179 
180   case Stmt::CXXCatchStmtClass:
181     K = CXCursor_CXXCatchStmt;
182     break;
183 
184   case Stmt::CXXTryStmtClass:
185     K = CXCursor_CXXTryStmt;
186     break;
187 
188   case Stmt::CXXForRangeStmtClass:
189     K = CXCursor_CXXForRangeStmt;
190     break;
191 
192   case Stmt::SEHTryStmtClass:
193     K = CXCursor_SEHTryStmt;
194     break;
195 
196   case Stmt::SEHExceptStmtClass:
197     K = CXCursor_SEHExceptStmt;
198     break;
199 
200   case Stmt::SEHFinallyStmtClass:
201     K = CXCursor_SEHFinallyStmt;
202     break;
203 
204   case Stmt::ArrayTypeTraitExprClass:
205   case Stmt::AsTypeExprClass:
206   case Stmt::AtomicExprClass:
207   case Stmt::BinaryConditionalOperatorClass:
208   case Stmt::BinaryTypeTraitExprClass:
209   case Stmt::TypeTraitExprClass:
210   case Stmt::CXXBindTemporaryExprClass:
211   case Stmt::CXXDefaultArgExprClass:
212   case Stmt::CXXScalarValueInitExprClass:
213   case Stmt::CXXUuidofExprClass:
214   case Stmt::ChooseExprClass:
215   case Stmt::DesignatedInitExprClass:
216   case Stmt::ExprWithCleanupsClass:
217   case Stmt::ExpressionTraitExprClass:
218   case Stmt::ExtVectorElementExprClass:
219   case Stmt::ImplicitCastExprClass:
220   case Stmt::ImplicitValueInitExprClass:
221   case Stmt::MaterializeTemporaryExprClass:
222   case Stmt::ObjCIndirectCopyRestoreExprClass:
223   case Stmt::OffsetOfExprClass:
224   case Stmt::ParenListExprClass:
225   case Stmt::PredefinedExprClass:
226   case Stmt::ShuffleVectorExprClass:
227   case Stmt::UnaryExprOrTypeTraitExprClass:
228   case Stmt::UnaryTypeTraitExprClass:
229   case Stmt::VAArgExprClass:
230     K = CXCursor_UnexposedExpr;
231     break;
232 
233   case Stmt::OpaqueValueExprClass:
234     if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr())
235       return MakeCXCursor(Src, Parent, TU, RegionOfInterest);
236     K = CXCursor_UnexposedExpr;
237     break;
238 
239   case Stmt::PseudoObjectExprClass:
240     return MakeCXCursor(cast<PseudoObjectExpr>(S)->getSyntacticForm(),
241                         Parent, TU, RegionOfInterest);
242 
243   case Stmt::CompoundStmtClass:
244     K = CXCursor_CompoundStmt;
245     break;
246 
247   case Stmt::NullStmtClass:
248     K = CXCursor_NullStmt;
249     break;
250 
251   case Stmt::LabelStmtClass:
252     K = CXCursor_LabelStmt;
253     break;
254 
255   case Stmt::DeclStmtClass:
256     K = CXCursor_DeclStmt;
257     break;
258 
259   case Stmt::IntegerLiteralClass:
260     K = CXCursor_IntegerLiteral;
261     break;
262 
263   case Stmt::FloatingLiteralClass:
264     K = CXCursor_FloatingLiteral;
265     break;
266 
267   case Stmt::ImaginaryLiteralClass:
268     K = CXCursor_ImaginaryLiteral;
269     break;
270 
271   case Stmt::StringLiteralClass:
272     K = CXCursor_StringLiteral;
273     break;
274 
275   case Stmt::CharacterLiteralClass:
276     K = CXCursor_CharacterLiteral;
277     break;
278 
279   case Stmt::ParenExprClass:
280     K = CXCursor_ParenExpr;
281     break;
282 
283   case Stmt::UnaryOperatorClass:
284     K = CXCursor_UnaryOperator;
285     break;
286 
287   case Stmt::CXXNoexceptExprClass:
288     K = CXCursor_UnaryExpr;
289     break;
290 
291   case Stmt::ArraySubscriptExprClass:
292     K = CXCursor_ArraySubscriptExpr;
293     break;
294 
295   case Stmt::BinaryOperatorClass:
296     K = CXCursor_BinaryOperator;
297     break;
298 
299   case Stmt::CompoundAssignOperatorClass:
300     K = CXCursor_CompoundAssignOperator;
301     break;
302 
303   case Stmt::ConditionalOperatorClass:
304     K = CXCursor_ConditionalOperator;
305     break;
306 
307   case Stmt::CStyleCastExprClass:
308     K = CXCursor_CStyleCastExpr;
309     break;
310 
311   case Stmt::CompoundLiteralExprClass:
312     K = CXCursor_CompoundLiteralExpr;
313     break;
314 
315   case Stmt::InitListExprClass:
316     K = CXCursor_InitListExpr;
317     break;
318 
319   case Stmt::AddrLabelExprClass:
320     K = CXCursor_AddrLabelExpr;
321     break;
322 
323   case Stmt::StmtExprClass:
324     K = CXCursor_StmtExpr;
325     break;
326 
327   case Stmt::GenericSelectionExprClass:
328     K = CXCursor_GenericSelectionExpr;
329     break;
330 
331   case Stmt::GNUNullExprClass:
332     K = CXCursor_GNUNullExpr;
333     break;
334 
335   case Stmt::CXXStaticCastExprClass:
336     K = CXCursor_CXXStaticCastExpr;
337     break;
338 
339   case Stmt::CXXDynamicCastExprClass:
340     K = CXCursor_CXXDynamicCastExpr;
341     break;
342 
343   case Stmt::CXXReinterpretCastExprClass:
344     K = CXCursor_CXXReinterpretCastExpr;
345     break;
346 
347   case Stmt::CXXConstCastExprClass:
348     K = CXCursor_CXXConstCastExpr;
349     break;
350 
351   case Stmt::CXXFunctionalCastExprClass:
352     K = CXCursor_CXXFunctionalCastExpr;
353     break;
354 
355   case Stmt::CXXTypeidExprClass:
356     K = CXCursor_CXXTypeidExpr;
357     break;
358 
359   case Stmt::CXXBoolLiteralExprClass:
360     K = CXCursor_CXXBoolLiteralExpr;
361     break;
362 
363   case Stmt::CXXNullPtrLiteralExprClass:
364     K = CXCursor_CXXNullPtrLiteralExpr;
365     break;
366 
367   case Stmt::CXXThisExprClass:
368     K = CXCursor_CXXThisExpr;
369     break;
370 
371   case Stmt::CXXThrowExprClass:
372     K = CXCursor_CXXThrowExpr;
373     break;
374 
375   case Stmt::CXXNewExprClass:
376     K = CXCursor_CXXNewExpr;
377     break;
378 
379   case Stmt::CXXDeleteExprClass:
380     K = CXCursor_CXXDeleteExpr;
381     break;
382 
383   case Stmt::ObjCStringLiteralClass:
384     K = CXCursor_ObjCStringLiteral;
385     break;
386 
387   case Stmt::ObjCEncodeExprClass:
388     K = CXCursor_ObjCEncodeExpr;
389     break;
390 
391   case Stmt::ObjCSelectorExprClass:
392     K = CXCursor_ObjCSelectorExpr;
393     break;
394 
395   case Stmt::ObjCProtocolExprClass:
396     K = CXCursor_ObjCProtocolExpr;
397     break;
398 
399   case Stmt::ObjCBridgedCastExprClass:
400     K = CXCursor_ObjCBridgedCastExpr;
401     break;
402 
403   case Stmt::BlockExprClass:
404     K = CXCursor_BlockExpr;
405     break;
406 
407   case Stmt::PackExpansionExprClass:
408     K = CXCursor_PackExpansionExpr;
409     break;
410 
411   case Stmt::SizeOfPackExprClass:
412     K = CXCursor_SizeOfPackExpr;
413     break;
414 
415   case Stmt::BlockDeclRefExprClass:
416   case Stmt::DeclRefExprClass:
417   case Stmt::DependentScopeDeclRefExprClass:
418   case Stmt::SubstNonTypeTemplateParmExprClass:
419   case Stmt::SubstNonTypeTemplateParmPackExprClass:
420   case Stmt::UnresolvedLookupExprClass:
421     K = CXCursor_DeclRefExpr;
422     break;
423 
424   case Stmt::CXXDependentScopeMemberExprClass:
425   case Stmt::CXXPseudoDestructorExprClass:
426   case Stmt::MemberExprClass:
427   case Stmt::ObjCIsaExprClass:
428   case Stmt::ObjCIvarRefExprClass:
429   case Stmt::ObjCPropertyRefExprClass:
430   case Stmt::UnresolvedMemberExprClass:
431     K = CXCursor_MemberRefExpr;
432     break;
433 
434   case Stmt::CallExprClass:
435   case Stmt::CXXOperatorCallExprClass:
436   case Stmt::CXXMemberCallExprClass:
437   case Stmt::CUDAKernelCallExprClass:
438   case Stmt::CXXConstructExprClass:
439   case Stmt::CXXTemporaryObjectExprClass:
440   case Stmt::CXXUnresolvedConstructExprClass:
441     K = CXCursor_CallExpr;
442     break;
443 
444   case Stmt::LambdaExprClass:
445     K = CXCursor_LambdaExpr;
446     break;
447 
448   case Stmt::ObjCMessageExprClass: {
449     K = CXCursor_ObjCMessageExpr;
450     int SelectorIdIndex = -1;
451     // Check if cursor points to a selector id.
452     if (RegionOfInterest.isValid() &&
453         RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) {
454       SmallVector<SourceLocation, 16> SelLocs;
455       cast<ObjCMessageExpr>(S)->getSelectorLocs(SelLocs);
456       SmallVector<SourceLocation, 16>::iterator
457         I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin());
458       if (I != SelLocs.end())
459         SelectorIdIndex = I - SelLocs.begin();
460     }
461     CXCursor C = { K, 0, { Parent, S, TU } };
462     return getSelectorIdentifierCursor(SelectorIdIndex, C);
463   }
464 
465   case Stmt::MSDependentExistsStmtClass:
466     K = CXCursor_UnexposedStmt;
467     break;
468   }
469 
470   CXCursor C = { K, 0, { Parent, S, TU } };
471   return C;
472 }
473 
474 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
475                                                SourceLocation Loc,
476                                                CXTranslationUnit TU) {
477   assert(Super && TU && "Invalid arguments!");
478   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
479   CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } };
480   return C;
481 }
482 
483 std::pair<ObjCInterfaceDecl *, SourceLocation>
484 cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
485   assert(C.kind == CXCursor_ObjCSuperClassRef);
486   return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
487            SourceLocation::getFromRawEncoding(
488                                       reinterpret_cast<uintptr_t>(C.data[1])));
489 }
490 
491 CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto,
492                                              SourceLocation Loc,
493                                              CXTranslationUnit TU) {
494   assert(Proto && TU && "Invalid arguments!");
495   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
496   CXCursor C = { CXCursor_ObjCProtocolRef, 0, { (void*)Proto, RawLoc, TU } };
497   return C;
498 }
499 
500 std::pair<ObjCProtocolDecl *, SourceLocation>
501 cxcursor::getCursorObjCProtocolRef(CXCursor C) {
502   assert(C.kind == CXCursor_ObjCProtocolRef);
503   return std::make_pair(static_cast<ObjCProtocolDecl *>(C.data[0]),
504            SourceLocation::getFromRawEncoding(
505                                       reinterpret_cast<uintptr_t>(C.data[1])));
506 }
507 
508 CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class,
509                                           SourceLocation Loc,
510                                           CXTranslationUnit TU) {
511   // 'Class' can be null for invalid code.
512   if (!Class)
513     return MakeCXCursorInvalid(CXCursor_InvalidCode);
514   assert(TU && "Invalid arguments!");
515   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
516   CXCursor C = { CXCursor_ObjCClassRef, 0, { (void*)Class, RawLoc, TU } };
517   return C;
518 }
519 
520 std::pair<ObjCInterfaceDecl *, SourceLocation>
521 cxcursor::getCursorObjCClassRef(CXCursor C) {
522   assert(C.kind == CXCursor_ObjCClassRef);
523   return std::make_pair(static_cast<ObjCInterfaceDecl *>(C.data[0]),
524            SourceLocation::getFromRawEncoding(
525                                       reinterpret_cast<uintptr_t>(C.data[1])));
526 }
527 
528 CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc,
529                                      CXTranslationUnit TU) {
530   assert(Type && TU && "Invalid arguments!");
531   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
532   CXCursor C = { CXCursor_TypeRef, 0, { (void*)Type, RawLoc, TU } };
533   return C;
534 }
535 
536 std::pair<TypeDecl *, SourceLocation>
537 cxcursor::getCursorTypeRef(CXCursor C) {
538   assert(C.kind == CXCursor_TypeRef);
539   return std::make_pair(static_cast<TypeDecl *>(C.data[0]),
540            SourceLocation::getFromRawEncoding(
541                                       reinterpret_cast<uintptr_t>(C.data[1])));
542 }
543 
544 CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template,
545                                          SourceLocation Loc,
546                                          CXTranslationUnit TU) {
547   assert(Template && TU && "Invalid arguments!");
548   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
549   CXCursor C = { CXCursor_TemplateRef, 0, { (void*)Template, RawLoc, TU } };
550   return C;
551 }
552 
553 std::pair<TemplateDecl *, SourceLocation>
554 cxcursor::getCursorTemplateRef(CXCursor C) {
555   assert(C.kind == CXCursor_TemplateRef);
556   return std::make_pair(static_cast<TemplateDecl *>(C.data[0]),
557                         SourceLocation::getFromRawEncoding(
558                                        reinterpret_cast<uintptr_t>(C.data[1])));
559 }
560 
561 CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS,
562                                           SourceLocation Loc,
563                                           CXTranslationUnit TU) {
564 
565   assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
566          "Invalid arguments!");
567   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
568   CXCursor C = { CXCursor_NamespaceRef, 0, { (void*)NS, RawLoc, TU } };
569   return C;
570 }
571 
572 std::pair<NamedDecl *, SourceLocation>
573 cxcursor::getCursorNamespaceRef(CXCursor C) {
574   assert(C.kind == CXCursor_NamespaceRef);
575   return std::make_pair(static_cast<NamedDecl *>(C.data[0]),
576                         SourceLocation::getFromRawEncoding(
577                                        reinterpret_cast<uintptr_t>(C.data[1])));
578 }
579 
580 CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc,
581                                          CXTranslationUnit TU) {
582 
583   assert(Var && TU && "Invalid arguments!");
584   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
585   CXCursor C = { CXCursor_VariableRef, 0, { (void*)Var, RawLoc, TU } };
586   return C;
587 }
588 
589 std::pair<VarDecl *, SourceLocation>
590 cxcursor::getCursorVariableRef(CXCursor C) {
591   assert(C.kind == CXCursor_VariableRef);
592   return std::make_pair(static_cast<VarDecl *>(C.data[0]),
593                         SourceLocation::getFromRawEncoding(
594                           reinterpret_cast<uintptr_t>(C.data[1])));
595 }
596 
597 CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc,
598                                        CXTranslationUnit TU) {
599 
600   assert(Field && TU && "Invalid arguments!");
601   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
602   CXCursor C = { CXCursor_MemberRef, 0, { (void*)Field, RawLoc, TU } };
603   return C;
604 }
605 
606 std::pair<FieldDecl *, SourceLocation>
607 cxcursor::getCursorMemberRef(CXCursor C) {
608   assert(C.kind == CXCursor_MemberRef);
609   return std::make_pair(static_cast<FieldDecl *>(C.data[0]),
610                         SourceLocation::getFromRawEncoding(
611                                        reinterpret_cast<uintptr_t>(C.data[1])));
612 }
613 
614 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B,
615                                               CXTranslationUnit TU){
616   CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { (void*)B, 0, TU } };
617   return C;
618 }
619 
620 CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
621   assert(C.kind == CXCursor_CXXBaseSpecifier);
622   return static_cast<CXXBaseSpecifier*>(C.data[0]);
623 }
624 
625 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
626                                                     CXTranslationUnit TU) {
627   CXCursor C = { CXCursor_PreprocessingDirective, 0,
628                  { reinterpret_cast<void *>(Range.getBegin().getRawEncoding()),
629                    reinterpret_cast<void *>(Range.getEnd().getRawEncoding()),
630                    TU }
631                };
632   return C;
633 }
634 
635 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
636   assert(C.kind == CXCursor_PreprocessingDirective);
637   SourceRange Range = SourceRange(SourceLocation::getFromRawEncoding(
638                                       reinterpret_cast<uintptr_t> (C.data[0])),
639                      SourceLocation::getFromRawEncoding(
640                                       reinterpret_cast<uintptr_t> (C.data[1])));
641   ASTUnit *TU = getCursorASTUnit(C);
642   return TU->mapRangeFromPreamble(Range);
643 }
644 
645 CXCursor cxcursor::MakeMacroDefinitionCursor(MacroDefinition *MI,
646                                              CXTranslationUnit TU) {
647   CXCursor C = { CXCursor_MacroDefinition, 0, { MI, 0, TU } };
648   return C;
649 }
650 
651 MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) {
652   assert(C.kind == CXCursor_MacroDefinition);
653   return static_cast<MacroDefinition *>(C.data[0]);
654 }
655 
656 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
657                                             CXTranslationUnit TU) {
658   CXCursor C = { CXCursor_MacroExpansion, 0, { MI, 0, TU } };
659   return C;
660 }
661 
662 MacroExpansion *cxcursor::getCursorMacroExpansion(CXCursor C) {
663   assert(C.kind == CXCursor_MacroExpansion);
664   return static_cast<MacroExpansion *>(C.data[0]);
665 }
666 
667 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
668                                                 CXTranslationUnit TU) {
669   CXCursor C = { CXCursor_InclusionDirective, 0, { ID, 0, TU } };
670   return C;
671 }
672 
673 InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
674   assert(C.kind == CXCursor_InclusionDirective);
675   return static_cast<InclusionDirective *>(C.data[0]);
676 }
677 
678 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
679                                       CXTranslationUnit TU) {
680 
681   assert(Label && TU && "Invalid arguments!");
682   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
683   CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } };
684   return C;
685 }
686 
687 std::pair<LabelStmt*, SourceLocation>
688 cxcursor::getCursorLabelRef(CXCursor C) {
689   assert(C.kind == CXCursor_LabelRef);
690   return std::make_pair(static_cast<LabelStmt *>(C.data[0]),
691                         SourceLocation::getFromRawEncoding(
692                                        reinterpret_cast<uintptr_t>(C.data[1])));
693 }
694 
695 CXCursor cxcursor::MakeCursorOverloadedDeclRef(OverloadExpr *E,
696                                                CXTranslationUnit TU) {
697   assert(E && TU && "Invalid arguments!");
698   OverloadedDeclRefStorage Storage(E);
699   void *RawLoc = reinterpret_cast<void *>(E->getNameLoc().getRawEncoding());
700   CXCursor C = {
701                  CXCursor_OverloadedDeclRef, 0,
702                  { Storage.getOpaqueValue(), RawLoc, TU }
703                };
704   return C;
705 }
706 
707 CXCursor cxcursor::MakeCursorOverloadedDeclRef(Decl *D,
708                                                SourceLocation Loc,
709                                                CXTranslationUnit TU) {
710   assert(D && TU && "Invalid arguments!");
711   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
712   OverloadedDeclRefStorage Storage(D);
713   CXCursor C = {
714     CXCursor_OverloadedDeclRef, 0,
715     { Storage.getOpaqueValue(), RawLoc, TU }
716   };
717   return C;
718 }
719 
720 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
721                                                SourceLocation Loc,
722                                                CXTranslationUnit TU) {
723   assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
724   void *RawLoc = reinterpret_cast<void *>(Loc.getRawEncoding());
725   OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
726   CXCursor C = {
727     CXCursor_OverloadedDeclRef, 0,
728     { Storage.getOpaqueValue(), RawLoc, TU }
729   };
730   return C;
731 }
732 
733 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
734 cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
735   assert(C.kind == CXCursor_OverloadedDeclRef);
736   return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(C.data[0]),
737                         SourceLocation::getFromRawEncoding(
738                                        reinterpret_cast<uintptr_t>(C.data[1])));
739 }
740 
741 Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
742   return (Decl *)Cursor.data[0];
743 }
744 
745 Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
746   return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
747 }
748 
749 Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
750   if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
751       Cursor.kind == CXCursor_ObjCProtocolRef ||
752       Cursor.kind == CXCursor_ObjCClassRef)
753     return 0;
754 
755   return (Stmt *)Cursor.data[1];
756 }
757 
758 Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
759   return (Attr *)Cursor.data[1];
760 }
761 
762 Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) {
763   return (Decl *)Cursor.data[0];
764 }
765 
766 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
767   return getCursorASTUnit(Cursor)->getASTContext();
768 }
769 
770 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
771   CXTranslationUnit TU = static_cast<CXTranslationUnit>(Cursor.data[2]);
772   if (!TU)
773     return 0;
774   return static_cast<ASTUnit *>(TU->TUData);
775 }
776 
777 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
778   return static_cast<CXTranslationUnit>(Cursor.data[2]);
779 }
780 
781 static void CollectOverriddenMethods(CXTranslationUnit TU,
782                                      DeclContext *Ctx,
783                                      ObjCMethodDecl *Method,
784                                      SmallVectorImpl<CXCursor> &Methods) {
785   if (!Ctx)
786     return;
787 
788   // If we have a class or category implementation, jump straight to the
789   // interface.
790   if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(Ctx))
791     return CollectOverriddenMethods(TU, Impl->getClassInterface(),
792                                     Method, Methods);
793 
794   ObjCContainerDecl *Container = dyn_cast<ObjCContainerDecl>(Ctx);
795   if (!Container)
796     return;
797 
798   // Check whether we have a matching method at this level.
799   if (ObjCMethodDecl *Overridden = Container->getMethod(Method->getSelector(),
800                                                     Method->isInstanceMethod()))
801     if (Method != Overridden) {
802       // We found an override at this level; there is no need to look
803       // into other protocols or categories.
804       Methods.push_back(MakeCXCursor(Overridden, TU));
805       return;
806     }
807 
808   if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
809     for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(),
810                                           PEnd = Protocol->protocol_end();
811          P != PEnd; ++P)
812       CollectOverriddenMethods(TU, *P, Method, Methods);
813   }
814 
815   if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
816     for (ObjCCategoryDecl::protocol_iterator P = Category->protocol_begin(),
817                                           PEnd = Category->protocol_end();
818          P != PEnd; ++P)
819       CollectOverriddenMethods(TU, *P, Method, Methods);
820   }
821 
822   if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
823     for (ObjCInterfaceDecl::protocol_iterator P = Interface->protocol_begin(),
824                                            PEnd = Interface->protocol_end();
825          P != PEnd; ++P)
826       CollectOverriddenMethods(TU, *P, Method, Methods);
827 
828     for (ObjCCategoryDecl *Category = Interface->getCategoryList();
829          Category; Category = Category->getNextClassCategory())
830       CollectOverriddenMethods(TU, Category, Method, Methods);
831 
832     // We only look into the superclass if we haven't found anything yet.
833     if (Methods.empty())
834       if (ObjCInterfaceDecl *Super = Interface->getSuperClass())
835         return CollectOverriddenMethods(TU, Super, Method, Methods);
836   }
837 }
838 
839 void cxcursor::getOverriddenCursors(CXCursor cursor,
840                                     SmallVectorImpl<CXCursor> &overridden) {
841   if (!clang_isDeclaration(cursor.kind))
842     return;
843 
844   Decl *D = getCursorDecl(cursor);
845   if (!D)
846     return;
847 
848   // Handle C++ member functions.
849   CXTranslationUnit TU = getCursorTU(cursor);
850   if (CXXMethodDecl *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
851     for (CXXMethodDecl::method_iterator
852               M = CXXMethod->begin_overridden_methods(),
853            MEnd = CXXMethod->end_overridden_methods();
854          M != MEnd; ++M)
855       overridden.push_back(MakeCXCursor(const_cast<CXXMethodDecl*>(*M), TU));
856     return;
857   }
858 
859   ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D);
860   if (!Method)
861     return;
862 
863   // Handle Objective-C methods.
864   CollectOverriddenMethods(TU, Method->getDeclContext(), Method, overridden);
865 }
866 
867 std::pair<int, SourceLocation>
868 cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) {
869   if (cursor.kind == CXCursor_ObjCMessageExpr) {
870     if (cursor.xdata != -1)
871       return std::make_pair(cursor.xdata,
872                             cast<ObjCMessageExpr>(getCursorExpr(cursor))
873                                                 ->getSelectorLoc(cursor.xdata));
874   } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
875              cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
876     if (cursor.xdata != -1)
877       return std::make_pair(cursor.xdata,
878                             cast<ObjCMethodDecl>(getCursorDecl(cursor))
879                                                 ->getSelectorLoc(cursor.xdata));
880   }
881 
882   return std::make_pair(-1, SourceLocation());
883 }
884 
885 CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) {
886   CXCursor newCursor = cursor;
887 
888   if (cursor.kind == CXCursor_ObjCMessageExpr) {
889     if (SelIdx == -1 ||
890         unsigned(SelIdx) >= cast<ObjCMessageExpr>(getCursorExpr(cursor))
891                                                          ->getNumSelectorLocs())
892       newCursor.xdata = -1;
893     else
894       newCursor.xdata = SelIdx;
895   } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
896              cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
897     if (SelIdx == -1 ||
898         unsigned(SelIdx) >= cast<ObjCMethodDecl>(getCursorDecl(cursor))
899                                                          ->getNumSelectorLocs())
900       newCursor.xdata = -1;
901     else
902       newCursor.xdata = SelIdx;
903   }
904 
905   return newCursor;
906 }
907 
908 CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) {
909   if (cursor.kind != CXCursor_CallExpr)
910     return cursor;
911 
912   if (cursor.xdata == 0)
913     return cursor;
914 
915   Expr *E = getCursorExpr(cursor);
916   TypeSourceInfo *Type = 0;
917   if (CXXUnresolvedConstructExpr *
918         UnCtor = dyn_cast<CXXUnresolvedConstructExpr>(E)) {
919     Type = UnCtor->getTypeSourceInfo();
920   } else if (CXXTemporaryObjectExpr *Tmp = dyn_cast<CXXTemporaryObjectExpr>(E)){
921     Type = Tmp->getTypeSourceInfo();
922   }
923 
924   if (!Type)
925     return cursor;
926 
927   CXTranslationUnit TU = getCursorTU(cursor);
928   QualType Ty = Type->getType();
929   TypeLoc TL = Type->getTypeLoc();
930   SourceLocation Loc = TL.getBeginLoc();
931 
932   if (const ElaboratedType *ElabT = Ty->getAs<ElaboratedType>()) {
933     Ty = ElabT->getNamedType();
934     ElaboratedTypeLoc ElabTL = cast<ElaboratedTypeLoc>(TL);
935     Loc = ElabTL.getNamedTypeLoc().getBeginLoc();
936   }
937 
938   if (const TypedefType *Typedef = Ty->getAs<TypedefType>())
939     return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU);
940   if (const TagType *Tag = Ty->getAs<TagType>())
941     return MakeCursorTypeRef(Tag->getDecl(), Loc, TU);
942   if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>())
943     return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU);
944 
945   return cursor;
946 }
947 
948 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
949   return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
950          X.data[2] == Y.data[2];
951 }
952 
953 // FIXME: Remove once we can model DeclGroups and their appropriate ranges
954 // properly in the ASTs.
955 bool cxcursor::isFirstInDeclGroup(CXCursor C) {
956   assert(clang_isDeclaration(C.kind));
957   return ((uintptr_t) (C.data[1])) != 0;
958 }
959 
960 //===----------------------------------------------------------------------===//
961 // libclang CXCursor APIs
962 //===----------------------------------------------------------------------===//
963 
964 extern "C" {
965 
966 int clang_Cursor_isNull(CXCursor cursor) {
967   return clang_equalCursors(cursor, clang_getNullCursor());
968 }
969 
970 CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) {
971   return getCursorTU(cursor);
972 }
973 
974 } // end: extern "C"
975 
976 //===----------------------------------------------------------------------===//
977 // CXCursorSet.
978 //===----------------------------------------------------------------------===//
979 
980 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
981 
982 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
983   return (CXCursorSet) setImpl;
984 }
985 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
986   return (CXCursorSet_Impl*) set;
987 }
988 namespace llvm {
989 template<> struct DenseMapInfo<CXCursor> {
990 public:
991   static inline CXCursor getEmptyKey() {
992     return MakeCXCursorInvalid(CXCursor_InvalidFile);
993   }
994   static inline CXCursor getTombstoneKey() {
995     return MakeCXCursorInvalid(CXCursor_NoDeclFound);
996   }
997   static inline unsigned getHashValue(const CXCursor &cursor) {
998     return llvm::DenseMapInfo<std::pair<void*,void*> >
999       ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1]));
1000   }
1001   static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
1002     return x.kind == y.kind &&
1003            x.data[0] == y.data[0] &&
1004            x.data[1] == y.data[1];
1005   }
1006 };
1007 }
1008 
1009 extern "C" {
1010 CXCursorSet clang_createCXCursorSet() {
1011   return packCXCursorSet(new CXCursorSet_Impl());
1012 }
1013 
1014 void clang_disposeCXCursorSet(CXCursorSet set) {
1015   delete unpackCXCursorSet(set);
1016 }
1017 
1018 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
1019   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1020   if (!setImpl)
1021     return 0;
1022   return setImpl->find(cursor) == setImpl->end();
1023 }
1024 
1025 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
1026   // Do not insert invalid cursors into the set.
1027   if (cursor.kind >= CXCursor_FirstInvalid &&
1028       cursor.kind <= CXCursor_LastInvalid)
1029     return 1;
1030 
1031   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1032   if (!setImpl)
1033     return 1;
1034   unsigned &entry = (*setImpl)[cursor];
1035   unsigned flag = entry == 0 ? 1 : 0;
1036   entry = 1;
1037   return flag;
1038 }
1039 
1040 CXCompletionString clang_getCursorCompletionString(CXCursor cursor) {
1041   enum CXCursorKind kind = clang_getCursorKind(cursor);
1042   if (clang_isDeclaration(kind)) {
1043     Decl *decl = getCursorDecl(cursor);
1044     if (NamedDecl *namedDecl = dyn_cast_or_null<NamedDecl>(decl)) {
1045       ASTUnit *unit = getCursorASTUnit(cursor);
1046       CodeCompletionAllocator *Allocator
1047         = unit->getCursorCompletionAllocator().getPtr();
1048       CodeCompletionResult Result(namedDecl);
1049       CodeCompletionString *String
1050         = Result.CreateCodeCompletionString(unit->getASTContext(),
1051                                             unit->getPreprocessor(),
1052                                             *Allocator);
1053       return String;
1054     }
1055   }
1056   else if (kind == CXCursor_MacroDefinition) {
1057     MacroDefinition *definition = getCursorMacroDefinition(cursor);
1058     const IdentifierInfo *MacroInfo = definition->getName();
1059     ASTUnit *unit = getCursorASTUnit(cursor);
1060     CodeCompletionAllocator *Allocator
1061       = unit->getCursorCompletionAllocator().getPtr();
1062     CodeCompletionResult Result(const_cast<IdentifierInfo *>(MacroInfo));
1063     CodeCompletionString *String
1064       = Result.CreateCodeCompletionString(unit->getASTContext(),
1065                                           unit->getPreprocessor(),
1066                                           *Allocator);
1067     return String;
1068   }
1069   return NULL;
1070 }
1071 
1072 } // end: extern "C"
1073