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