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