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