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