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