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