xref: /llvm-project/clang/tools/libclang/CXCursor.cpp (revision cbb9034e2a04f116bfd8cd62f69ef717afa10933) 
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::UnaryTypeTraitExprClass:
239   case Stmt::VAArgExprClass:
240   case Stmt::ObjCArrayLiteralClass:
241   case Stmt::ObjCDictionaryLiteralClass:
242   case Stmt::ObjCBoxedExprClass:
243   case Stmt::ObjCSubscriptRefExprClass:
244     K = CXCursor_UnexposedExpr;
245     break;
246 
247   case Stmt::OpaqueValueExprClass:
248     if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr())
249       return MakeCXCursor(Src, Parent, TU, RegionOfInterest);
250     K = CXCursor_UnexposedExpr;
251     break;
252 
253   case Stmt::PseudoObjectExprClass:
254     return MakeCXCursor(cast<PseudoObjectExpr>(S)->getSyntacticForm(),
255                         Parent, TU, RegionOfInterest);
256 
257   case Stmt::CompoundStmtClass:
258     K = CXCursor_CompoundStmt;
259     break;
260 
261   case Stmt::NullStmtClass:
262     K = CXCursor_NullStmt;
263     break;
264 
265   case Stmt::LabelStmtClass:
266     K = CXCursor_LabelStmt;
267     break;
268 
269   case Stmt::AttributedStmtClass:
270     K = CXCursor_UnexposedStmt;
271     break;
272 
273   case Stmt::DeclStmtClass:
274     K = CXCursor_DeclStmt;
275     break;
276 
277   case Stmt::CapturedStmtClass:
278     K = CXCursor_UnexposedStmt;
279     break;
280 
281   case Stmt::IntegerLiteralClass:
282     K = CXCursor_IntegerLiteral;
283     break;
284 
285   case Stmt::FloatingLiteralClass:
286     K = CXCursor_FloatingLiteral;
287     break;
288 
289   case Stmt::ImaginaryLiteralClass:
290     K = CXCursor_ImaginaryLiteral;
291     break;
292 
293   case Stmt::StringLiteralClass:
294     K = CXCursor_StringLiteral;
295     break;
296 
297   case Stmt::CharacterLiteralClass:
298     K = CXCursor_CharacterLiteral;
299     break;
300 
301   case Stmt::ParenExprClass:
302     K = CXCursor_ParenExpr;
303     break;
304 
305   case Stmt::UnaryOperatorClass:
306     K = CXCursor_UnaryOperator;
307     break;
308 
309   case Stmt::CXXNoexceptExprClass:
310     K = CXCursor_UnaryExpr;
311     break;
312 
313   case Stmt::ArraySubscriptExprClass:
314     K = CXCursor_ArraySubscriptExpr;
315     break;
316 
317   case Stmt::BinaryOperatorClass:
318     K = CXCursor_BinaryOperator;
319     break;
320 
321   case Stmt::CompoundAssignOperatorClass:
322     K = CXCursor_CompoundAssignOperator;
323     break;
324 
325   case Stmt::ConditionalOperatorClass:
326     K = CXCursor_ConditionalOperator;
327     break;
328 
329   case Stmt::CStyleCastExprClass:
330     K = CXCursor_CStyleCastExpr;
331     break;
332 
333   case Stmt::CompoundLiteralExprClass:
334     K = CXCursor_CompoundLiteralExpr;
335     break;
336 
337   case Stmt::InitListExprClass:
338     K = CXCursor_InitListExpr;
339     break;
340 
341   case Stmt::AddrLabelExprClass:
342     K = CXCursor_AddrLabelExpr;
343     break;
344 
345   case Stmt::StmtExprClass:
346     K = CXCursor_StmtExpr;
347     break;
348 
349   case Stmt::GenericSelectionExprClass:
350     K = CXCursor_GenericSelectionExpr;
351     break;
352 
353   case Stmt::GNUNullExprClass:
354     K = CXCursor_GNUNullExpr;
355     break;
356 
357   case Stmt::CXXStaticCastExprClass:
358     K = CXCursor_CXXStaticCastExpr;
359     break;
360 
361   case Stmt::CXXDynamicCastExprClass:
362     K = CXCursor_CXXDynamicCastExpr;
363     break;
364 
365   case Stmt::CXXReinterpretCastExprClass:
366     K = CXCursor_CXXReinterpretCastExpr;
367     break;
368 
369   case Stmt::CXXConstCastExprClass:
370     K = CXCursor_CXXConstCastExpr;
371     break;
372 
373   case Stmt::CXXFunctionalCastExprClass:
374     K = CXCursor_CXXFunctionalCastExpr;
375     break;
376 
377   case Stmt::CXXTypeidExprClass:
378     K = CXCursor_CXXTypeidExpr;
379     break;
380 
381   case Stmt::CXXBoolLiteralExprClass:
382     K = CXCursor_CXXBoolLiteralExpr;
383     break;
384 
385   case Stmt::CXXNullPtrLiteralExprClass:
386     K = CXCursor_CXXNullPtrLiteralExpr;
387     break;
388 
389   case Stmt::CXXThisExprClass:
390     K = CXCursor_CXXThisExpr;
391     break;
392 
393   case Stmt::CXXThrowExprClass:
394     K = CXCursor_CXXThrowExpr;
395     break;
396 
397   case Stmt::CXXNewExprClass:
398     K = CXCursor_CXXNewExpr;
399     break;
400 
401   case Stmt::CXXDeleteExprClass:
402     K = CXCursor_CXXDeleteExpr;
403     break;
404 
405   case Stmt::ObjCStringLiteralClass:
406     K = CXCursor_ObjCStringLiteral;
407     break;
408 
409   case Stmt::ObjCEncodeExprClass:
410     K = CXCursor_ObjCEncodeExpr;
411     break;
412 
413   case Stmt::ObjCSelectorExprClass:
414     K = CXCursor_ObjCSelectorExpr;
415     break;
416 
417   case Stmt::ObjCProtocolExprClass:
418     K = CXCursor_ObjCProtocolExpr;
419     break;
420 
421   case Stmt::ObjCBoolLiteralExprClass:
422     K = CXCursor_ObjCBoolLiteralExpr;
423     break;
424 
425   case Stmt::ObjCBridgedCastExprClass:
426     K = CXCursor_ObjCBridgedCastExpr;
427     break;
428 
429   case Stmt::BlockExprClass:
430     K = CXCursor_BlockExpr;
431     break;
432 
433   case Stmt::PackExpansionExprClass:
434     K = CXCursor_PackExpansionExpr;
435     break;
436 
437   case Stmt::SizeOfPackExprClass:
438     K = CXCursor_SizeOfPackExpr;
439     break;
440 
441   case Stmt::DeclRefExprClass:
442     if (const ImplicitParamDecl *IPD =
443          dyn_cast_or_null<ImplicitParamDecl>(cast<DeclRefExpr>(S)->getDecl())) {
444       if (const ObjCMethodDecl *MD =
445             dyn_cast<ObjCMethodDecl>(IPD->getDeclContext())) {
446         if (MD->getSelfDecl() == IPD) {
447           K = CXCursor_ObjCSelfExpr;
448           break;
449         }
450       }
451     }
452 
453     K = CXCursor_DeclRefExpr;
454     break;
455 
456   case Stmt::DependentScopeDeclRefExprClass:
457   case Stmt::SubstNonTypeTemplateParmExprClass:
458   case Stmt::SubstNonTypeTemplateParmPackExprClass:
459   case Stmt::FunctionParmPackExprClass:
460   case Stmt::UnresolvedLookupExprClass:
461     K = CXCursor_DeclRefExpr;
462     break;
463 
464   case Stmt::CXXDependentScopeMemberExprClass:
465   case Stmt::CXXPseudoDestructorExprClass:
466   case Stmt::MemberExprClass:
467   case Stmt::MSPropertyRefExprClass:
468   case Stmt::ObjCIsaExprClass:
469   case Stmt::ObjCIvarRefExprClass:
470   case Stmt::ObjCPropertyRefExprClass:
471   case Stmt::UnresolvedMemberExprClass:
472     K = CXCursor_MemberRefExpr;
473     break;
474 
475   case Stmt::CallExprClass:
476   case Stmt::CXXOperatorCallExprClass:
477   case Stmt::CXXMemberCallExprClass:
478   case Stmt::CUDAKernelCallExprClass:
479   case Stmt::CXXConstructExprClass:
480   case Stmt::CXXTemporaryObjectExprClass:
481   case Stmt::CXXUnresolvedConstructExprClass:
482   case Stmt::UserDefinedLiteralClass:
483     K = CXCursor_CallExpr;
484     break;
485 
486   case Stmt::LambdaExprClass:
487     K = CXCursor_LambdaExpr;
488     break;
489 
490   case Stmt::ObjCMessageExprClass: {
491     K = CXCursor_ObjCMessageExpr;
492     int SelectorIdIndex = -1;
493     // Check if cursor points to a selector id.
494     if (RegionOfInterest.isValid() &&
495         RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) {
496       SmallVector<SourceLocation, 16> SelLocs;
497       cast<ObjCMessageExpr>(S)->getSelectorLocs(SelLocs);
498       SmallVectorImpl<SourceLocation>::iterator
499         I=std::find(SelLocs.begin(), SelLocs.end(),RegionOfInterest.getBegin());
500       if (I != SelLocs.end())
501         SelectorIdIndex = I - SelLocs.begin();
502     }
503     CXCursor C = { K, 0, { Parent, S, TU } };
504     return getSelectorIdentifierCursor(SelectorIdIndex, C);
505   }
506 
507   case Stmt::MSDependentExistsStmtClass:
508     K = CXCursor_UnexposedStmt;
509     break;
510   case Stmt::OMPParallelDirectiveClass:
511     K = CXCursor_OMPParallelDirective;
512     break;
513 
514   }
515 
516   CXCursor C = { K, 0, { Parent, S, TU } };
517   return C;
518 }
519 
520 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
521                                                SourceLocation Loc,
522                                                CXTranslationUnit TU) {
523   assert(Super && TU && "Invalid arguments!");
524   void *RawLoc = Loc.getPtrEncoding();
525   CXCursor C = { CXCursor_ObjCSuperClassRef, 0, { Super, RawLoc, TU } };
526   return C;
527 }
528 
529 std::pair<const ObjCInterfaceDecl *, SourceLocation>
530 cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
531   assert(C.kind == CXCursor_ObjCSuperClassRef);
532   return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]),
533                         SourceLocation::getFromPtrEncoding(C.data[1]));
534 }
535 
536 CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto,
537                                              SourceLocation Loc,
538                                              CXTranslationUnit TU) {
539   assert(Proto && TU && "Invalid arguments!");
540   void *RawLoc = Loc.getPtrEncoding();
541   CXCursor C = { CXCursor_ObjCProtocolRef, 0, { Proto, RawLoc, TU } };
542   return C;
543 }
544 
545 std::pair<const ObjCProtocolDecl *, SourceLocation>
546 cxcursor::getCursorObjCProtocolRef(CXCursor C) {
547   assert(C.kind == CXCursor_ObjCProtocolRef);
548   return std::make_pair(static_cast<const ObjCProtocolDecl *>(C.data[0]),
549                         SourceLocation::getFromPtrEncoding(C.data[1]));
550 }
551 
552 CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class,
553                                           SourceLocation Loc,
554                                           CXTranslationUnit TU) {
555   // 'Class' can be null for invalid code.
556   if (!Class)
557     return MakeCXCursorInvalid(CXCursor_InvalidCode);
558   assert(TU && "Invalid arguments!");
559   void *RawLoc = Loc.getPtrEncoding();
560   CXCursor C = { CXCursor_ObjCClassRef, 0, { Class, RawLoc, TU } };
561   return C;
562 }
563 
564 std::pair<const ObjCInterfaceDecl *, SourceLocation>
565 cxcursor::getCursorObjCClassRef(CXCursor C) {
566   assert(C.kind == CXCursor_ObjCClassRef);
567   return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]),
568                         SourceLocation::getFromPtrEncoding(C.data[1]));
569 }
570 
571 CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc,
572                                      CXTranslationUnit TU) {
573   assert(Type && TU && "Invalid arguments!");
574   void *RawLoc = Loc.getPtrEncoding();
575   CXCursor C = { CXCursor_TypeRef, 0, { Type, RawLoc, TU } };
576   return C;
577 }
578 
579 std::pair<const TypeDecl *, SourceLocation>
580 cxcursor::getCursorTypeRef(CXCursor C) {
581   assert(C.kind == CXCursor_TypeRef);
582   return std::make_pair(static_cast<const TypeDecl *>(C.data[0]),
583                         SourceLocation::getFromPtrEncoding(C.data[1]));
584 }
585 
586 CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template,
587                                          SourceLocation Loc,
588                                          CXTranslationUnit TU) {
589   assert(Template && TU && "Invalid arguments!");
590   void *RawLoc = Loc.getPtrEncoding();
591   CXCursor C = { CXCursor_TemplateRef, 0, { Template, RawLoc, TU } };
592   return C;
593 }
594 
595 std::pair<const TemplateDecl *, SourceLocation>
596 cxcursor::getCursorTemplateRef(CXCursor C) {
597   assert(C.kind == CXCursor_TemplateRef);
598   return std::make_pair(static_cast<const TemplateDecl *>(C.data[0]),
599                         SourceLocation::getFromPtrEncoding(C.data[1]));
600 }
601 
602 CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS,
603                                           SourceLocation Loc,
604                                           CXTranslationUnit TU) {
605 
606   assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
607          "Invalid arguments!");
608   void *RawLoc = Loc.getPtrEncoding();
609   CXCursor C = { CXCursor_NamespaceRef, 0, { NS, RawLoc, TU } };
610   return C;
611 }
612 
613 std::pair<const NamedDecl *, SourceLocation>
614 cxcursor::getCursorNamespaceRef(CXCursor C) {
615   assert(C.kind == CXCursor_NamespaceRef);
616   return std::make_pair(static_cast<const NamedDecl *>(C.data[0]),
617                         SourceLocation::getFromPtrEncoding(C.data[1]));
618 }
619 
620 CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc,
621                                          CXTranslationUnit TU) {
622 
623   assert(Var && TU && "Invalid arguments!");
624   void *RawLoc = Loc.getPtrEncoding();
625   CXCursor C = { CXCursor_VariableRef, 0, { Var, RawLoc, TU } };
626   return C;
627 }
628 
629 std::pair<const VarDecl *, SourceLocation>
630 cxcursor::getCursorVariableRef(CXCursor C) {
631   assert(C.kind == CXCursor_VariableRef);
632   return std::make_pair(static_cast<const VarDecl *>(C.data[0]),
633                         SourceLocation::getFromPtrEncoding(C.data[1]));
634 }
635 
636 CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field, SourceLocation Loc,
637                                        CXTranslationUnit TU) {
638 
639   assert(Field && TU && "Invalid arguments!");
640   void *RawLoc = Loc.getPtrEncoding();
641   CXCursor C = { CXCursor_MemberRef, 0, { Field, RawLoc, TU } };
642   return C;
643 }
644 
645 std::pair<const FieldDecl *, SourceLocation>
646 cxcursor::getCursorMemberRef(CXCursor C) {
647   assert(C.kind == CXCursor_MemberRef);
648   return std::make_pair(static_cast<const FieldDecl *>(C.data[0]),
649                         SourceLocation::getFromPtrEncoding(C.data[1]));
650 }
651 
652 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B,
653                                               CXTranslationUnit TU){
654   CXCursor C = { CXCursor_CXXBaseSpecifier, 0, { B, 0, TU } };
655   return C;
656 }
657 
658 const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
659   assert(C.kind == CXCursor_CXXBaseSpecifier);
660   return static_cast<const CXXBaseSpecifier*>(C.data[0]);
661 }
662 
663 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
664                                                     CXTranslationUnit TU) {
665   CXCursor C = { CXCursor_PreprocessingDirective, 0,
666                  { Range.getBegin().getPtrEncoding(),
667                    Range.getEnd().getPtrEncoding(),
668                    TU }
669                };
670   return C;
671 }
672 
673 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
674   assert(C.kind == CXCursor_PreprocessingDirective);
675   SourceRange Range(SourceLocation::getFromPtrEncoding(C.data[0]),
676                     SourceLocation::getFromPtrEncoding(C.data[1]));
677   ASTUnit *TU = getCursorASTUnit(C);
678   return TU->mapRangeFromPreamble(Range);
679 }
680 
681 CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinition *MI,
682                                              CXTranslationUnit TU) {
683   CXCursor C = { CXCursor_MacroDefinition, 0, { MI, 0, TU } };
684   return C;
685 }
686 
687 const MacroDefinition *cxcursor::getCursorMacroDefinition(CXCursor C) {
688   assert(C.kind == CXCursor_MacroDefinition);
689   return static_cast<const MacroDefinition *>(C.data[0]);
690 }
691 
692 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
693                                             CXTranslationUnit TU) {
694   CXCursor C = { CXCursor_MacroExpansion, 0, { MI, 0, TU } };
695   return C;
696 }
697 
698 CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinition *MI,
699                                             SourceLocation Loc,
700                                             CXTranslationUnit TU) {
701   assert(Loc.isValid());
702   CXCursor C = { CXCursor_MacroExpansion, 0, { MI, Loc.getPtrEncoding(), TU } };
703   return C;
704 }
705 
706 const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const {
707   if (isPseudo())
708     return getAsMacroDefinition()->getName();
709   return getAsMacroExpansion()->getName();
710 }
711 const MacroDefinition *cxcursor::MacroExpansionCursor::getDefinition() const {
712   if (isPseudo())
713     return getAsMacroDefinition();
714   return getAsMacroExpansion()->getDefinition();
715 }
716 SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const {
717   if (isPseudo())
718     return getPseudoLoc();
719   return getAsMacroExpansion()->getSourceRange();
720 }
721 
722 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
723                                                 CXTranslationUnit TU) {
724   CXCursor C = { CXCursor_InclusionDirective, 0, { ID, 0, TU } };
725   return C;
726 }
727 
728 const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
729   assert(C.kind == CXCursor_InclusionDirective);
730   return static_cast<const InclusionDirective *>(C.data[0]);
731 }
732 
733 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
734                                       CXTranslationUnit TU) {
735 
736   assert(Label && TU && "Invalid arguments!");
737   void *RawLoc = Loc.getPtrEncoding();
738   CXCursor C = { CXCursor_LabelRef, 0, { Label, RawLoc, TU } };
739   return C;
740 }
741 
742 std::pair<const LabelStmt *, SourceLocation>
743 cxcursor::getCursorLabelRef(CXCursor C) {
744   assert(C.kind == CXCursor_LabelRef);
745   return std::make_pair(static_cast<const LabelStmt *>(C.data[0]),
746                         SourceLocation::getFromPtrEncoding(C.data[1]));
747 }
748 
749 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E,
750                                                CXTranslationUnit TU) {
751   assert(E && TU && "Invalid arguments!");
752   OverloadedDeclRefStorage Storage(E);
753   void *RawLoc = E->getNameLoc().getPtrEncoding();
754   CXCursor C = {
755                  CXCursor_OverloadedDeclRef, 0,
756                  { Storage.getOpaqueValue(), RawLoc, TU }
757                };
758   return C;
759 }
760 
761 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D,
762                                                SourceLocation Loc,
763                                                CXTranslationUnit TU) {
764   assert(D && TU && "Invalid arguments!");
765   void *RawLoc = Loc.getPtrEncoding();
766   OverloadedDeclRefStorage Storage(D);
767   CXCursor C = {
768     CXCursor_OverloadedDeclRef, 0,
769     { Storage.getOpaqueValue(), RawLoc, TU }
770   };
771   return C;
772 }
773 
774 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
775                                                SourceLocation Loc,
776                                                CXTranslationUnit TU) {
777   assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
778   void *RawLoc = Loc.getPtrEncoding();
779   OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
780   CXCursor C = {
781     CXCursor_OverloadedDeclRef, 0,
782     { Storage.getOpaqueValue(), RawLoc, TU }
783   };
784   return C;
785 }
786 
787 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
788 cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
789   assert(C.kind == CXCursor_OverloadedDeclRef);
790   return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(
791                                        const_cast<void *>(C.data[0])),
792                         SourceLocation::getFromPtrEncoding(C.data[1]));
793 }
794 
795 const Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
796   return static_cast<const Decl *>(Cursor.data[0]);
797 }
798 
799 const Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
800   return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
801 }
802 
803 const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
804   if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
805       Cursor.kind == CXCursor_ObjCProtocolRef ||
806       Cursor.kind == CXCursor_ObjCClassRef)
807     return 0;
808 
809   return static_cast<const Stmt *>(Cursor.data[1]);
810 }
811 
812 const Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
813   return static_cast<const Attr *>(Cursor.data[1]);
814 }
815 
816 const Decl *cxcursor::getCursorParentDecl(CXCursor Cursor) {
817   return static_cast<const Decl *>(Cursor.data[0]);
818 }
819 
820 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
821   return getCursorASTUnit(Cursor)->getASTContext();
822 }
823 
824 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
825   CXTranslationUnit TU = getCursorTU(Cursor);
826   if (!TU)
827     return 0;
828   return cxtu::getASTUnit(TU);
829 }
830 
831 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
832   return static_cast<CXTranslationUnit>(const_cast<void*>(Cursor.data[2]));
833 }
834 
835 void cxcursor::getOverriddenCursors(CXCursor cursor,
836                                     SmallVectorImpl<CXCursor> &overridden) {
837   assert(clang_isDeclaration(cursor.kind));
838   const NamedDecl *D = dyn_cast_or_null<NamedDecl>(getCursorDecl(cursor));
839   if (!D)
840     return;
841 
842   CXTranslationUnit TU = getCursorTU(cursor);
843   SmallVector<const NamedDecl *, 8> OverDecls;
844   D->getASTContext().getOverriddenMethods(D, OverDecls);
845 
846   for (SmallVectorImpl<const NamedDecl *>::iterator
847          I = OverDecls.begin(), E = OverDecls.end(); I != E; ++I) {
848     overridden.push_back(MakeCXCursor(*I, TU));
849   }
850 }
851 
852 std::pair<int, SourceLocation>
853 cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) {
854   if (cursor.kind == CXCursor_ObjCMessageExpr) {
855     if (cursor.xdata != -1)
856       return std::make_pair(cursor.xdata,
857                             cast<ObjCMessageExpr>(getCursorExpr(cursor))
858                                                 ->getSelectorLoc(cursor.xdata));
859   } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
860              cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
861     if (cursor.xdata != -1)
862       return std::make_pair(cursor.xdata,
863                             cast<ObjCMethodDecl>(getCursorDecl(cursor))
864                                                 ->getSelectorLoc(cursor.xdata));
865   }
866 
867   return std::make_pair(-1, SourceLocation());
868 }
869 
870 CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) {
871   CXCursor newCursor = cursor;
872 
873   if (cursor.kind == CXCursor_ObjCMessageExpr) {
874     if (SelIdx == -1 ||
875         unsigned(SelIdx) >= cast<ObjCMessageExpr>(getCursorExpr(cursor))
876                                                          ->getNumSelectorLocs())
877       newCursor.xdata = -1;
878     else
879       newCursor.xdata = SelIdx;
880   } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
881              cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
882     if (SelIdx == -1 ||
883         unsigned(SelIdx) >= cast<ObjCMethodDecl>(getCursorDecl(cursor))
884                                                          ->getNumSelectorLocs())
885       newCursor.xdata = -1;
886     else
887       newCursor.xdata = SelIdx;
888   }
889 
890   return newCursor;
891 }
892 
893 CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) {
894   if (cursor.kind != CXCursor_CallExpr)
895     return cursor;
896 
897   if (cursor.xdata == 0)
898     return cursor;
899 
900   const Expr *E = getCursorExpr(cursor);
901   TypeSourceInfo *Type = 0;
902   if (const CXXUnresolvedConstructExpr *
903         UnCtor = dyn_cast<CXXUnresolvedConstructExpr>(E)) {
904     Type = UnCtor->getTypeSourceInfo();
905   } else if (const CXXTemporaryObjectExpr *Tmp =
906                  dyn_cast<CXXTemporaryObjectExpr>(E)){
907     Type = Tmp->getTypeSourceInfo();
908   }
909 
910   if (!Type)
911     return cursor;
912 
913   CXTranslationUnit TU = getCursorTU(cursor);
914   QualType Ty = Type->getType();
915   TypeLoc TL = Type->getTypeLoc();
916   SourceLocation Loc = TL.getBeginLoc();
917 
918   if (const ElaboratedType *ElabT = Ty->getAs<ElaboratedType>()) {
919     Ty = ElabT->getNamedType();
920     ElaboratedTypeLoc ElabTL = TL.castAs<ElaboratedTypeLoc>();
921     Loc = ElabTL.getNamedTypeLoc().getBeginLoc();
922   }
923 
924   if (const TypedefType *Typedef = Ty->getAs<TypedefType>())
925     return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU);
926   if (const TagType *Tag = Ty->getAs<TagType>())
927     return MakeCursorTypeRef(Tag->getDecl(), Loc, TU);
928   if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>())
929     return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU);
930 
931   return cursor;
932 }
933 
934 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
935   return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
936          X.data[2] == Y.data[2];
937 }
938 
939 // FIXME: Remove once we can model DeclGroups and their appropriate ranges
940 // properly in the ASTs.
941 bool cxcursor::isFirstInDeclGroup(CXCursor C) {
942   assert(clang_isDeclaration(C.kind));
943   return ((uintptr_t) (C.data[1])) != 0;
944 }
945 
946 //===----------------------------------------------------------------------===//
947 // libclang CXCursor APIs
948 //===----------------------------------------------------------------------===//
949 
950 extern "C" {
951 
952 int clang_Cursor_isNull(CXCursor cursor) {
953   return clang_equalCursors(cursor, clang_getNullCursor());
954 }
955 
956 CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) {
957   return getCursorTU(cursor);
958 }
959 
960 int clang_Cursor_getNumArguments(CXCursor C) {
961   if (clang_isDeclaration(C.kind)) {
962     const Decl *D = cxcursor::getCursorDecl(C);
963     if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
964       return MD->param_size();
965     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
966       return FD->param_size();
967   }
968 
969   if (clang_isExpression(C.kind)) {
970     const Expr *E = cxcursor::getCursorExpr(C);
971     if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
972       return CE->getNumArgs();
973     }
974   }
975 
976   return -1;
977 }
978 
979 CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) {
980   if (clang_isDeclaration(C.kind)) {
981     const Decl *D = cxcursor::getCursorDecl(C);
982     if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
983       if (i < MD->param_size())
984         return cxcursor::MakeCXCursor(MD->param_begin()[i],
985                                       cxcursor::getCursorTU(C));
986     } else if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
987       if (i < FD->param_size())
988         return cxcursor::MakeCXCursor(FD->param_begin()[i],
989                                       cxcursor::getCursorTU(C));
990     }
991   }
992 
993   if (clang_isExpression(C.kind)) {
994     const Expr *E = cxcursor::getCursorExpr(C);
995     if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
996       if (i < CE->getNumArgs()) {
997         return cxcursor::MakeCXCursor(CE->getArg(i),
998                                       getCursorDecl(C),
999                                       cxcursor::getCursorTU(C));
1000       }
1001     }
1002   }
1003 
1004   return clang_getNullCursor();
1005 }
1006 
1007 } // end: extern "C"
1008 
1009 //===----------------------------------------------------------------------===//
1010 // CXCursorSet.
1011 //===----------------------------------------------------------------------===//
1012 
1013 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
1014 
1015 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
1016   return (CXCursorSet) setImpl;
1017 }
1018 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
1019   return (CXCursorSet_Impl*) set;
1020 }
1021 namespace llvm {
1022 template<> struct DenseMapInfo<CXCursor> {
1023 public:
1024   static inline CXCursor getEmptyKey() {
1025     return MakeCXCursorInvalid(CXCursor_InvalidFile);
1026   }
1027   static inline CXCursor getTombstoneKey() {
1028     return MakeCXCursorInvalid(CXCursor_NoDeclFound);
1029   }
1030   static inline unsigned getHashValue(const CXCursor &cursor) {
1031     return llvm::DenseMapInfo<std::pair<const void *, const void *> >
1032       ::getHashValue(std::make_pair(cursor.data[0], cursor.data[1]));
1033   }
1034   static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
1035     return x.kind == y.kind &&
1036            x.data[0] == y.data[0] &&
1037            x.data[1] == y.data[1];
1038   }
1039 };
1040 }
1041 
1042 extern "C" {
1043 CXCursorSet clang_createCXCursorSet() {
1044   return packCXCursorSet(new CXCursorSet_Impl());
1045 }
1046 
1047 void clang_disposeCXCursorSet(CXCursorSet set) {
1048   delete unpackCXCursorSet(set);
1049 }
1050 
1051 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
1052   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1053   if (!setImpl)
1054     return 0;
1055   return setImpl->find(cursor) != setImpl->end();
1056 }
1057 
1058 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
1059   // Do not insert invalid cursors into the set.
1060   if (cursor.kind >= CXCursor_FirstInvalid &&
1061       cursor.kind <= CXCursor_LastInvalid)
1062     return 1;
1063 
1064   CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1065   if (!setImpl)
1066     return 1;
1067   unsigned &entry = (*setImpl)[cursor];
1068   unsigned flag = entry == 0 ? 1 : 0;
1069   entry = 1;
1070   return flag;
1071 }
1072 
1073 CXCompletionString clang_getCursorCompletionString(CXCursor cursor) {
1074   enum CXCursorKind kind = clang_getCursorKind(cursor);
1075   if (clang_isDeclaration(kind)) {
1076     const Decl *decl = getCursorDecl(cursor);
1077     if (const NamedDecl *namedDecl = dyn_cast_or_null<NamedDecl>(decl)) {
1078       ASTUnit *unit = getCursorASTUnit(cursor);
1079       CodeCompletionResult Result(namedDecl, CCP_Declaration);
1080       CodeCompletionString *String
1081         = Result.CreateCodeCompletionString(unit->getASTContext(),
1082                                             unit->getPreprocessor(),
1083                                  unit->getCodeCompletionTUInfo().getAllocator(),
1084                                  unit->getCodeCompletionTUInfo(),
1085                                  true);
1086       return String;
1087     }
1088   }
1089   else if (kind == CXCursor_MacroDefinition) {
1090     const MacroDefinition *definition = getCursorMacroDefinition(cursor);
1091     const IdentifierInfo *MacroInfo = definition->getName();
1092     ASTUnit *unit = getCursorASTUnit(cursor);
1093     CodeCompletionResult Result(MacroInfo);
1094     CodeCompletionString *String
1095       = Result.CreateCodeCompletionString(unit->getASTContext(),
1096                                           unit->getPreprocessor(),
1097                                  unit->getCodeCompletionTUInfo().getAllocator(),
1098                                  unit->getCodeCompletionTUInfo(),
1099                                  false);
1100     return String;
1101   }
1102   return NULL;
1103 }
1104 } // end: extern C.
1105 
1106 namespace {
1107   struct OverridenCursorsPool {
1108     typedef SmallVector<CXCursor, 2> CursorVec;
1109     std::vector<CursorVec*> AllCursors;
1110     std::vector<CursorVec*> AvailableCursors;
1111 
1112     ~OverridenCursorsPool() {
1113       for (std::vector<CursorVec*>::iterator I = AllCursors.begin(),
1114            E = AllCursors.end(); I != E; ++I) {
1115         delete *I;
1116       }
1117     }
1118   };
1119 }
1120 
1121 void *cxcursor::createOverridenCXCursorsPool() {
1122   return new OverridenCursorsPool();
1123 }
1124 
1125 void cxcursor::disposeOverridenCXCursorsPool(void *pool) {
1126   delete static_cast<OverridenCursorsPool*>(pool);
1127 }
1128 
1129 extern "C" {
1130 void clang_getOverriddenCursors(CXCursor cursor,
1131                                 CXCursor **overridden,
1132                                 unsigned *num_overridden) {
1133   if (overridden)
1134     *overridden = 0;
1135   if (num_overridden)
1136     *num_overridden = 0;
1137 
1138   CXTranslationUnit TU = cxcursor::getCursorTU(cursor);
1139 
1140   if (!overridden || !num_overridden || !TU)
1141     return;
1142 
1143   if (!clang_isDeclaration(cursor.kind))
1144     return;
1145 
1146   OverridenCursorsPool &pool =
1147     *static_cast<OverridenCursorsPool*>(TU->OverridenCursorsPool);
1148 
1149   OverridenCursorsPool::CursorVec *Vec = 0;
1150 
1151   if (!pool.AvailableCursors.empty()) {
1152     Vec = pool.AvailableCursors.back();
1153     pool.AvailableCursors.pop_back();
1154   }
1155   else {
1156     Vec = new OverridenCursorsPool::CursorVec();
1157     pool.AllCursors.push_back(Vec);
1158   }
1159 
1160   // Clear out the vector, but don't free the memory contents.  This
1161   // reduces malloc() traffic.
1162   Vec->clear();
1163 
1164   // Use the first entry to contain a back reference to the vector.
1165   // This is a complete hack.
1166   CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU);
1167   backRefCursor.data[0] = Vec;
1168   assert(cxcursor::getCursorTU(backRefCursor) == TU);
1169   Vec->push_back(backRefCursor);
1170 
1171   // Get the overriden cursors.
1172   cxcursor::getOverriddenCursors(cursor, *Vec);
1173 
1174   // Did we get any overriden cursors?  If not, return Vec to the pool
1175   // of available cursor vectors.
1176   if (Vec->size() == 1) {
1177     pool.AvailableCursors.push_back(Vec);
1178     return;
1179   }
1180 
1181   // Now tell the caller about the overriden cursors.
1182   assert(Vec->size() > 1);
1183   *overridden = &((*Vec)[1]);
1184   *num_overridden = Vec->size() - 1;
1185 }
1186 
1187 void clang_disposeOverriddenCursors(CXCursor *overridden) {
1188   if (!overridden)
1189     return;
1190 
1191   // Use pointer arithmetic to get back the first faux entry
1192   // which has a back-reference to the TU and the vector.
1193   --overridden;
1194   OverridenCursorsPool::CursorVec *Vec =
1195       static_cast<OverridenCursorsPool::CursorVec *>(
1196           const_cast<void *>(overridden->data[0]));
1197   CXTranslationUnit TU = getCursorTU(*overridden);
1198 
1199   assert(Vec && TU);
1200 
1201   OverridenCursorsPool &pool =
1202     *static_cast<OverridenCursorsPool*>(TU->OverridenCursorsPool);
1203 
1204   pool.AvailableCursors.push_back(Vec);
1205 }
1206 
1207 int clang_Cursor_isDynamicCall(CXCursor C) {
1208   const Expr *E = 0;
1209   if (clang_isExpression(C.kind))
1210     E = getCursorExpr(C);
1211   if (!E)
1212     return 0;
1213 
1214   if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E))
1215     return MsgE->getReceiverKind() == ObjCMessageExpr::Instance;
1216 
1217   const MemberExpr *ME = 0;
1218   if (isa<MemberExpr>(E))
1219     ME = cast<MemberExpr>(E);
1220   else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
1221     ME = dyn_cast_or_null<MemberExpr>(CE->getCallee());
1222 
1223   if (ME) {
1224     if (const CXXMethodDecl *
1225           MD = dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl()))
1226       return MD->isVirtual() && !ME->hasQualifier();
1227   }
1228 
1229   return 0;
1230 }
1231 
1232 CXType clang_Cursor_getReceiverType(CXCursor C) {
1233   CXTranslationUnit TU = cxcursor::getCursorTU(C);
1234   const Expr *E = 0;
1235   if (clang_isExpression(C.kind))
1236     E = getCursorExpr(C);
1237 
1238   if (const ObjCMessageExpr *MsgE = dyn_cast_or_null<ObjCMessageExpr>(E))
1239     return cxtype::MakeCXType(MsgE->getReceiverType(), TU);
1240 
1241   return cxtype::MakeCXType(QualType(), TU);
1242 }
1243 
1244 } // end: extern "C"
1245