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