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