1 //===- CXCursor.cpp - Routines for manipulating CXCursors -----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines routines for manipulating CXCursors. It should be the
10 // only file that has internal knowledge of the encoding of the data in
11 // CXCursor.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "CXCursor.h"
16 #include "CXString.h"
17 #include "CXTranslationUnit.h"
18 #include "CXType.h"
19 #include "clang-c/Index.h"
20 #include "clang/AST/Attr.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclCXX.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/DeclTemplate.h"
25 #include "clang/AST/Expr.h"
26 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/ExprObjC.h"
28 #include "clang/Frontend/ASTUnit.h"
29 #include "llvm/Support/ErrorHandling.h"
30
31 using namespace clang;
32 using namespace cxcursor;
33
MakeCXCursorInvalid(CXCursorKind K,CXTranslationUnit TU)34 CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K, CXTranslationUnit TU) {
35 assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid);
36 CXCursor C = {K, 0, {nullptr, nullptr, TU}};
37 return C;
38 }
39
GetCursorKind(const Attr * A)40 static CXCursorKind GetCursorKind(const Attr *A) {
41 assert(A && "Invalid arguments!");
42 switch (A->getKind()) {
43 default:
44 break;
45 case attr::IBAction:
46 return CXCursor_IBActionAttr;
47 case attr::IBOutlet:
48 return CXCursor_IBOutletAttr;
49 case attr::IBOutletCollection:
50 return CXCursor_IBOutletCollectionAttr;
51 case attr::Final:
52 return CXCursor_CXXFinalAttr;
53 case attr::Override:
54 return CXCursor_CXXOverrideAttr;
55 case attr::Annotate:
56 return CXCursor_AnnotateAttr;
57 case attr::AsmLabel:
58 return CXCursor_AsmLabelAttr;
59 case attr::Packed:
60 return CXCursor_PackedAttr;
61 case attr::Pure:
62 return CXCursor_PureAttr;
63 case attr::Const:
64 return CXCursor_ConstAttr;
65 case attr::NoDuplicate:
66 return CXCursor_NoDuplicateAttr;
67 case attr::CUDAConstant:
68 return CXCursor_CUDAConstantAttr;
69 case attr::CUDADevice:
70 return CXCursor_CUDADeviceAttr;
71 case attr::CUDAGlobal:
72 return CXCursor_CUDAGlobalAttr;
73 case attr::CUDAHost:
74 return CXCursor_CUDAHostAttr;
75 case attr::CUDAShared:
76 return CXCursor_CUDASharedAttr;
77 case attr::Visibility:
78 return CXCursor_VisibilityAttr;
79 case attr::DLLExport:
80 return CXCursor_DLLExport;
81 case attr::DLLImport:
82 return CXCursor_DLLImport;
83 case attr::NSReturnsRetained:
84 return CXCursor_NSReturnsRetained;
85 case attr::NSReturnsNotRetained:
86 return CXCursor_NSReturnsNotRetained;
87 case attr::NSReturnsAutoreleased:
88 return CXCursor_NSReturnsAutoreleased;
89 case attr::NSConsumesSelf:
90 return CXCursor_NSConsumesSelf;
91 case attr::NSConsumed:
92 return CXCursor_NSConsumed;
93 case attr::ObjCException:
94 return CXCursor_ObjCException;
95 case attr::ObjCNSObject:
96 return CXCursor_ObjCNSObject;
97 case attr::ObjCIndependentClass:
98 return CXCursor_ObjCIndependentClass;
99 case attr::ObjCPreciseLifetime:
100 return CXCursor_ObjCPreciseLifetime;
101 case attr::ObjCReturnsInnerPointer:
102 return CXCursor_ObjCReturnsInnerPointer;
103 case attr::ObjCRequiresSuper:
104 return CXCursor_ObjCRequiresSuper;
105 case attr::ObjCRootClass:
106 return CXCursor_ObjCRootClass;
107 case attr::ObjCSubclassingRestricted:
108 return CXCursor_ObjCSubclassingRestricted;
109 case attr::ObjCExplicitProtocolImpl:
110 return CXCursor_ObjCExplicitProtocolImpl;
111 case attr::ObjCDesignatedInitializer:
112 return CXCursor_ObjCDesignatedInitializer;
113 case attr::ObjCRuntimeVisible:
114 return CXCursor_ObjCRuntimeVisible;
115 case attr::ObjCBoxable:
116 return CXCursor_ObjCBoxable;
117 case attr::FlagEnum:
118 return CXCursor_FlagEnum;
119 case attr::Convergent:
120 return CXCursor_ConvergentAttr;
121 case attr::WarnUnused:
122 return CXCursor_WarnUnusedAttr;
123 case attr::WarnUnusedResult:
124 return CXCursor_WarnUnusedResultAttr;
125 case attr::Aligned:
126 return CXCursor_AlignedAttr;
127 }
128
129 return CXCursor_UnexposedAttr;
130 }
131
MakeCXCursor(const Attr * A,const Decl * Parent,CXTranslationUnit TU)132 CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent,
133 CXTranslationUnit TU) {
134 assert(A && Parent && TU && "Invalid arguments!");
135 CXCursor C = {GetCursorKind(A), 0, {Parent, A, TU}};
136 return C;
137 }
138
MakeCXCursor(const Decl * D,CXTranslationUnit TU,SourceRange RegionOfInterest,bool FirstInDeclGroup)139 CXCursor cxcursor::MakeCXCursor(const Decl *D, CXTranslationUnit TU,
140 SourceRange RegionOfInterest,
141 bool FirstInDeclGroup) {
142 assert(D && TU && "Invalid arguments!");
143
144 CXCursorKind K = getCursorKindForDecl(D);
145
146 if (K == CXCursor_ObjCClassMethodDecl ||
147 K == CXCursor_ObjCInstanceMethodDecl) {
148 int SelectorIdIndex = -1;
149 // Check if cursor points to a selector id.
150 if (RegionOfInterest.isValid() &&
151 RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) {
152 SmallVector<SourceLocation, 16> SelLocs;
153 cast<ObjCMethodDecl>(D)->getSelectorLocs(SelLocs);
154 SmallVectorImpl<SourceLocation>::iterator I =
155 llvm::find(SelLocs, RegionOfInterest.getBegin());
156 if (I != SelLocs.end())
157 SelectorIdIndex = I - SelLocs.begin();
158 }
159 CXCursor C = {K,
160 SelectorIdIndex,
161 {D, (void *)(intptr_t)(FirstInDeclGroup ? 1 : 0), TU}};
162 return C;
163 }
164
165 CXCursor C = {K, 0, {D, (void *)(intptr_t)(FirstInDeclGroup ? 1 : 0), TU}};
166 return C;
167 }
168
MakeCXCursor(const Stmt * S,const Decl * Parent,CXTranslationUnit TU,SourceRange RegionOfInterest)169 CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
170 CXTranslationUnit TU,
171 SourceRange RegionOfInterest) {
172 assert(S && TU && "Invalid arguments!");
173 CXCursorKind K = CXCursor_NotImplemented;
174
175 switch (S->getStmtClass()) {
176 case Stmt::NoStmtClass:
177 break;
178
179 case Stmt::CaseStmtClass:
180 K = CXCursor_CaseStmt;
181 break;
182
183 case Stmt::DefaultStmtClass:
184 K = CXCursor_DefaultStmt;
185 break;
186
187 case Stmt::IfStmtClass:
188 K = CXCursor_IfStmt;
189 break;
190
191 case Stmt::SwitchStmtClass:
192 K = CXCursor_SwitchStmt;
193 break;
194
195 case Stmt::WhileStmtClass:
196 K = CXCursor_WhileStmt;
197 break;
198
199 case Stmt::DoStmtClass:
200 K = CXCursor_DoStmt;
201 break;
202
203 case Stmt::ForStmtClass:
204 K = CXCursor_ForStmt;
205 break;
206
207 case Stmt::GotoStmtClass:
208 K = CXCursor_GotoStmt;
209 break;
210
211 case Stmt::IndirectGotoStmtClass:
212 K = CXCursor_IndirectGotoStmt;
213 break;
214
215 case Stmt::ContinueStmtClass:
216 K = CXCursor_ContinueStmt;
217 break;
218
219 case Stmt::BreakStmtClass:
220 K = CXCursor_BreakStmt;
221 break;
222
223 case Stmt::ReturnStmtClass:
224 K = CXCursor_ReturnStmt;
225 break;
226
227 case Stmt::GCCAsmStmtClass:
228 K = CXCursor_GCCAsmStmt;
229 break;
230
231 case Stmt::MSAsmStmtClass:
232 K = CXCursor_MSAsmStmt;
233 break;
234
235 case Stmt::ObjCAtTryStmtClass:
236 K = CXCursor_ObjCAtTryStmt;
237 break;
238
239 case Stmt::ObjCAtCatchStmtClass:
240 K = CXCursor_ObjCAtCatchStmt;
241 break;
242
243 case Stmt::ObjCAtFinallyStmtClass:
244 K = CXCursor_ObjCAtFinallyStmt;
245 break;
246
247 case Stmt::ObjCAtThrowStmtClass:
248 K = CXCursor_ObjCAtThrowStmt;
249 break;
250
251 case Stmt::ObjCAtSynchronizedStmtClass:
252 K = CXCursor_ObjCAtSynchronizedStmt;
253 break;
254
255 case Stmt::ObjCAutoreleasePoolStmtClass:
256 K = CXCursor_ObjCAutoreleasePoolStmt;
257 break;
258
259 case Stmt::ObjCForCollectionStmtClass:
260 K = CXCursor_ObjCForCollectionStmt;
261 break;
262
263 case Stmt::CXXCatchStmtClass:
264 K = CXCursor_CXXCatchStmt;
265 break;
266
267 case Stmt::CXXTryStmtClass:
268 K = CXCursor_CXXTryStmt;
269 break;
270
271 case Stmt::CXXForRangeStmtClass:
272 K = CXCursor_CXXForRangeStmt;
273 break;
274
275 case Stmt::SEHTryStmtClass:
276 K = CXCursor_SEHTryStmt;
277 break;
278
279 case Stmt::SEHExceptStmtClass:
280 K = CXCursor_SEHExceptStmt;
281 break;
282
283 case Stmt::SEHFinallyStmtClass:
284 K = CXCursor_SEHFinallyStmt;
285 break;
286
287 case Stmt::SEHLeaveStmtClass:
288 K = CXCursor_SEHLeaveStmt;
289 break;
290
291 case Stmt::CoroutineBodyStmtClass:
292 case Stmt::CoreturnStmtClass:
293 K = CXCursor_UnexposedStmt;
294 break;
295
296 case Stmt::ArrayTypeTraitExprClass:
297 case Stmt::AsTypeExprClass:
298 case Stmt::AtomicExprClass:
299 case Stmt::BinaryConditionalOperatorClass:
300 case Stmt::TypeTraitExprClass:
301 case Stmt::CoawaitExprClass:
302 case Stmt::ConceptSpecializationExprClass:
303 case Stmt::RequiresExprClass:
304 case Stmt::DependentCoawaitExprClass:
305 case Stmt::CoyieldExprClass:
306 case Stmt::CXXBindTemporaryExprClass:
307 case Stmt::CXXDefaultArgExprClass:
308 case Stmt::CXXDefaultInitExprClass:
309 case Stmt::CXXFoldExprClass:
310 case Stmt::CXXRewrittenBinaryOperatorClass:
311 case Stmt::CXXStdInitializerListExprClass:
312 case Stmt::CXXScalarValueInitExprClass:
313 case Stmt::CXXUuidofExprClass:
314 case Stmt::ChooseExprClass:
315 case Stmt::DesignatedInitExprClass:
316 case Stmt::DesignatedInitUpdateExprClass:
317 case Stmt::ArrayInitLoopExprClass:
318 case Stmt::ArrayInitIndexExprClass:
319 case Stmt::ExprWithCleanupsClass:
320 case Stmt::ExpressionTraitExprClass:
321 case Stmt::ExtVectorElementExprClass:
322 case Stmt::ImplicitCastExprClass:
323 case Stmt::ImplicitValueInitExprClass:
324 case Stmt::NoInitExprClass:
325 case Stmt::MaterializeTemporaryExprClass:
326 case Stmt::ObjCIndirectCopyRestoreExprClass:
327 case Stmt::OffsetOfExprClass:
328 case Stmt::ParenListExprClass:
329 case Stmt::PredefinedExprClass:
330 case Stmt::ShuffleVectorExprClass:
331 case Stmt::SourceLocExprClass:
332 case Stmt::ConvertVectorExprClass:
333 case Stmt::VAArgExprClass:
334 case Stmt::ObjCArrayLiteralClass:
335 case Stmt::ObjCDictionaryLiteralClass:
336 case Stmt::ObjCBoxedExprClass:
337 case Stmt::ObjCSubscriptRefExprClass:
338 case Stmt::RecoveryExprClass:
339 K = CXCursor_UnexposedExpr;
340 break;
341
342 case Stmt::OpaqueValueExprClass:
343 if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr())
344 return MakeCXCursor(Src, Parent, TU, RegionOfInterest);
345 K = CXCursor_UnexposedExpr;
346 break;
347
348 case Stmt::PseudoObjectExprClass:
349 return MakeCXCursor(cast<PseudoObjectExpr>(S)->getSyntacticForm(), Parent,
350 TU, RegionOfInterest);
351
352 case Stmt::CompoundStmtClass:
353 K = CXCursor_CompoundStmt;
354 break;
355
356 case Stmt::NullStmtClass:
357 K = CXCursor_NullStmt;
358 break;
359
360 case Stmt::LabelStmtClass:
361 K = CXCursor_LabelStmt;
362 break;
363
364 case Stmt::AttributedStmtClass:
365 K = CXCursor_UnexposedStmt;
366 break;
367
368 case Stmt::DeclStmtClass:
369 K = CXCursor_DeclStmt;
370 break;
371
372 case Stmt::CapturedStmtClass:
373 K = CXCursor_UnexposedStmt;
374 break;
375
376 case Stmt::IntegerLiteralClass:
377 K = CXCursor_IntegerLiteral;
378 break;
379
380 case Stmt::FixedPointLiteralClass:
381 K = CXCursor_FixedPointLiteral;
382 break;
383
384 case Stmt::FloatingLiteralClass:
385 K = CXCursor_FloatingLiteral;
386 break;
387
388 case Stmt::ImaginaryLiteralClass:
389 K = CXCursor_ImaginaryLiteral;
390 break;
391
392 case Stmt::StringLiteralClass:
393 K = CXCursor_StringLiteral;
394 break;
395
396 case Stmt::CharacterLiteralClass:
397 K = CXCursor_CharacterLiteral;
398 break;
399
400 case Stmt::ConstantExprClass:
401 return MakeCXCursor(cast<ConstantExpr>(S)->getSubExpr(), Parent, TU,
402 RegionOfInterest);
403
404 case Stmt::ParenExprClass:
405 K = CXCursor_ParenExpr;
406 break;
407
408 case Stmt::UnaryOperatorClass:
409 K = CXCursor_UnaryOperator;
410 break;
411
412 case Stmt::UnaryExprOrTypeTraitExprClass:
413 case Stmt::CXXNoexceptExprClass:
414 K = CXCursor_UnaryExpr;
415 break;
416
417 case Stmt::MSPropertySubscriptExprClass:
418 case Stmt::ArraySubscriptExprClass:
419 K = CXCursor_ArraySubscriptExpr;
420 break;
421
422 case Stmt::MatrixSubscriptExprClass:
423 // TODO: add support for MatrixSubscriptExpr.
424 K = CXCursor_UnexposedExpr;
425 break;
426
427 case Stmt::OMPArraySectionExprClass:
428 K = CXCursor_OMPArraySectionExpr;
429 break;
430
431 case Stmt::OMPArrayShapingExprClass:
432 K = CXCursor_OMPArrayShapingExpr;
433 break;
434
435 case Stmt::OMPIteratorExprClass:
436 K = CXCursor_OMPIteratorExpr;
437 break;
438
439 case Stmt::BinaryOperatorClass:
440 K = CXCursor_BinaryOperator;
441 break;
442
443 case Stmt::CompoundAssignOperatorClass:
444 K = CXCursor_CompoundAssignOperator;
445 break;
446
447 case Stmt::ConditionalOperatorClass:
448 K = CXCursor_ConditionalOperator;
449 break;
450
451 case Stmt::CStyleCastExprClass:
452 K = CXCursor_CStyleCastExpr;
453 break;
454
455 case Stmt::CompoundLiteralExprClass:
456 K = CXCursor_CompoundLiteralExpr;
457 break;
458
459 case Stmt::InitListExprClass:
460 K = CXCursor_InitListExpr;
461 break;
462
463 case Stmt::AddrLabelExprClass:
464 K = CXCursor_AddrLabelExpr;
465 break;
466
467 case Stmt::StmtExprClass:
468 K = CXCursor_StmtExpr;
469 break;
470
471 case Stmt::GenericSelectionExprClass:
472 K = CXCursor_GenericSelectionExpr;
473 break;
474
475 case Stmt::GNUNullExprClass:
476 K = CXCursor_GNUNullExpr;
477 break;
478
479 case Stmt::CXXStaticCastExprClass:
480 K = CXCursor_CXXStaticCastExpr;
481 break;
482
483 case Stmt::CXXDynamicCastExprClass:
484 K = CXCursor_CXXDynamicCastExpr;
485 break;
486
487 case Stmt::CXXReinterpretCastExprClass:
488 K = CXCursor_CXXReinterpretCastExpr;
489 break;
490
491 case Stmt::CXXConstCastExprClass:
492 K = CXCursor_CXXConstCastExpr;
493 break;
494
495 case Stmt::CXXFunctionalCastExprClass:
496 K = CXCursor_CXXFunctionalCastExpr;
497 break;
498
499 case Stmt::CXXAddrspaceCastExprClass:
500 K = CXCursor_CXXAddrspaceCastExpr;
501 break;
502
503 case Stmt::CXXTypeidExprClass:
504 K = CXCursor_CXXTypeidExpr;
505 break;
506
507 case Stmt::CXXBoolLiteralExprClass:
508 K = CXCursor_CXXBoolLiteralExpr;
509 break;
510
511 case Stmt::CXXNullPtrLiteralExprClass:
512 K = CXCursor_CXXNullPtrLiteralExpr;
513 break;
514
515 case Stmt::CXXThisExprClass:
516 K = CXCursor_CXXThisExpr;
517 break;
518
519 case Stmt::CXXThrowExprClass:
520 K = CXCursor_CXXThrowExpr;
521 break;
522
523 case Stmt::CXXNewExprClass:
524 K = CXCursor_CXXNewExpr;
525 break;
526
527 case Stmt::CXXDeleteExprClass:
528 K = CXCursor_CXXDeleteExpr;
529 break;
530
531 case Stmt::ObjCStringLiteralClass:
532 K = CXCursor_ObjCStringLiteral;
533 break;
534
535 case Stmt::ObjCEncodeExprClass:
536 K = CXCursor_ObjCEncodeExpr;
537 break;
538
539 case Stmt::ObjCSelectorExprClass:
540 K = CXCursor_ObjCSelectorExpr;
541 break;
542
543 case Stmt::ObjCProtocolExprClass:
544 K = CXCursor_ObjCProtocolExpr;
545 break;
546
547 case Stmt::ObjCBoolLiteralExprClass:
548 K = CXCursor_ObjCBoolLiteralExpr;
549 break;
550
551 case Stmt::ObjCAvailabilityCheckExprClass:
552 K = CXCursor_ObjCAvailabilityCheckExpr;
553 break;
554
555 case Stmt::ObjCBridgedCastExprClass:
556 K = CXCursor_ObjCBridgedCastExpr;
557 break;
558
559 case Stmt::BlockExprClass:
560 K = CXCursor_BlockExpr;
561 break;
562
563 case Stmt::PackExpansionExprClass:
564 K = CXCursor_PackExpansionExpr;
565 break;
566
567 case Stmt::SizeOfPackExprClass:
568 K = CXCursor_SizeOfPackExpr;
569 break;
570
571 case Stmt::DeclRefExprClass:
572 if (const ImplicitParamDecl *IPD = dyn_cast_or_null<ImplicitParamDecl>(
573 cast<DeclRefExpr>(S)->getDecl())) {
574 if (const ObjCMethodDecl *MD =
575 dyn_cast<ObjCMethodDecl>(IPD->getDeclContext())) {
576 if (MD->getSelfDecl() == IPD) {
577 K = CXCursor_ObjCSelfExpr;
578 break;
579 }
580 }
581 }
582
583 K = CXCursor_DeclRefExpr;
584 break;
585
586 case Stmt::DependentScopeDeclRefExprClass:
587 case Stmt::SubstNonTypeTemplateParmExprClass:
588 case Stmt::SubstNonTypeTemplateParmPackExprClass:
589 case Stmt::FunctionParmPackExprClass:
590 case Stmt::UnresolvedLookupExprClass:
591 case Stmt::TypoExprClass: // A typo could actually be a DeclRef or a MemberRef
592 K = CXCursor_DeclRefExpr;
593 break;
594
595 case Stmt::CXXDependentScopeMemberExprClass:
596 case Stmt::CXXPseudoDestructorExprClass:
597 case Stmt::MemberExprClass:
598 case Stmt::MSPropertyRefExprClass:
599 case Stmt::ObjCIsaExprClass:
600 case Stmt::ObjCIvarRefExprClass:
601 case Stmt::ObjCPropertyRefExprClass:
602 case Stmt::UnresolvedMemberExprClass:
603 K = CXCursor_MemberRefExpr;
604 break;
605
606 case Stmt::CallExprClass:
607 case Stmt::CXXOperatorCallExprClass:
608 case Stmt::CXXMemberCallExprClass:
609 case Stmt::CUDAKernelCallExprClass:
610 case Stmt::CXXConstructExprClass:
611 case Stmt::CXXInheritedCtorInitExprClass:
612 case Stmt::CXXTemporaryObjectExprClass:
613 case Stmt::CXXUnresolvedConstructExprClass:
614 case Stmt::UserDefinedLiteralClass:
615 K = CXCursor_CallExpr;
616 break;
617
618 case Stmt::LambdaExprClass:
619 K = CXCursor_LambdaExpr;
620 break;
621
622 case Stmt::ObjCMessageExprClass: {
623 K = CXCursor_ObjCMessageExpr;
624 int SelectorIdIndex = -1;
625 // Check if cursor points to a selector id.
626 if (RegionOfInterest.isValid() &&
627 RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) {
628 SmallVector<SourceLocation, 16> SelLocs;
629 cast<ObjCMessageExpr>(S)->getSelectorLocs(SelLocs);
630 SmallVectorImpl<SourceLocation>::iterator I =
631 llvm::find(SelLocs, RegionOfInterest.getBegin());
632 if (I != SelLocs.end())
633 SelectorIdIndex = I - SelLocs.begin();
634 }
635 CXCursor C = {K, 0, {Parent, S, TU}};
636 return getSelectorIdentifierCursor(SelectorIdIndex, C);
637 }
638
639 case Stmt::MSDependentExistsStmtClass:
640 K = CXCursor_UnexposedStmt;
641 break;
642 case Stmt::OMPCanonicalLoopClass:
643 K = CXCursor_OMPCanonicalLoop;
644 break;
645 case Stmt::OMPParallelDirectiveClass:
646 K = CXCursor_OMPParallelDirective;
647 break;
648 case Stmt::OMPSimdDirectiveClass:
649 K = CXCursor_OMPSimdDirective;
650 break;
651 case Stmt::OMPTileDirectiveClass:
652 K = CXCursor_OMPTileDirective;
653 break;
654 case Stmt::OMPForDirectiveClass:
655 K = CXCursor_OMPForDirective;
656 break;
657 case Stmt::OMPForSimdDirectiveClass:
658 K = CXCursor_OMPForSimdDirective;
659 break;
660 case Stmt::OMPSectionsDirectiveClass:
661 K = CXCursor_OMPSectionsDirective;
662 break;
663 case Stmt::OMPSectionDirectiveClass:
664 K = CXCursor_OMPSectionDirective;
665 break;
666 case Stmt::OMPSingleDirectiveClass:
667 K = CXCursor_OMPSingleDirective;
668 break;
669 case Stmt::OMPMasterDirectiveClass:
670 K = CXCursor_OMPMasterDirective;
671 break;
672 case Stmt::OMPCriticalDirectiveClass:
673 K = CXCursor_OMPCriticalDirective;
674 break;
675 case Stmt::OMPParallelForDirectiveClass:
676 K = CXCursor_OMPParallelForDirective;
677 break;
678 case Stmt::OMPParallelForSimdDirectiveClass:
679 K = CXCursor_OMPParallelForSimdDirective;
680 break;
681 case Stmt::OMPParallelMasterDirectiveClass:
682 K = CXCursor_OMPParallelMasterDirective;
683 break;
684 case Stmt::OMPParallelSectionsDirectiveClass:
685 K = CXCursor_OMPParallelSectionsDirective;
686 break;
687 case Stmt::OMPTaskDirectiveClass:
688 K = CXCursor_OMPTaskDirective;
689 break;
690 case Stmt::OMPTaskyieldDirectiveClass:
691 K = CXCursor_OMPTaskyieldDirective;
692 break;
693 case Stmt::OMPBarrierDirectiveClass:
694 K = CXCursor_OMPBarrierDirective;
695 break;
696 case Stmt::OMPTaskwaitDirectiveClass:
697 K = CXCursor_OMPTaskwaitDirective;
698 break;
699 case Stmt::OMPTaskgroupDirectiveClass:
700 K = CXCursor_OMPTaskgroupDirective;
701 break;
702 case Stmt::OMPFlushDirectiveClass:
703 K = CXCursor_OMPFlushDirective;
704 break;
705 case Stmt::OMPDepobjDirectiveClass:
706 K = CXCursor_OMPDepobjDirective;
707 break;
708 case Stmt::OMPScanDirectiveClass:
709 K = CXCursor_OMPScanDirective;
710 break;
711 case Stmt::OMPOrderedDirectiveClass:
712 K = CXCursor_OMPOrderedDirective;
713 break;
714 case Stmt::OMPAtomicDirectiveClass:
715 K = CXCursor_OMPAtomicDirective;
716 break;
717 case Stmt::OMPTargetDirectiveClass:
718 K = CXCursor_OMPTargetDirective;
719 break;
720 case Stmt::OMPTargetDataDirectiveClass:
721 K = CXCursor_OMPTargetDataDirective;
722 break;
723 case Stmt::OMPTargetEnterDataDirectiveClass:
724 K = CXCursor_OMPTargetEnterDataDirective;
725 break;
726 case Stmt::OMPTargetExitDataDirectiveClass:
727 K = CXCursor_OMPTargetExitDataDirective;
728 break;
729 case Stmt::OMPTargetParallelDirectiveClass:
730 K = CXCursor_OMPTargetParallelDirective;
731 break;
732 case Stmt::OMPTargetParallelForDirectiveClass:
733 K = CXCursor_OMPTargetParallelForDirective;
734 break;
735 case Stmt::OMPTargetUpdateDirectiveClass:
736 K = CXCursor_OMPTargetUpdateDirective;
737 break;
738 case Stmt::OMPTeamsDirectiveClass:
739 K = CXCursor_OMPTeamsDirective;
740 break;
741 case Stmt::OMPCancellationPointDirectiveClass:
742 K = CXCursor_OMPCancellationPointDirective;
743 break;
744 case Stmt::OMPCancelDirectiveClass:
745 K = CXCursor_OMPCancelDirective;
746 break;
747 case Stmt::OMPTaskLoopDirectiveClass:
748 K = CXCursor_OMPTaskLoopDirective;
749 break;
750 case Stmt::OMPTaskLoopSimdDirectiveClass:
751 K = CXCursor_OMPTaskLoopSimdDirective;
752 break;
753 case Stmt::OMPMasterTaskLoopDirectiveClass:
754 K = CXCursor_OMPMasterTaskLoopDirective;
755 break;
756 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
757 K = CXCursor_OMPMasterTaskLoopSimdDirective;
758 break;
759 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
760 K = CXCursor_OMPParallelMasterTaskLoopDirective;
761 break;
762 case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
763 K = CXCursor_OMPParallelMasterTaskLoopSimdDirective;
764 break;
765 case Stmt::OMPDistributeDirectiveClass:
766 K = CXCursor_OMPDistributeDirective;
767 break;
768 case Stmt::OMPDistributeParallelForDirectiveClass:
769 K = CXCursor_OMPDistributeParallelForDirective;
770 break;
771 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
772 K = CXCursor_OMPDistributeParallelForSimdDirective;
773 break;
774 case Stmt::OMPDistributeSimdDirectiveClass:
775 K = CXCursor_OMPDistributeSimdDirective;
776 break;
777 case Stmt::OMPTargetParallelForSimdDirectiveClass:
778 K = CXCursor_OMPTargetParallelForSimdDirective;
779 break;
780 case Stmt::OMPTargetSimdDirectiveClass:
781 K = CXCursor_OMPTargetSimdDirective;
782 break;
783 case Stmt::OMPTeamsDistributeDirectiveClass:
784 K = CXCursor_OMPTeamsDistributeDirective;
785 break;
786 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
787 K = CXCursor_OMPTeamsDistributeSimdDirective;
788 break;
789 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
790 K = CXCursor_OMPTeamsDistributeParallelForSimdDirective;
791 break;
792 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
793 K = CXCursor_OMPTeamsDistributeParallelForDirective;
794 break;
795 case Stmt::OMPTargetTeamsDirectiveClass:
796 K = CXCursor_OMPTargetTeamsDirective;
797 break;
798 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
799 K = CXCursor_OMPTargetTeamsDistributeDirective;
800 break;
801 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
802 K = CXCursor_OMPTargetTeamsDistributeParallelForDirective;
803 break;
804 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
805 K = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective;
806 break;
807 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
808 K = CXCursor_OMPTargetTeamsDistributeSimdDirective;
809 break;
810 case Stmt::OMPInteropDirectiveClass:
811 K = CXCursor_OMPInteropDirective;
812 break;
813 case Stmt::OMPDispatchDirectiveClass:
814 K = CXCursor_OMPDispatchDirective;
815 break;
816 case Stmt::OMPMaskedDirectiveClass:
817 K = CXCursor_OMPMaskedDirective;
818 break;
819 case Stmt::BuiltinBitCastExprClass:
820 K = CXCursor_BuiltinBitCastExpr;
821 }
822
823 CXCursor C = {K, 0, {Parent, S, TU}};
824 return C;
825 }
826
MakeCursorObjCSuperClassRef(ObjCInterfaceDecl * Super,SourceLocation Loc,CXTranslationUnit TU)827 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
828 SourceLocation Loc,
829 CXTranslationUnit TU) {
830 assert(Super && TU && "Invalid arguments!");
831 void *RawLoc = Loc.getPtrEncoding();
832 CXCursor C = {CXCursor_ObjCSuperClassRef, 0, {Super, RawLoc, TU}};
833 return C;
834 }
835
836 std::pair<const ObjCInterfaceDecl *, SourceLocation>
getCursorObjCSuperClassRef(CXCursor C)837 cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
838 assert(C.kind == CXCursor_ObjCSuperClassRef);
839 return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]),
840 SourceLocation::getFromPtrEncoding(C.data[1]));
841 }
842
MakeCursorObjCProtocolRef(const ObjCProtocolDecl * Proto,SourceLocation Loc,CXTranslationUnit TU)843 CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto,
844 SourceLocation Loc,
845 CXTranslationUnit TU) {
846 assert(Proto && TU && "Invalid arguments!");
847 void *RawLoc = Loc.getPtrEncoding();
848 CXCursor C = {CXCursor_ObjCProtocolRef, 0, {Proto, RawLoc, TU}};
849 return C;
850 }
851
852 std::pair<const ObjCProtocolDecl *, SourceLocation>
getCursorObjCProtocolRef(CXCursor C)853 cxcursor::getCursorObjCProtocolRef(CXCursor C) {
854 assert(C.kind == CXCursor_ObjCProtocolRef);
855 return std::make_pair(static_cast<const ObjCProtocolDecl *>(C.data[0]),
856 SourceLocation::getFromPtrEncoding(C.data[1]));
857 }
858
MakeCursorObjCClassRef(const ObjCInterfaceDecl * Class,SourceLocation Loc,CXTranslationUnit TU)859 CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class,
860 SourceLocation Loc,
861 CXTranslationUnit TU) {
862 // 'Class' can be null for invalid code.
863 if (!Class)
864 return MakeCXCursorInvalid(CXCursor_InvalidCode);
865 assert(TU && "Invalid arguments!");
866 void *RawLoc = Loc.getPtrEncoding();
867 CXCursor C = {CXCursor_ObjCClassRef, 0, {Class, RawLoc, TU}};
868 return C;
869 }
870
871 std::pair<const ObjCInterfaceDecl *, SourceLocation>
getCursorObjCClassRef(CXCursor C)872 cxcursor::getCursorObjCClassRef(CXCursor C) {
873 assert(C.kind == CXCursor_ObjCClassRef);
874 return std::make_pair(static_cast<const ObjCInterfaceDecl *>(C.data[0]),
875 SourceLocation::getFromPtrEncoding(C.data[1]));
876 }
877
MakeCursorTypeRef(const TypeDecl * Type,SourceLocation Loc,CXTranslationUnit TU)878 CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc,
879 CXTranslationUnit TU) {
880 assert(Type && TU && "Invalid arguments!");
881 void *RawLoc = Loc.getPtrEncoding();
882 CXCursor C = {CXCursor_TypeRef, 0, {Type, RawLoc, TU}};
883 return C;
884 }
885
886 std::pair<const TypeDecl *, SourceLocation>
getCursorTypeRef(CXCursor C)887 cxcursor::getCursorTypeRef(CXCursor C) {
888 assert(C.kind == CXCursor_TypeRef);
889 return std::make_pair(static_cast<const TypeDecl *>(C.data[0]),
890 SourceLocation::getFromPtrEncoding(C.data[1]));
891 }
892
MakeCursorTemplateRef(const TemplateDecl * Template,SourceLocation Loc,CXTranslationUnit TU)893 CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template,
894 SourceLocation Loc,
895 CXTranslationUnit TU) {
896 assert(Template && TU && "Invalid arguments!");
897 void *RawLoc = Loc.getPtrEncoding();
898 CXCursor C = {CXCursor_TemplateRef, 0, {Template, RawLoc, TU}};
899 return C;
900 }
901
902 std::pair<const TemplateDecl *, SourceLocation>
getCursorTemplateRef(CXCursor C)903 cxcursor::getCursorTemplateRef(CXCursor C) {
904 assert(C.kind == CXCursor_TemplateRef);
905 return std::make_pair(static_cast<const TemplateDecl *>(C.data[0]),
906 SourceLocation::getFromPtrEncoding(C.data[1]));
907 }
908
MakeCursorNamespaceRef(const NamedDecl * NS,SourceLocation Loc,CXTranslationUnit TU)909 CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS,
910 SourceLocation Loc,
911 CXTranslationUnit TU) {
912
913 assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
914 "Invalid arguments!");
915 void *RawLoc = Loc.getPtrEncoding();
916 CXCursor C = {CXCursor_NamespaceRef, 0, {NS, RawLoc, TU}};
917 return C;
918 }
919
920 std::pair<const NamedDecl *, SourceLocation>
getCursorNamespaceRef(CXCursor C)921 cxcursor::getCursorNamespaceRef(CXCursor C) {
922 assert(C.kind == CXCursor_NamespaceRef);
923 return std::make_pair(static_cast<const NamedDecl *>(C.data[0]),
924 SourceLocation::getFromPtrEncoding(C.data[1]));
925 }
926
MakeCursorVariableRef(const VarDecl * Var,SourceLocation Loc,CXTranslationUnit TU)927 CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc,
928 CXTranslationUnit TU) {
929
930 assert(Var && TU && "Invalid arguments!");
931 void *RawLoc = Loc.getPtrEncoding();
932 CXCursor C = {CXCursor_VariableRef, 0, {Var, RawLoc, TU}};
933 return C;
934 }
935
936 std::pair<const VarDecl *, SourceLocation>
getCursorVariableRef(CXCursor C)937 cxcursor::getCursorVariableRef(CXCursor C) {
938 assert(C.kind == CXCursor_VariableRef);
939 return std::make_pair(static_cast<const VarDecl *>(C.data[0]),
940 SourceLocation::getFromPtrEncoding(C.data[1]));
941 }
942
MakeCursorMemberRef(const FieldDecl * Field,SourceLocation Loc,CXTranslationUnit TU)943 CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field,
944 SourceLocation Loc,
945 CXTranslationUnit TU) {
946
947 assert(Field && TU && "Invalid arguments!");
948 void *RawLoc = Loc.getPtrEncoding();
949 CXCursor C = {CXCursor_MemberRef, 0, {Field, RawLoc, TU}};
950 return C;
951 }
952
953 std::pair<const FieldDecl *, SourceLocation>
getCursorMemberRef(CXCursor C)954 cxcursor::getCursorMemberRef(CXCursor C) {
955 assert(C.kind == CXCursor_MemberRef);
956 return std::make_pair(static_cast<const FieldDecl *>(C.data[0]),
957 SourceLocation::getFromPtrEncoding(C.data[1]));
958 }
959
MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier * B,CXTranslationUnit TU)960 CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B,
961 CXTranslationUnit TU) {
962 CXCursor C = {CXCursor_CXXBaseSpecifier, 0, {B, nullptr, TU}};
963 return C;
964 }
965
getCursorCXXBaseSpecifier(CXCursor C)966 const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
967 assert(C.kind == CXCursor_CXXBaseSpecifier);
968 return static_cast<const CXXBaseSpecifier *>(C.data[0]);
969 }
970
MakePreprocessingDirectiveCursor(SourceRange Range,CXTranslationUnit TU)971 CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
972 CXTranslationUnit TU) {
973 CXCursor C = {
974 CXCursor_PreprocessingDirective,
975 0,
976 {Range.getBegin().getPtrEncoding(), Range.getEnd().getPtrEncoding(), TU}};
977 return C;
978 }
979
getCursorPreprocessingDirective(CXCursor C)980 SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
981 assert(C.kind == CXCursor_PreprocessingDirective);
982 SourceRange Range(SourceLocation::getFromPtrEncoding(C.data[0]),
983 SourceLocation::getFromPtrEncoding(C.data[1]));
984 ASTUnit *TU = getCursorASTUnit(C);
985 return TU->mapRangeFromPreamble(Range);
986 }
987
MakeMacroDefinitionCursor(const MacroDefinitionRecord * MI,CXTranslationUnit TU)988 CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinitionRecord *MI,
989 CXTranslationUnit TU) {
990 CXCursor C = {CXCursor_MacroDefinition, 0, {MI, nullptr, TU}};
991 return C;
992 }
993
getCursorMacroDefinition(CXCursor C)994 const MacroDefinitionRecord *cxcursor::getCursorMacroDefinition(CXCursor C) {
995 assert(C.kind == CXCursor_MacroDefinition);
996 return static_cast<const MacroDefinitionRecord *>(C.data[0]);
997 }
998
MakeMacroExpansionCursor(MacroExpansion * MI,CXTranslationUnit TU)999 CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
1000 CXTranslationUnit TU) {
1001 CXCursor C = {CXCursor_MacroExpansion, 0, {MI, nullptr, TU}};
1002 return C;
1003 }
1004
MakeMacroExpansionCursor(MacroDefinitionRecord * MI,SourceLocation Loc,CXTranslationUnit TU)1005 CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinitionRecord *MI,
1006 SourceLocation Loc,
1007 CXTranslationUnit TU) {
1008 assert(Loc.isValid());
1009 CXCursor C = {CXCursor_MacroExpansion, 0, {MI, Loc.getPtrEncoding(), TU}};
1010 return C;
1011 }
1012
getName() const1013 const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const {
1014 if (isPseudo())
1015 return getAsMacroDefinition()->getName();
1016 return getAsMacroExpansion()->getName();
1017 }
1018 const MacroDefinitionRecord *
getDefinition() const1019 cxcursor::MacroExpansionCursor::getDefinition() const {
1020 if (isPseudo())
1021 return getAsMacroDefinition();
1022 return getAsMacroExpansion()->getDefinition();
1023 }
getSourceRange() const1024 SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const {
1025 if (isPseudo())
1026 return getPseudoLoc();
1027 return getAsMacroExpansion()->getSourceRange();
1028 }
1029
MakeInclusionDirectiveCursor(InclusionDirective * ID,CXTranslationUnit TU)1030 CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
1031 CXTranslationUnit TU) {
1032 CXCursor C = {CXCursor_InclusionDirective, 0, {ID, nullptr, TU}};
1033 return C;
1034 }
1035
getCursorInclusionDirective(CXCursor C)1036 const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
1037 assert(C.kind == CXCursor_InclusionDirective);
1038 return static_cast<const InclusionDirective *>(C.data[0]);
1039 }
1040
MakeCursorLabelRef(LabelStmt * Label,SourceLocation Loc,CXTranslationUnit TU)1041 CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
1042 CXTranslationUnit TU) {
1043
1044 assert(Label && TU && "Invalid arguments!");
1045 void *RawLoc = Loc.getPtrEncoding();
1046 CXCursor C = {CXCursor_LabelRef, 0, {Label, RawLoc, TU}};
1047 return C;
1048 }
1049
1050 std::pair<const LabelStmt *, SourceLocation>
getCursorLabelRef(CXCursor C)1051 cxcursor::getCursorLabelRef(CXCursor C) {
1052 assert(C.kind == CXCursor_LabelRef);
1053 return std::make_pair(static_cast<const LabelStmt *>(C.data[0]),
1054 SourceLocation::getFromPtrEncoding(C.data[1]));
1055 }
1056
MakeCursorOverloadedDeclRef(const OverloadExpr * E,CXTranslationUnit TU)1057 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E,
1058 CXTranslationUnit TU) {
1059 assert(E && TU && "Invalid arguments!");
1060 OverloadedDeclRefStorage Storage(E);
1061 void *RawLoc = E->getNameLoc().getPtrEncoding();
1062 CXCursor C = {
1063 CXCursor_OverloadedDeclRef, 0, {Storage.getOpaqueValue(), RawLoc, TU}};
1064 return C;
1065 }
1066
MakeCursorOverloadedDeclRef(const Decl * D,SourceLocation Loc,CXTranslationUnit TU)1067 CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D,
1068 SourceLocation Loc,
1069 CXTranslationUnit TU) {
1070 assert(D && TU && "Invalid arguments!");
1071 void *RawLoc = Loc.getPtrEncoding();
1072 OverloadedDeclRefStorage Storage(D);
1073 CXCursor C = {
1074 CXCursor_OverloadedDeclRef, 0, {Storage.getOpaqueValue(), RawLoc, TU}};
1075 return C;
1076 }
1077
MakeCursorOverloadedDeclRef(TemplateName Name,SourceLocation Loc,CXTranslationUnit TU)1078 CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
1079 SourceLocation Loc,
1080 CXTranslationUnit TU) {
1081 assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
1082 void *RawLoc = Loc.getPtrEncoding();
1083 OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
1084 CXCursor C = {
1085 CXCursor_OverloadedDeclRef, 0, {Storage.getOpaqueValue(), RawLoc, TU}};
1086 return C;
1087 }
1088
1089 std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
getCursorOverloadedDeclRef(CXCursor C)1090 cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
1091 assert(C.kind == CXCursor_OverloadedDeclRef);
1092 return std::make_pair(OverloadedDeclRefStorage::getFromOpaqueValue(
1093 const_cast<void *>(C.data[0])),
1094 SourceLocation::getFromPtrEncoding(C.data[1]));
1095 }
1096
getCursorDecl(CXCursor Cursor)1097 const Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
1098 return static_cast<const Decl *>(Cursor.data[0]);
1099 }
1100
getCursorExpr(CXCursor Cursor)1101 const Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
1102 return dyn_cast_or_null<Expr>(getCursorStmt(Cursor));
1103 }
1104
getCursorStmt(CXCursor Cursor)1105 const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
1106 if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
1107 Cursor.kind == CXCursor_ObjCProtocolRef ||
1108 Cursor.kind == CXCursor_ObjCClassRef)
1109 return nullptr;
1110
1111 return static_cast<const Stmt *>(Cursor.data[1]);
1112 }
1113
getCursorAttr(CXCursor Cursor)1114 const Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
1115 return static_cast<const Attr *>(Cursor.data[1]);
1116 }
1117
getCursorContext(CXCursor Cursor)1118 ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
1119 return getCursorASTUnit(Cursor)->getASTContext();
1120 }
1121
getCursorASTUnit(CXCursor Cursor)1122 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
1123 CXTranslationUnit TU = getCursorTU(Cursor);
1124 if (!TU)
1125 return nullptr;
1126 return cxtu::getASTUnit(TU);
1127 }
1128
getCursorTU(CXCursor Cursor)1129 CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
1130 return static_cast<CXTranslationUnit>(const_cast<void *>(Cursor.data[2]));
1131 }
1132
getOverriddenCursors(CXCursor cursor,SmallVectorImpl<CXCursor> & overridden)1133 void cxcursor::getOverriddenCursors(CXCursor cursor,
1134 SmallVectorImpl<CXCursor> &overridden) {
1135 assert(clang_isDeclaration(cursor.kind));
1136 const NamedDecl *D = dyn_cast_or_null<NamedDecl>(getCursorDecl(cursor));
1137 if (!D)
1138 return;
1139
1140 CXTranslationUnit TU = getCursorTU(cursor);
1141 SmallVector<const NamedDecl *, 8> OverDecls;
1142 D->getASTContext().getOverriddenMethods(D, OverDecls);
1143
1144 for (SmallVectorImpl<const NamedDecl *>::iterator I = OverDecls.begin(),
1145 E = OverDecls.end();
1146 I != E; ++I) {
1147 overridden.push_back(MakeCXCursor(*I, TU));
1148 }
1149 }
1150
1151 std::pair<int, SourceLocation>
getSelectorIdentifierIndexAndLoc(CXCursor cursor)1152 cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) {
1153 if (cursor.kind == CXCursor_ObjCMessageExpr) {
1154 if (cursor.xdata != -1)
1155 return std::make_pair(cursor.xdata,
1156 cast<ObjCMessageExpr>(getCursorExpr(cursor))
1157 ->getSelectorLoc(cursor.xdata));
1158 } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
1159 cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
1160 if (cursor.xdata != -1)
1161 return std::make_pair(cursor.xdata,
1162 cast<ObjCMethodDecl>(getCursorDecl(cursor))
1163 ->getSelectorLoc(cursor.xdata));
1164 }
1165
1166 return std::make_pair(-1, SourceLocation());
1167 }
1168
getSelectorIdentifierCursor(int SelIdx,CXCursor cursor)1169 CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) {
1170 CXCursor newCursor = cursor;
1171
1172 if (cursor.kind == CXCursor_ObjCMessageExpr) {
1173 if (SelIdx == -1 ||
1174 unsigned(SelIdx) >=
1175 cast<ObjCMessageExpr>(getCursorExpr(cursor))->getNumSelectorLocs())
1176 newCursor.xdata = -1;
1177 else
1178 newCursor.xdata = SelIdx;
1179 } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
1180 cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
1181 if (SelIdx == -1 ||
1182 unsigned(SelIdx) >=
1183 cast<ObjCMethodDecl>(getCursorDecl(cursor))->getNumSelectorLocs())
1184 newCursor.xdata = -1;
1185 else
1186 newCursor.xdata = SelIdx;
1187 }
1188
1189 return newCursor;
1190 }
1191
getTypeRefCursor(CXCursor cursor)1192 CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) {
1193 if (cursor.kind != CXCursor_CallExpr)
1194 return cursor;
1195
1196 if (cursor.xdata == 0)
1197 return cursor;
1198
1199 const Expr *E = getCursorExpr(cursor);
1200 TypeSourceInfo *Type = nullptr;
1201 if (const CXXUnresolvedConstructExpr *UnCtor =
1202 dyn_cast<CXXUnresolvedConstructExpr>(E)) {
1203 Type = UnCtor->getTypeSourceInfo();
1204 } else if (const CXXTemporaryObjectExpr *Tmp =
1205 dyn_cast<CXXTemporaryObjectExpr>(E)) {
1206 Type = Tmp->getTypeSourceInfo();
1207 }
1208
1209 if (!Type)
1210 return cursor;
1211
1212 CXTranslationUnit TU = getCursorTU(cursor);
1213 QualType Ty = Type->getType();
1214 TypeLoc TL = Type->getTypeLoc();
1215 SourceLocation Loc = TL.getBeginLoc();
1216
1217 if (const ElaboratedType *ElabT = Ty->getAs<ElaboratedType>()) {
1218 Ty = ElabT->getNamedType();
1219 ElaboratedTypeLoc ElabTL = TL.castAs<ElaboratedTypeLoc>();
1220 Loc = ElabTL.getNamedTypeLoc().getBeginLoc();
1221 }
1222
1223 if (const TypedefType *Typedef = Ty->getAs<TypedefType>())
1224 return MakeCursorTypeRef(Typedef->getDecl(), Loc, TU);
1225 if (const TagType *Tag = Ty->getAs<TagType>())
1226 return MakeCursorTypeRef(Tag->getDecl(), Loc, TU);
1227 if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>())
1228 return MakeCursorTypeRef(TemplP->getDecl(), Loc, TU);
1229
1230 return cursor;
1231 }
1232
operator ==(CXCursor X,CXCursor Y)1233 bool cxcursor::operator==(CXCursor X, CXCursor Y) {
1234 return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
1235 X.data[2] == Y.data[2];
1236 }
1237
1238 // FIXME: Remove once we can model DeclGroups and their appropriate ranges
1239 // properly in the ASTs.
isFirstInDeclGroup(CXCursor C)1240 bool cxcursor::isFirstInDeclGroup(CXCursor C) {
1241 assert(clang_isDeclaration(C.kind));
1242 return ((uintptr_t)(C.data[1])) != 0;
1243 }
1244
1245 //===----------------------------------------------------------------------===//
1246 // libclang CXCursor APIs
1247 //===----------------------------------------------------------------------===//
1248
clang_Cursor_isNull(CXCursor cursor)1249 int clang_Cursor_isNull(CXCursor cursor) {
1250 return clang_equalCursors(cursor, clang_getNullCursor());
1251 }
1252
clang_Cursor_getTranslationUnit(CXCursor cursor)1253 CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) {
1254 return getCursorTU(cursor);
1255 }
1256
clang_Cursor_getNumArguments(CXCursor C)1257 int clang_Cursor_getNumArguments(CXCursor C) {
1258 if (clang_isDeclaration(C.kind)) {
1259 const Decl *D = cxcursor::getCursorDecl(C);
1260 if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
1261 return MD->param_size();
1262 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
1263 return FD->param_size();
1264 }
1265
1266 if (clang_isExpression(C.kind)) {
1267 const Expr *E = cxcursor::getCursorExpr(C);
1268 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1269 return CE->getNumArgs();
1270 }
1271 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E)) {
1272 return CE->getNumArgs();
1273 }
1274 }
1275
1276 return -1;
1277 }
1278
clang_Cursor_getArgument(CXCursor C,unsigned i)1279 CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) {
1280 if (clang_isDeclaration(C.kind)) {
1281 const Decl *D = cxcursor::getCursorDecl(C);
1282 if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) {
1283 if (i < MD->param_size())
1284 return cxcursor::MakeCXCursor(MD->parameters()[i],
1285 cxcursor::getCursorTU(C));
1286 } else if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
1287 if (i < FD->param_size())
1288 return cxcursor::MakeCXCursor(FD->parameters()[i],
1289 cxcursor::getCursorTU(C));
1290 }
1291 }
1292
1293 if (clang_isExpression(C.kind)) {
1294 const Expr *E = cxcursor::getCursorExpr(C);
1295 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1296 if (i < CE->getNumArgs()) {
1297 return cxcursor::MakeCXCursor(CE->getArg(i), getCursorDecl(C),
1298 cxcursor::getCursorTU(C));
1299 }
1300 }
1301 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E)) {
1302 if (i < CE->getNumArgs()) {
1303 return cxcursor::MakeCXCursor(CE->getArg(i), getCursorDecl(C),
1304 cxcursor::getCursorTU(C));
1305 }
1306 }
1307 }
1308
1309 return clang_getNullCursor();
1310 }
1311
clang_Cursor_getNumTemplateArguments(CXCursor C)1312 int clang_Cursor_getNumTemplateArguments(CXCursor C) {
1313 if (clang_getCursorKind(C) != CXCursor_FunctionDecl) {
1314 return -1;
1315 }
1316
1317 const FunctionDecl *FD =
1318 llvm::dyn_cast_or_null<clang::FunctionDecl>(getCursorDecl(C));
1319 if (!FD) {
1320 return -1;
1321 }
1322
1323 const FunctionTemplateSpecializationInfo *SpecInfo =
1324 FD->getTemplateSpecializationInfo();
1325 if (!SpecInfo) {
1326 return -1;
1327 }
1328
1329 return SpecInfo->TemplateArguments->size();
1330 }
1331
1332 enum CXGetTemplateArgumentStatus {
1333 /** The operation completed successfully */
1334 CXGetTemplateArgumentStatus_Success = 0,
1335
1336 /** The specified cursor did not represent a FunctionDecl. */
1337 CXGetTemplateArgumentStatus_CursorNotFunctionDecl = -1,
1338
1339 /** The specified cursor was not castable to a FunctionDecl. */
1340 CXGetTemplateArgumentStatus_BadFunctionDeclCast = -2,
1341
1342 /** A NULL FunctionTemplateSpecializationInfo was retrieved. */
1343 CXGetTemplateArgumentStatus_NullTemplSpecInfo = -3,
1344
1345 /** An invalid (OOB) argument index was specified */
1346 CXGetTemplateArgumentStatus_InvalidIndex = -4
1347 };
1348
clang_Cursor_getTemplateArgument(CXCursor C,unsigned I,TemplateArgument * TA)1349 static int clang_Cursor_getTemplateArgument(CXCursor C, unsigned I,
1350 TemplateArgument *TA) {
1351 if (clang_getCursorKind(C) != CXCursor_FunctionDecl) {
1352 return CXGetTemplateArgumentStatus_CursorNotFunctionDecl;
1353 }
1354
1355 const FunctionDecl *FD =
1356 llvm::dyn_cast_or_null<clang::FunctionDecl>(getCursorDecl(C));
1357 if (!FD) {
1358 return CXGetTemplateArgumentStatus_BadFunctionDeclCast;
1359 }
1360
1361 const FunctionTemplateSpecializationInfo *SpecInfo =
1362 FD->getTemplateSpecializationInfo();
1363 if (!SpecInfo) {
1364 return CXGetTemplateArgumentStatus_NullTemplSpecInfo;
1365 }
1366
1367 if (I >= SpecInfo->TemplateArguments->size()) {
1368 return CXGetTemplateArgumentStatus_InvalidIndex;
1369 }
1370
1371 *TA = SpecInfo->TemplateArguments->get(I);
1372 return 0;
1373 }
1374
clang_Cursor_getTemplateArgumentKind(CXCursor C,unsigned I)1375 enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C,
1376 unsigned I) {
1377 TemplateArgument TA;
1378 if (clang_Cursor_getTemplateArgument(C, I, &TA)) {
1379 return CXTemplateArgumentKind_Invalid;
1380 }
1381
1382 switch (TA.getKind()) {
1383 case TemplateArgument::Null:
1384 return CXTemplateArgumentKind_Null;
1385 case TemplateArgument::Type:
1386 return CXTemplateArgumentKind_Type;
1387 case TemplateArgument::Declaration:
1388 return CXTemplateArgumentKind_Declaration;
1389 case TemplateArgument::NullPtr:
1390 return CXTemplateArgumentKind_NullPtr;
1391 case TemplateArgument::Integral:
1392 return CXTemplateArgumentKind_Integral;
1393 case TemplateArgument::Template:
1394 return CXTemplateArgumentKind_Template;
1395 case TemplateArgument::TemplateExpansion:
1396 return CXTemplateArgumentKind_TemplateExpansion;
1397 case TemplateArgument::Expression:
1398 return CXTemplateArgumentKind_Expression;
1399 case TemplateArgument::Pack:
1400 return CXTemplateArgumentKind_Pack;
1401 }
1402
1403 return CXTemplateArgumentKind_Invalid;
1404 }
1405
clang_Cursor_getTemplateArgumentType(CXCursor C,unsigned I)1406 CXType clang_Cursor_getTemplateArgumentType(CXCursor C, unsigned I) {
1407 TemplateArgument TA;
1408 if (clang_Cursor_getTemplateArgument(C, I, &TA) !=
1409 CXGetTemplateArgumentStatus_Success) {
1410 return cxtype::MakeCXType(QualType(), getCursorTU(C));
1411 }
1412
1413 if (TA.getKind() != TemplateArgument::Type) {
1414 return cxtype::MakeCXType(QualType(), getCursorTU(C));
1415 }
1416
1417 return cxtype::MakeCXType(TA.getAsType(), getCursorTU(C));
1418 }
1419
clang_Cursor_getTemplateArgumentValue(CXCursor C,unsigned I)1420 long long clang_Cursor_getTemplateArgumentValue(CXCursor C, unsigned I) {
1421 TemplateArgument TA;
1422 if (clang_Cursor_getTemplateArgument(C, I, &TA) !=
1423 CXGetTemplateArgumentStatus_Success) {
1424 assert(0 && "Unable to retrieve TemplateArgument");
1425 return 0;
1426 }
1427
1428 if (TA.getKind() != TemplateArgument::Integral) {
1429 assert(0 && "Passed template argument is not Integral");
1430 return 0;
1431 }
1432
1433 return TA.getAsIntegral().getSExtValue();
1434 }
1435
clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C,unsigned I)1436 unsigned long long clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C,
1437 unsigned I) {
1438 TemplateArgument TA;
1439 if (clang_Cursor_getTemplateArgument(C, I, &TA) !=
1440 CXGetTemplateArgumentStatus_Success) {
1441 assert(0 && "Unable to retrieve TemplateArgument");
1442 return 0;
1443 }
1444
1445 if (TA.getKind() != TemplateArgument::Integral) {
1446 assert(0 && "Passed template argument is not Integral");
1447 return 0;
1448 }
1449
1450 return TA.getAsIntegral().getZExtValue();
1451 }
1452
1453 //===----------------------------------------------------------------------===//
1454 // CXCursorSet.
1455 //===----------------------------------------------------------------------===//
1456
1457 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
1458
packCXCursorSet(CXCursorSet_Impl * setImpl)1459 static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
1460 return (CXCursorSet)setImpl;
1461 }
unpackCXCursorSet(CXCursorSet set)1462 static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
1463 return (CXCursorSet_Impl *)set;
1464 }
1465 namespace llvm {
1466 template <> struct DenseMapInfo<CXCursor> {
1467 public:
getEmptyKeyllvm::DenseMapInfo1468 static inline CXCursor getEmptyKey() {
1469 return MakeCXCursorInvalid(CXCursor_InvalidFile);
1470 }
getTombstoneKeyllvm::DenseMapInfo1471 static inline CXCursor getTombstoneKey() {
1472 return MakeCXCursorInvalid(CXCursor_NoDeclFound);
1473 }
getHashValuellvm::DenseMapInfo1474 static inline unsigned getHashValue(const CXCursor &cursor) {
1475 return llvm::DenseMapInfo<std::pair<const void *, const void *>>::
1476 getHashValue(std::make_pair(cursor.data[0], cursor.data[1]));
1477 }
isEqualllvm::DenseMapInfo1478 static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
1479 return x.kind == y.kind && x.data[0] == y.data[0] && x.data[1] == y.data[1];
1480 }
1481 };
1482 } // namespace llvm
1483
clang_createCXCursorSet()1484 CXCursorSet clang_createCXCursorSet() {
1485 return packCXCursorSet(new CXCursorSet_Impl());
1486 }
1487
clang_disposeCXCursorSet(CXCursorSet set)1488 void clang_disposeCXCursorSet(CXCursorSet set) {
1489 delete unpackCXCursorSet(set);
1490 }
1491
clang_CXCursorSet_contains(CXCursorSet set,CXCursor cursor)1492 unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
1493 CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1494 if (!setImpl)
1495 return 0;
1496 return setImpl->find(cursor) != setImpl->end();
1497 }
1498
clang_CXCursorSet_insert(CXCursorSet set,CXCursor cursor)1499 unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
1500 // Do not insert invalid cursors into the set.
1501 if (cursor.kind >= CXCursor_FirstInvalid &&
1502 cursor.kind <= CXCursor_LastInvalid)
1503 return 1;
1504
1505 CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1506 if (!setImpl)
1507 return 1;
1508 unsigned &entry = (*setImpl)[cursor];
1509 unsigned flag = entry == 0 ? 1 : 0;
1510 entry = 1;
1511 return flag;
1512 }
1513
clang_getCursorCompletionString(CXCursor cursor)1514 CXCompletionString clang_getCursorCompletionString(CXCursor cursor) {
1515 enum CXCursorKind kind = clang_getCursorKind(cursor);
1516 if (clang_isDeclaration(kind)) {
1517 const Decl *decl = getCursorDecl(cursor);
1518 if (const NamedDecl *namedDecl = dyn_cast_or_null<NamedDecl>(decl)) {
1519 ASTUnit *unit = getCursorASTUnit(cursor);
1520 CodeCompletionResult Result(namedDecl, CCP_Declaration);
1521 CodeCompletionString *String = Result.CreateCodeCompletionString(
1522 unit->getASTContext(), unit->getPreprocessor(),
1523 CodeCompletionContext::CCC_Other,
1524 unit->getCodeCompletionTUInfo().getAllocator(),
1525 unit->getCodeCompletionTUInfo(), true);
1526 return String;
1527 }
1528 } else if (kind == CXCursor_MacroDefinition) {
1529 const MacroDefinitionRecord *definition = getCursorMacroDefinition(cursor);
1530 const IdentifierInfo *Macro = definition->getName();
1531 ASTUnit *unit = getCursorASTUnit(cursor);
1532 CodeCompletionResult Result(
1533 Macro,
1534 unit->getPreprocessor().getMacroDefinition(Macro).getMacroInfo());
1535 CodeCompletionString *String = Result.CreateCodeCompletionString(
1536 unit->getASTContext(), unit->getPreprocessor(),
1537 CodeCompletionContext::CCC_Other,
1538 unit->getCodeCompletionTUInfo().getAllocator(),
1539 unit->getCodeCompletionTUInfo(), false);
1540 return String;
1541 }
1542 return nullptr;
1543 }
1544
1545 namespace {
1546 struct OverridenCursorsPool {
1547 typedef SmallVector<CXCursor, 2> CursorVec;
1548 std::vector<CursorVec *> AllCursors;
1549 std::vector<CursorVec *> AvailableCursors;
1550
~OverridenCursorsPool__anon04f458790111::OverridenCursorsPool1551 ~OverridenCursorsPool() {
1552 for (std::vector<CursorVec *>::iterator I = AllCursors.begin(),
1553 E = AllCursors.end();
1554 I != E; ++I) {
1555 delete *I;
1556 }
1557 }
1558 };
1559 } // namespace
1560
createOverridenCXCursorsPool()1561 void *cxcursor::createOverridenCXCursorsPool() {
1562 return new OverridenCursorsPool();
1563 }
1564
disposeOverridenCXCursorsPool(void * pool)1565 void cxcursor::disposeOverridenCXCursorsPool(void *pool) {
1566 delete static_cast<OverridenCursorsPool *>(pool);
1567 }
1568
clang_getOverriddenCursors(CXCursor cursor,CXCursor ** overridden,unsigned * num_overridden)1569 void clang_getOverriddenCursors(CXCursor cursor, CXCursor **overridden,
1570 unsigned *num_overridden) {
1571 if (overridden)
1572 *overridden = nullptr;
1573 if (num_overridden)
1574 *num_overridden = 0;
1575
1576 CXTranslationUnit TU = cxcursor::getCursorTU(cursor);
1577
1578 if (!overridden || !num_overridden || !TU)
1579 return;
1580
1581 if (!clang_isDeclaration(cursor.kind))
1582 return;
1583
1584 OverridenCursorsPool &pool =
1585 *static_cast<OverridenCursorsPool *>(TU->OverridenCursorsPool);
1586
1587 OverridenCursorsPool::CursorVec *Vec = nullptr;
1588
1589 if (!pool.AvailableCursors.empty()) {
1590 Vec = pool.AvailableCursors.back();
1591 pool.AvailableCursors.pop_back();
1592 } else {
1593 Vec = new OverridenCursorsPool::CursorVec();
1594 pool.AllCursors.push_back(Vec);
1595 }
1596
1597 // Clear out the vector, but don't free the memory contents. This
1598 // reduces malloc() traffic.
1599 Vec->clear();
1600
1601 // Use the first entry to contain a back reference to the vector.
1602 // This is a complete hack.
1603 CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU);
1604 backRefCursor.data[0] = Vec;
1605 assert(cxcursor::getCursorTU(backRefCursor) == TU);
1606 Vec->push_back(backRefCursor);
1607
1608 // Get the overridden cursors.
1609 cxcursor::getOverriddenCursors(cursor, *Vec);
1610
1611 // Did we get any overridden cursors? If not, return Vec to the pool
1612 // of available cursor vectors.
1613 if (Vec->size() == 1) {
1614 pool.AvailableCursors.push_back(Vec);
1615 return;
1616 }
1617
1618 // Now tell the caller about the overridden cursors.
1619 assert(Vec->size() > 1);
1620 *overridden = &((*Vec)[1]);
1621 *num_overridden = Vec->size() - 1;
1622 }
1623
clang_disposeOverriddenCursors(CXCursor * overridden)1624 void clang_disposeOverriddenCursors(CXCursor *overridden) {
1625 if (!overridden)
1626 return;
1627
1628 // Use pointer arithmetic to get back the first faux entry
1629 // which has a back-reference to the TU and the vector.
1630 --overridden;
1631 OverridenCursorsPool::CursorVec *Vec =
1632 static_cast<OverridenCursorsPool::CursorVec *>(
1633 const_cast<void *>(overridden->data[0]));
1634 CXTranslationUnit TU = getCursorTU(*overridden);
1635
1636 assert(Vec && TU);
1637
1638 OverridenCursorsPool &pool =
1639 *static_cast<OverridenCursorsPool *>(TU->OverridenCursorsPool);
1640
1641 pool.AvailableCursors.push_back(Vec);
1642 }
1643
clang_Cursor_isDynamicCall(CXCursor C)1644 int clang_Cursor_isDynamicCall(CXCursor C) {
1645 const Expr *E = nullptr;
1646 if (clang_isExpression(C.kind))
1647 E = getCursorExpr(C);
1648 if (!E)
1649 return 0;
1650
1651 if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E)) {
1652 if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance)
1653 return false;
1654 if (auto *RecE = dyn_cast<ObjCMessageExpr>(
1655 MsgE->getInstanceReceiver()->IgnoreParenCasts())) {
1656 if (RecE->getMethodFamily() == OMF_alloc)
1657 return false;
1658 }
1659 return true;
1660 }
1661
1662 if (auto *PropRefE = dyn_cast<ObjCPropertyRefExpr>(E)) {
1663 return !PropRefE->isSuperReceiver();
1664 }
1665
1666 const MemberExpr *ME = nullptr;
1667 if (isa<MemberExpr>(E))
1668 ME = cast<MemberExpr>(E);
1669 else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
1670 ME = dyn_cast_or_null<MemberExpr>(CE->getCallee());
1671
1672 if (ME) {
1673 if (const CXXMethodDecl *MD =
1674 dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl()))
1675 return MD->isVirtual() &&
1676 ME->performsVirtualDispatch(
1677 cxcursor::getCursorContext(C).getLangOpts());
1678 }
1679
1680 return 0;
1681 }
1682
clang_Cursor_getReceiverType(CXCursor C)1683 CXType clang_Cursor_getReceiverType(CXCursor C) {
1684 CXTranslationUnit TU = cxcursor::getCursorTU(C);
1685 const Expr *E = nullptr;
1686 if (clang_isExpression(C.kind))
1687 E = getCursorExpr(C);
1688
1689 if (const ObjCMessageExpr *MsgE = dyn_cast_or_null<ObjCMessageExpr>(E))
1690 return cxtype::MakeCXType(MsgE->getReceiverType(), TU);
1691
1692 if (auto *PropRefE = dyn_cast<ObjCPropertyRefExpr>(E)) {
1693 return cxtype::MakeCXType(
1694 PropRefE->getReceiverType(cxcursor::getCursorContext(C)), TU);
1695 }
1696
1697 const MemberExpr *ME = nullptr;
1698 if (isa<MemberExpr>(E))
1699 ME = cast<MemberExpr>(E);
1700 else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
1701 ME = dyn_cast_or_null<MemberExpr>(CE->getCallee());
1702
1703 if (ME) {
1704 if (dyn_cast_or_null<CXXMethodDecl>(ME->getMemberDecl())) {
1705 auto receiverTy = ME->getBase()->IgnoreImpCasts()->getType();
1706 return cxtype::MakeCXType(receiverTy, TU);
1707 }
1708 }
1709
1710 return cxtype::MakeCXType(QualType(), TU);
1711 }
1712