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   }
671 
672   CXCursor C = { K, 0, { Parent, S, TU } };
673   return C;
674 }
675 
676 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
677                                                SourceLocation Loc,
678                                                CXTranslationUnit TU) {
679   assert(Super && TU && "Invalid arguments!");
680   void *RawLoc = Loc.getPtrEncoding();
681   CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } };
682   return C;
683 }
684 
685 std::pair<const ObjCInterfaceDecl *, SourceLocation>
686 cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
687   assert(C.kind == CXCursor_ObjCSuperClassRef);
688   return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]),
689                         SourceLocation::getFromPtrEncoding(C.data[1]));
690 }
691 
692 CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto,
693                                              SourceLocation Loc,
694                                              CXTranslationUnit TU) {
695   assert(Proto && TU && "Invalid arguments!");
696   void *RawLoc = Loc.getPtrEncoding();
697   CXCursor C = { CXCursor_ObjCProtocolRef, 0, { Proto, RawLoc, TU } };
698   return C;
699 }
700 
701 std::pair<const ObjCProtocolDecl *, SourceLocation>
702 cxcursor::getCursorObjCProtocolRef(CXCursor C) {
703   assert(C.kind == CXCursor_ObjCProtocolRef);
704   return std::make_pair(static_cast<const ObjCProtocolDecl *>(C.data[0]),
705                         SourceLocation::getFromPtrEncoding(C.data[1]));
706 }
707 
708 CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class,
709                                           SourceLocation Loc,
710                                           CXTranslationUnit TU) {
711   // 'Class' can be null for invalid code.
712   if (!Class)
713     return MakeCXCursorInvalid(CXCursor_InvalidCode);
714   assert(TU && "Invalid arguments!");
715   void *RawLoc = Loc.getPtrEncoding();
716   CXCursor C = { CXCursor_ObjCClassRef, 0, { Class, RawLoc, TU } };
717   return C;
718 }
719 
720 std::pair<const ObjCInterfaceDecl *, SourceLocation>
721 cxcursor::getCursorObjCClassRef(CXCursor C) {
722   assert(C.kind == CXCursor_ObjCClassRef);
723   return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]),
724                         SourceLocation::getFromPtrEncoding(C.data[1]));
725 }
726 
727 CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc,
728                                      CXTranslationUnit TU) {
729   assert(Type && TU && "Invalid arguments!");
730   void *RawLoc = Loc.getPtrEncoding();
731   CXCursor C = { CXCursor_TypeRef, 0, { Type, RawLoc, TU } };
732   return C;
733 }
734 
735 std::pair<const TypeDecl *, SourceLocation>
736 cxcursor::getCursorTypeRef(CXCursor C) {
737   assert(C.kind == CXCursor_TypeRef);
738   return std::make_pair(static_cast<const TypeDecl *>(C.data[0]),
739                         SourceLocation::getFromPtrEncoding(C.data[1]));
740 }
741 
742 CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template,
743                                          SourceLocation Loc,
744                                          CXTranslationUnit TU) {
745   assert(Template && TU && "Invalid arguments!");
746   void *RawLoc = Loc.getPtrEncoding();
747   CXCursor C = { CXCursor_TemplateRef, 0, { Template, RawLoc, TU } };
748   return C;
749 }
750 
751 std::pair<const TemplateDecl *, SourceLocation>
752 cxcursor::getCursorTemplateRef(CXCursor C) {
753   assert(C.kind == CXCursor_TemplateRef);
754   return std::make_pair(static_cast<const TemplateDecl *>(C.data[0]),
755                         SourceLocation::getFromPtrEncoding(C.data[1]));
756 }
757 
758 CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS,
759                                           SourceLocation Loc,
760                                           CXTranslationUnit TU) {
761 
762   assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
763          "Invalid arguments!");
764   void *RawLoc = Loc.getPtrEncoding();
765   CXCursor C = { CXCursor_NamespaceRef, 0, { NS, RawLoc, TU } };
766   return C;
767 }
768 
769 std::pair<const NamedDecl *, SourceLocation>
770 cxcursor::getCursorNamespaceRef(CXCursor C) {
771   assert(C.kind == CXCursor_NamespaceRef);
772   return std::make_pair(static_cast<const NamedDecl *>(C.data[0]),
773                         SourceLocation::getFromPtrEncoding(C.data[1]));
774 }
775 
776 CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc,
777                                          CXTranslationUnit TU) {
778 
779   assert(Var && TU && "Invalid arguments!");
780   void *RawLoc = Loc.getPtrEncoding();
781   CXCursor C = { CXCursor_VariableRef, 0, { Var, RawLoc, TU } };
782   return C;
783 }
784 
785 std::pair<const VarDecl *, SourceLocation>
786 cxcursor::getCursorVariableRef(CXCursor C) {
787   assert(C.kind == CXCursor_VariableRef);
788   return std::make_pair(static_cast<const VarDecl *>(C.data[0]),
789                         SourceLocation::getFromPtrEncoding(C.data[1]));
790 }
791 
792 CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc,
793                                        CXTranslationUnit TU) {
794 
795   assert(Field && TU && "Invalid arguments!");
796   void *RawLoc = Loc.getPtrEncoding();
797   CXCursor C = { CXCursor_MemberRef, 0, { Field, RawLoc, TU } };
798   return C;
799 }
800 
801 std::pair<const FieldDecl *, SourceLocation>
802 cxcursor::getCursorMemberRef(CXCursor C) {
803   assert(C.kind == CXCursor_MemberRef);
804   return std::make_pair(static_cast<const FieldDecl *>(C.data[0]),
805                         SourceLocation::getFromPtrEncoding(C.data[1]));
806 }
807 
808 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B,
809                                               CXTranslationUnit TU){
810   CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, nullptr, TU } };
811   return C;
812 }
813 
814 const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
815   assert(C.kind == CXCursor_CXXBaseSpecifier);
816   return static_cast<const CXXBaseSpecifier*>(C.data[0]);
817 }
818 
819 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
820                                                     CXTranslationUnit TU) {
821   CXCursor C = { CXCursor_PreprocessingDirective, 0,
822                  { Range.getBegin().getPtrEncoding(),
823                    Range.getEnd().getPtrEncoding(),
824                    TU }
825                };
826   return C;
827 }
828 
829 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
830   assert(C.kind == CXCursor_PreprocessingDirective);
831   SourceRange Range(SourceLocation::getFromPtrEncoding(C.data[0]),
832                     SourceLocation::getFromPtrEncoding(C.data[1]));
833   ASTUnit *TU = getCursorASTUnit(C);
834   return TU->mapRangeFromPreamble(Range);
835 }
836 
837 CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinitionRecord *MI,
838                                              CXTranslationUnit TU) {
839   CXCursor C = {CXCursor_MacroDefinition, 0, {MI, nullptr, TU}};
840   return C;
841 }
842 
843 const MacroDefinitionRecord *cxcursor::getCursorMacroDefinition(CXCursor C) {
844   assert(C.kind == CXCursor_MacroDefinition);
845   return static_cast<const MacroDefinitionRecord *>(C.data[0]);
846 }
847 
848 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
849                                             CXTranslationUnit TU) {
850   CXCursor C = { CXCursor_MacroExpansion, 0, { MI, nullptr, TU } };
851   return C;
852 }
853 
854 CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinitionRecord *MI,
855                                             SourceLocation Loc,
856                                             CXTranslationUnit TU) {
857   assert(Loc.isValid());
858   CXCursor C = {CXCursor_MacroExpansion, 0, {MI, Loc.getPtrEncoding(), TU}};
859   return C;
860 }
861 
862 const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const {
863   if (isPseudo())
864     return getAsMacroDefinition()->getName();
865   return getAsMacroExpansion()->getName();
866 }
867 const MacroDefinitionRecord *
868 cxcursor::MacroExpansionCursor::getDefinition() const {
869   if (isPseudo())
870     return getAsMacroDefinition();
871   return getAsMacroExpansion()->getDefinition();
872 }
873 SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const {
874   if (isPseudo())
875     return getPseudoLoc();
876   return getAsMacroExpansion()->getSourceRange();
877 }
878 
879 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
880                                                 CXTranslationUnit TU) {
881   CXCursor C = { CXCursor_InclusionDirective, 0, { ID, nullptr, TU } };
882   return C;
883 }
884 
885 const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
886   assert(C.kind == CXCursor_InclusionDirective);
887   return static_cast<const InclusionDirective *>(C.data[0]);
888 }
889 
890 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
891                                       CXTranslationUnit TU) {
892 
893   assert(Label && TU && "Invalid arguments!");
894   void *RawLoc = Loc.getPtrEncoding();
895   CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } };
896   return C;
897 }
898 
899 std::pair<const LabelStmt *, SourceLocation>
900 cxcursor::getCursorLabelRef(CXCursor C) {
901   assert(C.kind == CXCursor_LabelRef);
902   return std::make_pair(static_cast<const LabelStmt *>(C.data[0]),
903                         SourceLocation::getFromPtrEncoding(C.data[1]));
904 }
905 
906 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E,
907                                                CXTranslationUnit TU) {
908   assert(E && TU && "Invalid arguments!");
909   OverloadedDeclRefStorage Storage(E);
910   void *RawLoc = E->getNameLoc().getPtrEncoding();
911   CXCursor C = {
912                  CXCursor_OverloadedDeclRef, 0,
913                  { Storage.getOpaqueValue(), RawLoc, TU }
914                };
915   return C;
916 }
917 
918 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D,
919                                                SourceLocation Loc,
920                                                CXTranslationUnit TU) {
921   assert(D && TU && "Invalid arguments!");
922   void *RawLoc = Loc.getPtrEncoding();
923   OverloadedDeclRefStorage Storage(D);
924   CXCursor C = {
925     CXCursor_OverloadedDeclRef, 0,
926     { Storage.getOpaqueValue(), RawLoc, TU }
927   };
928   return C;
929 }
930 
931 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
932                                                SourceLocation Loc,
933                                                CXTranslationUnit TU) {
934   assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
935   void *RawLoc = Loc.getPtrEncoding();
936   OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
937   CXCursor C = {
938     CXCursor_OverloadedDeclRef, 0,
939     { Storage.getOpaqueValue(), RawLoc, TU }
940   };
941   return C;
942 }
943 
944 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
945 cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
946   assert(C.kind == CXCursor_OverloadedDeclRef);
947   return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(
948                                        const_cast<void *>(C.data[0])),
949                         SourceLocation::getFromPtrEncoding(C.data[1]));
950 }
951 
952 const Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
953   return static_cast<const Decl *>(Cursor.data[0]);
954 }
955 
956 const Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
957   return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
958 }
959 
960 const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
961   if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
962       Cursor.kind == CXCursor_ObjCProtocolRef ||
963       Cursor.kind == CXCursor_ObjCClassRef)
964     return nullptr;
965 
966   return static_cast<const Stmt *>(Cursor.data[1]);
967 }
968 
969 const Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
970   return static_cast<const Attr *>(Cursor.data[1]);
971 }
972 
973 const Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) {
974   return static_cast<const Decl *>(Cursor.data[0]);
975 }
976 
977 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
978   return getCursorASTUnit(Cursor)->getASTContext();
979 }
980 
981 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
982   CXTranslationUnit TU = getCursorTU(Cursor);
983   if (!TU)
984     return nullptr;
985   return cxtu::getASTUnit(TU);
986 }
987 
988 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
989   return static_cast<CXTranslationUnit>(const_cast<void*>(Cursor.data[2]));
990 }
991 
992 void cxcursor::getOverriddenCursors(CXCursor cursor,
993                                     SmallVectorImpl<CXCursor> &overridden) {
994   assert(clang_isDeclaration(cursor.kind));
995   const NamedDecl *D = dyn_cast_or_null<NamedDecl>(getCursorDecl(cursor));
996   if (!D)
997     return;
998 
999   CXTranslationUnit TU = getCursorTU(cursor);
1000   SmallVector<const NamedDecl *, 8> OverDecls;
1001   D->getASTContext().getOverriddenMethods(D, OverDecls);
1002 
1003   for (SmallVectorImpl<const NamedDecl *>::iterator
1004          I = OverDecls.begin(), E = OverDecls.end(); I != E; ++I) {
1005     overridden.push_back(MakeCXCursor(*I, TU));
1006   }
1007 }
1008 
1009 std::pair<int, SourceLocation>
1010 cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) {
1011   if (cursor.kind == CXCursor_ObjCMessageExpr) {
1012     if (cursor.xdata != -1)
1013       return std::make_pair(cursor.xdata,
1014                             cast<ObjCMessageExpr>(getCursorExpr(cursor))
1015                                                 ->getSelectorLoc(cursor.xdata));
1016   } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
1017              cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
1018     if (cursor.xdata != -1)
1019       return std::make_pair(cursor.xdata,
1020                             cast<ObjCMethodDecl>(getCursorDecl(cursor))
1021                                                 ->getSelectorLoc(cursor.xdata));
1022   }
1023 
1024   return std::make_pair(-1, SourceLocation());
1025 }
1026 
1027 CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) {
1028   CXCursor newCursor = cursor;
1029 
1030   if (cursor.kind == CXCursor_ObjCMessageExpr) {
1031     if (SelIdx == -1 ||
1032         unsigned(SelIdx) >= cast<ObjCMessageExpr>(getCursorExpr(cursor))
1033                                                          ->getNumSelectorLocs())
1034       newCursor.xdata = -1;
1035     else
1036       newCursor.xdata = SelIdx;
1037   } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
1038              cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
1039     if (SelIdx == -1 ||
1040         unsigned(SelIdx) >= cast<ObjCMethodDecl>(getCursorDecl(cursor))
1041                                                          ->getNumSelectorLocs())
1042       newCursor.xdata = -1;
1043     else
1044       newCursor.xdata = SelIdx;
1045   }
1046 
1047   return newCursor;
1048 }
1049 
1050 CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) {
1051   if (cursor.kind != CXCursor_CallExpr)
1052     return cursor;
1053 
1054   if (cursor.xdata == 0)
1055     return cursor;
1056 
1057   const Expr *E = getCursorExpr(cursor);
1058   TypeSourceInfo *Type = nullptr;
1059   if (const CXXUnresolvedConstructExpr *
1060         UnCtor = dyn_cast<CXXUnresolvedConstructExpr>(E)) {
1061     Type = UnCtor->getTypeSourceInfo();
1062   } else if (const CXXTemporaryObjectExpr *Tmp =
1063                  dyn_cast<CXXTemporaryObjectExpr>(E)){
1064     Type = Tmp->getTypeSourceInfo();
1065   }
1066 
1067   if (!Type)
1068     return cursor;
1069 
1070   CXTranslationUnit TU = getCursorTU(cursor);
1071   QualType Ty = Type->getType();
1072   TypeLoc TL = Type->getTypeLoc();
1073   SourceLocation Loc = TL.getBeginLoc();
1074 
1075   if (const ElaboratedType *ElabT = Ty->getAs<ElaboratedType>()) {
1076     Ty = ElabT->getNamedType();
1077     ElaboratedTypeLoc ElabTL = TL.castAs<ElaboratedTypeLoc>();
1078     Loc = ElabTL.getNamedTypeLoc().getBeginLoc();
1079   }
1080 
1081   if (const TypedefType *Typedef = Ty->getAs<TypedefType>())
1082     return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU);
1083   if (const TagType *Tag = Ty->getAs<TagType>())
1084     return MakeCursorTypeRef(Tag->getDecl(), Loc, TU);
1085   if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>())
1086     return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU);
1087 
1088   return cursor;
1089 }
1090 
1091 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
1092   return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
1093          X.data[2] == Y.data[2];
1094 }
1095 
1096 // FIXME: Remove once we can model DeclGroups and their appropriate ranges
1097 // properly in the ASTs.
1098 bool cxcursor::isFirstInDeclGroup(CXCursor C) {
1099   assert(clang_isDeclaration(C.kind));
1100   return ((uintptr_t) (C.data[1])) != 0;
1101 }
1102 
1103 //===----------------------------------------------------------------------===//
1104 // libclang CXCursor APIs
1105 //===----------------------------------------------------------------------===//
1106 
1107 extern "C" {
1108 
1109 int clang_Cursor_isNull(CXCursor cursor) {
1110   return clang_equalCursors(cursor, clang_getNullCursor());
1111 }
1112 
1113 CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) {
1114   return getCursorTU(cursor);
1115 }
1116 
1117 int clang_Cursor_getNumArguments(CXCursor C) {
1118   if (clang_isDeclaration(C.kind)) {
1119     const Decl *D = cxcursor::getCursorDecl(C);
1120     if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
1121       return MD->param_size();
1122     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
1123       return FD->param_size();
1124   }
1125 
1126   if (clang_isExpression(C.kind)) {
1127     const Expr *E = cxcursor::getCursorExpr(C);
1128     if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1129       return CE->getNumArgs();
1130     }
1131   }
1132 
1133   return -1;
1134 }
1135 
1136 CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) {
1137   if (clang_isDeclaration(C.kind)) {
1138     const Decl *D = cxcursor::getCursorDecl(C);
1139     if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
1140       if (i < MD->param_size())
1141         return cxcursor::MakeCXCursor(MD->parameters()[i],
1142                                       cxcursor::getCursorTU(C));
1143     } else if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
1144       if (i < FD->param_size())
1145         return cxcursor::MakeCXCursor(FD->parameters()[i],
1146                                       cxcursor::getCursorTU(C));
1147     }
1148   }
1149 
1150   if (clang_isExpression(C.kind)) {
1151     const Expr *E = cxcursor::getCursorExpr(C);
1152     if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1153       if (i < CE->getNumArgs()) {
1154         return cxcursor::MakeCXCursor(CE->getArg(i),
1155                                       getCursorDecl(C),
1156                                       cxcursor::getCursorTU(C));
1157       }
1158     }
1159   }
1160 
1161   return clang_getNullCursor();
1162 }
1163 
1164 int clang_Cursor_getNumTemplateArguments(CXCursor C) {
1165   if (clang_getCursorKind(C) != CXCursor_FunctionDecl) {
1166     return -1;
1167   }
1168 
1169   const FunctionDecl *FD = llvm::dyn_cast_or_null<clang::FunctionDecl>(
1170       getCursorDecl(C));
1171   if (!FD) {
1172     return -1;
1173   }
1174 
1175   const FunctionTemplateSpecializationInfo* SpecInfo =
1176       FD->getTemplateSpecializationInfo();
1177   if (!SpecInfo) {
1178     return -1;
1179   }
1180 
1181   return SpecInfo->TemplateArguments->size();
1182 }
1183 
1184 enum CXGetTemplateArgumentStatus {
1185   /** \brief The operation completed successfully */
1186   CXGetTemplateArgumentStatus_Success = 0,
1187 
1188   /** \brief The specified cursor did not represent a FunctionDecl. */
1189   CXGetTemplateArgumentStatus_CursorNotFunctionDecl = -1,
1190 
1191   /** \brief The specified cursor was not castable to a FunctionDecl. */
1192   CXGetTemplateArgumentStatus_BadFunctionDeclCast = -2,
1193 
1194   /** \brief A NULL FunctionTemplateSpecializationInfo was retrieved. */
1195   CXGetTemplateArgumentStatus_NullTemplSpecInfo = -3,
1196 
1197   /** \brief An invalid (OOB) argument index was specified */
1198   CXGetTemplateArgumentStatus_InvalidIndex = -4
1199 };
1200 
1201 static int clang_Cursor_getTemplateArgument(
1202     CXCursor C, unsigned I, TemplateArgument *TA) {
1203   if (clang_getCursorKind(C) != CXCursor_FunctionDecl) {
1204     return CXGetTemplateArgumentStatus_CursorNotFunctionDecl;
1205   }
1206 
1207   const FunctionDecl *FD = llvm::dyn_cast_or_null<clang::FunctionDecl>(
1208       getCursorDecl(C));
1209   if (!FD) {
1210     return CXGetTemplateArgumentStatus_BadFunctionDeclCast;
1211   }
1212 
1213   const FunctionTemplateSpecializationInfo* SpecInfo =
1214       FD->getTemplateSpecializationInfo();
1215   if (!SpecInfo) {
1216     return CXGetTemplateArgumentStatus_NullTemplSpecInfo;
1217   }
1218 
1219   if (I >= SpecInfo->TemplateArguments->size()) {
1220     return CXGetTemplateArgumentStatus_InvalidIndex;
1221   }
1222 
1223   *TA = SpecInfo->TemplateArguments->get(I);
1224   return 0;
1225 }
1226 
1227 enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C,
1228                                                                  unsigned I) {
1229   TemplateArgument TA;
1230   if (clang_Cursor_getTemplateArgument(C, I, &TA)) {
1231     return CXTemplateArgumentKind_Invalid;
1232   }
1233 
1234   switch (TA.getKind()) {
1235     case TemplateArgument::Null: return CXTemplateArgumentKind_Null;
1236     case TemplateArgument::Type: return CXTemplateArgumentKind_Type;
1237     case TemplateArgument::Declaration:
1238       return CXTemplateArgumentKind_Declaration;
1239     case TemplateArgument::NullPtr: return CXTemplateArgumentKind_NullPtr;
1240     case TemplateArgument::Integral: return CXTemplateArgumentKind_Integral;
1241     case TemplateArgument::Template: return CXTemplateArgumentKind_Template;
1242     case TemplateArgument::TemplateExpansion:
1243       return CXTemplateArgumentKind_TemplateExpansion;
1244     case TemplateArgument::Expression: return CXTemplateArgumentKind_Expression;
1245     case TemplateArgument::Pack: return CXTemplateArgumentKind_Pack;
1246   }
1247 
1248   return CXTemplateArgumentKind_Invalid;
1249 }
1250 
1251 CXType clang_Cursor_getTemplateArgumentType(CXCursor C, unsigned I) {
1252   TemplateArgument TA;
1253   if (clang_Cursor_getTemplateArgument(C, I, &TA) !=
1254       CXGetTemplateArgumentStatus_Success) {
1255     return cxtype::MakeCXType(QualType(), getCursorTU(C));
1256   }
1257 
1258   if (TA.getKind() != TemplateArgument::Type) {
1259     return cxtype::MakeCXType(QualType(), getCursorTU(C));
1260   }
1261 
1262   return cxtype::MakeCXType(TA.getAsType(), getCursorTU(C));
1263 }
1264 
1265 long long clang_Cursor_getTemplateArgumentValue(CXCursor C, unsigned I) {
1266   TemplateArgument TA;
1267   if (clang_Cursor_getTemplateArgument(C, I, &TA) !=
1268       CXGetTemplateArgumentStatus_Success) {
1269     assert(0 && "Unable to retrieve TemplateArgument");
1270     return 0;
1271   }
1272 
1273   if (TA.getKind() != TemplateArgument::Integral) {
1274     assert(0 && "Passed template argument is not Integral");
1275     return 0;
1276   }
1277 
1278   return TA.getAsIntegral().getSExtValue();
1279 }
1280 
1281 unsigned long long clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C,
1282                                                                  unsigned I) {
1283   TemplateArgument TA;
1284   if (clang_Cursor_getTemplateArgument(C, I, &TA) !=
1285       CXGetTemplateArgumentStatus_Success) {
1286     assert(0 && "Unable to retrieve TemplateArgument");
1287     return 0;
1288   }
1289 
1290   if (TA.getKind() != TemplateArgument::Integral) {
1291     assert(0 && "Passed template argument is not Integral");
1292     return 0;
1293   }
1294 
1295   return TA.getAsIntegral().getZExtValue();
1296 }
1297 
1298 } // end: extern "C"
1299 
1300 //===----------------------------------------------------------------------===//
1301 // CXCursorSet.
1302 //===----------------------------------------------------------------------===//
1303 
1304 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
1305 
1306 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
1307   return (CXCursorSet) setImpl;
1308 }
1309 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
1310   return (CXCursorSet_Impl*) set;
1311 }
1312 namespace llvm {
1313 template<> struct DenseMapInfo<CXCursor> {
1314 public:
1315   static inline CXCursor getEmptyKey() {
1316     return MakeCXCursorInvalid(CXCursor_InvalidFile);
1317   }
1318   static inline CXCursor getTombstoneKey() {
1319     return MakeCXCursorInvalid(CXCursor_NoDeclFound);
1320   }
1321   static inline unsigned getHashValue(const CXCursor &cursor) {
1322     return llvm::DenseMapInfo<std::pair<const void *, const void *> >
1323       ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1]));
1324   }
1325   static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
1326     return x.kind == y.kind &&
1327            x.data[0] == y.data[0] &&
1328            x.data[1] == y.data[1];
1329   }
1330 };
1331 }
1332 
1333 extern "C" {
1334 CXCursorSet clang_createCXCursorSet() {
1335   return packCXCursorSet(new CXCursorSet_Impl());
1336 }
1337 
1338 void clang_disposeCXCursorSet(CXCursorSet set) {
1339   delete unpackCXCursorSet(set);
1340 }
1341 
1342 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
1343   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1344   if (!setImpl)
1345     return 0;
1346   return setImpl->find(cursor) != setImpl->end();
1347 }
1348 
1349 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
1350   // Do not insert invalid cursors into the set.
1351   if (cursor.kind >= CXCursor_FirstInvalid &&
1352       cursor.kind <= CXCursor_LastInvalid)
1353     return 1;
1354 
1355   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1356   if (!setImpl)
1357     return 1;
1358   unsigned &entry = (*setImpl)[cursor];
1359   unsigned flag = entry == 0 ? 1 : 0;
1360   entry = 1;
1361   return flag;
1362 }
1363 
1364 CXCompletionString clang_getCursorCompletionString(CXCursor cursor) {
1365   enum CXCursorKind kind = clang_getCursorKind(cursor);
1366   if (clang_isDeclaration(kind)) {
1367     const Decl *decl = getCursorDecl(cursor);
1368     if (const NamedDecl *namedDecl = dyn_cast_or_null<NamedDecl>(decl)) {
1369       ASTUnit *unit = getCursorASTUnit(cursor);
1370       CodeCompletionResult Result(namedDecl, CCP_Declaration);
1371       CodeCompletionString *String
1372         = Result.CreateCodeCompletionString(unit->getASTContext(),
1373                                             unit->getPreprocessor(),
1374                                             CodeCompletionContext::CCC_Other,
1375                                  unit->getCodeCompletionTUInfo().getAllocator(),
1376                                  unit->getCodeCompletionTUInfo(),
1377                                  true);
1378       return String;
1379     }
1380   } else if (kind == CXCursor_MacroDefinition) {
1381     const MacroDefinitionRecord *definition = getCursorMacroDefinition(cursor);
1382     const IdentifierInfo *MacroInfo = definition->getName();
1383     ASTUnit *unit = getCursorASTUnit(cursor);
1384     CodeCompletionResult Result(MacroInfo);
1385     CodeCompletionString *String
1386       = Result.CreateCodeCompletionString(unit->getASTContext(),
1387                                           unit->getPreprocessor(),
1388                                           CodeCompletionContext::CCC_Other,
1389                                  unit->getCodeCompletionTUInfo().getAllocator(),
1390                                  unit->getCodeCompletionTUInfo(),
1391                                  false);
1392     return String;
1393   }
1394   return nullptr;
1395 }
1396 } // end: extern C.
1397 
1398 namespace {
1399   struct OverridenCursorsPool {
1400     typedef SmallVector<CXCursor, 2> CursorVec;
1401     std::vector<CursorVec*> AllCursors;
1402     std::vector<CursorVec*> AvailableCursors;
1403 
1404     ~OverridenCursorsPool() {
1405       for (std::vector<CursorVec*>::iterator I = AllCursors.begin(),
1406            E = AllCursors.end(); I != E; ++I) {
1407         delete *I;
1408       }
1409     }
1410   };
1411 }
1412 
1413 void *cxcursor::createOverridenCXCursorsPool() {
1414   return new OverridenCursorsPool();
1415 }
1416 
1417 void cxcursor::disposeOverridenCXCursorsPool(void *pool) {
1418   delete static_cast<OverridenCursorsPool*>(pool);
1419 }
1420 
1421 extern "C" {
1422 void clang_getOverriddenCursors(CXCursor cursor,
1423                                 CXCursor **overridden,
1424                                 unsigned *num_overridden) {
1425   if (overridden)
1426     *overridden = nullptr;
1427   if (num_overridden)
1428     *num_overridden = 0;
1429 
1430   CXTranslationUnit TU = cxcursor::getCursorTU(cursor);
1431 
1432   if (!overridden || !num_overridden || !TU)
1433     return;
1434 
1435   if (!clang_isDeclaration(cursor.kind))
1436     return;
1437 
1438   OverridenCursorsPool &pool =
1439     *static_cast<OverridenCursorsPool*>(TU->OverridenCursorsPool);
1440 
1441   OverridenCursorsPool::CursorVec *Vec = nullptr;
1442 
1443   if (!pool.AvailableCursors.empty()) {
1444     Vec = pool.AvailableCursors.back();
1445     pool.AvailableCursors.pop_back();
1446   }
1447   else {
1448     Vec = new OverridenCursorsPool::CursorVec();
1449     pool.AllCursors.push_back(Vec);
1450   }
1451 
1452   // Clear out the vector, but don't free the memory contents.  This
1453   // reduces malloc() traffic.
1454   Vec->clear();
1455 
1456   // Use the first entry to contain a back reference to the vector.
1457   // This is a complete hack.
1458   CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU);
1459   backRefCursor.data[0] = Vec;
1460   assert(cxcursor::getCursorTU(backRefCursor) == TU);
1461   Vec->push_back(backRefCursor);
1462 
1463   // Get the overriden cursors.
1464   cxcursor::getOverriddenCursors(cursor, *Vec);
1465 
1466   // Did we get any overriden cursors?  If not, return Vec to the pool
1467   // of available cursor vectors.
1468   if (Vec->size() == 1) {
1469     pool.AvailableCursors.push_back(Vec);
1470     return;
1471   }
1472 
1473   // Now tell the caller about the overriden cursors.
1474   assert(Vec->size() > 1);
1475   *overridden = &((*Vec)[1]);
1476   *num_overridden = Vec->size() - 1;
1477 }
1478 
1479 void clang_disposeOverriddenCursors(CXCursor *overridden) {
1480   if (!overridden)
1481     return;
1482 
1483   // Use pointer arithmetic to get back the first faux entry
1484   // which has a back-reference to the TU and the vector.
1485   --overridden;
1486   OverridenCursorsPool::CursorVec *Vec =
1487       static_cast<OverridenCursorsPool::CursorVec *>(
1488           const_cast<void *>(overridden->data[0]));
1489   CXTranslationUnit TU = getCursorTU(*overridden);
1490 
1491   assert(Vec && TU);
1492 
1493   OverridenCursorsPool &pool =
1494     *static_cast<OverridenCursorsPool*>(TU->OverridenCursorsPool);
1495 
1496   pool.AvailableCursors.push_back(Vec);
1497 }
1498 
1499 int clang_Cursor_isDynamicCall(CXCursor C) {
1500   const Expr *E = nullptr;
1501   if (clang_isExpression(C.kind))
1502     E = getCursorExpr(C);
1503   if (!E)
1504     return 0;
1505 
1506   if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E)) {
1507     if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance)
1508       return false;
1509     if (auto *RecE = dyn_cast<ObjCMessageExpr>(
1510             MsgE->getInstanceReceiver()->IgnoreParenCasts())) {
1511       if (RecE->getMethodFamily() == OMF_alloc)
1512         return false;
1513     }
1514     return true;
1515   }
1516 
1517   const MemberExpr *ME = nullptr;
1518   if (isa<MemberExpr>(E))
1519     ME = cast<MemberExpr>(E);
1520   else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
1521     ME = dyn_cast_or_null<MemberExpr>(CE->getCallee());
1522 
1523   if (ME) {
1524     if (const CXXMethodDecl *
1525           MD = dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl()))
1526       return MD->isVirtual() && !ME->hasQualifier();
1527   }
1528 
1529   return 0;
1530 }
1531 
1532 CXType clang_Cursor_getReceiverType(CXCursor C) {
1533   CXTranslationUnit TU = cxcursor::getCursorTU(C);
1534   const Expr *E = nullptr;
1535   if (clang_isExpression(C.kind))
1536     E = getCursorExpr(C);
1537 
1538   if (const ObjCMessageExpr *MsgE = dyn_cast_or_null<ObjCMessageExpr>(E))
1539     return cxtype::MakeCXType(MsgE->getReceiverType(), TU);
1540 
1541   return cxtype::MakeCXType(QualType(), TU);
1542 }
1543 
1544 } // end: extern "C"
1545