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