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