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
31using namespace clang;
32using namespace cxcursor;
33
34CXCursor cxcursor::MakeCXCursorInvalid(CXCursorKind K, CXTranslationUnit TU) {
35 assert(K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid);
36 CXCursor C = {.kind: K, .xdata: 0, .data: {nullptr, nullptr, TU}};
37 return C;
38}
39
40static 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
132CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent,
133 CXTranslationUnit TU) {
134 assert(A && Parent && TU && "Invalid arguments!");
135 CXCursor C = {.kind: GetCursorKind(A), .xdata: 0, .data: {Parent, A, TU}};
136 return C;
137}
138
139CXCursor 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>(Val: D)->getSelectorLocs(SelLocs);
154 SmallVectorImpl<SourceLocation>::iterator I =
155 llvm::find(Range&: SelLocs, Val: RegionOfInterest.getBegin());
156 if (I != SelLocs.end())
157 SelectorIdIndex = I - SelLocs.begin();
158 }
159 CXCursor C = {.kind: K,
160 .xdata: SelectorIdIndex,
161 .data: {D, (void *)(intptr_t)(FirstInDeclGroup ? 1 : 0), TU}};
162 return C;
163 }
164
165 CXCursor C = {.kind: K, .xdata: 0, .data: {D, (void *)(intptr_t)(FirstInDeclGroup ? 1 : 0), TU}};
166 return C;
167}
168
169CXCursor 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 // Not exposed for now because '_Defer' is currently just a TS.
228 case Stmt::DeferStmtClass:
229 K = CXCursor_UnexposedStmt;
230 break;
231
232 case Stmt::GCCAsmStmtClass:
233 K = CXCursor_GCCAsmStmt;
234 break;
235
236 case Stmt::MSAsmStmtClass:
237 K = CXCursor_MSAsmStmt;
238 break;
239
240 case Stmt::ObjCAtTryStmtClass:
241 K = CXCursor_ObjCAtTryStmt;
242 break;
243
244 case Stmt::ObjCAtCatchStmtClass:
245 K = CXCursor_ObjCAtCatchStmt;
246 break;
247
248 case Stmt::ObjCAtFinallyStmtClass:
249 K = CXCursor_ObjCAtFinallyStmt;
250 break;
251
252 case Stmt::ObjCAtThrowStmtClass:
253 K = CXCursor_ObjCAtThrowStmt;
254 break;
255
256 case Stmt::ObjCAtSynchronizedStmtClass:
257 K = CXCursor_ObjCAtSynchronizedStmt;
258 break;
259
260 case Stmt::ObjCAutoreleasePoolStmtClass:
261 K = CXCursor_ObjCAutoreleasePoolStmt;
262 break;
263
264 case Stmt::ObjCForCollectionStmtClass:
265 K = CXCursor_ObjCForCollectionStmt;
266 break;
267
268 case Stmt::CXXCatchStmtClass:
269 K = CXCursor_CXXCatchStmt;
270 break;
271
272 case Stmt::CXXTryStmtClass:
273 K = CXCursor_CXXTryStmt;
274 break;
275
276 case Stmt::CXXForRangeStmtClass:
277 K = CXCursor_CXXForRangeStmt;
278 break;
279
280 case Stmt::SEHTryStmtClass:
281 K = CXCursor_SEHTryStmt;
282 break;
283
284 case Stmt::SEHExceptStmtClass:
285 K = CXCursor_SEHExceptStmt;
286 break;
287
288 case Stmt::SEHFinallyStmtClass:
289 K = CXCursor_SEHFinallyStmt;
290 break;
291
292 case Stmt::SEHLeaveStmtClass:
293 K = CXCursor_SEHLeaveStmt;
294 break;
295
296 case Stmt::CoroutineBodyStmtClass:
297 case Stmt::CoreturnStmtClass:
298 K = CXCursor_UnexposedStmt;
299 break;
300
301 case Stmt::ArrayTypeTraitExprClass:
302 case Stmt::AsTypeExprClass:
303 case Stmt::AtomicExprClass:
304 case Stmt::BinaryConditionalOperatorClass:
305 case Stmt::TypeTraitExprClass:
306 case Stmt::CoawaitExprClass:
307 case Stmt::DependentCoawaitExprClass:
308 case Stmt::CoyieldExprClass:
309 case Stmt::CXXBindTemporaryExprClass:
310 case Stmt::CXXDefaultArgExprClass:
311 case Stmt::CXXDefaultInitExprClass:
312 case Stmt::CXXFoldExprClass:
313 case Stmt::CXXReflectExprClass:
314 case Stmt::CXXRewrittenBinaryOperatorClass:
315 case Stmt::CXXStdInitializerListExprClass:
316 case Stmt::CXXScalarValueInitExprClass:
317 case Stmt::CXXUuidofExprClass:
318 case Stmt::ChooseExprClass:
319 case Stmt::DesignatedInitExprClass:
320 case Stmt::DesignatedInitUpdateExprClass:
321 case Stmt::ArrayInitLoopExprClass:
322 case Stmt::ArrayInitIndexExprClass:
323 case Stmt::ExprWithCleanupsClass:
324 case Stmt::ExpressionTraitExprClass:
325 case Stmt::ExtVectorElementExprClass:
326 case Stmt::MatrixElementExprClass:
327 case Stmt::ImplicitCastExprClass:
328 case Stmt::ImplicitValueInitExprClass:
329 case Stmt::NoInitExprClass:
330 case Stmt::MaterializeTemporaryExprClass:
331 case Stmt::ObjCIndirectCopyRestoreExprClass:
332 case Stmt::OffsetOfExprClass:
333 case Stmt::ParenListExprClass:
334 case Stmt::PredefinedExprClass:
335 case Stmt::ShuffleVectorExprClass:
336 case Stmt::SourceLocExprClass:
337 case Stmt::ConvertVectorExprClass:
338 case Stmt::VAArgExprClass:
339 case Stmt::ObjCArrayLiteralClass:
340 case Stmt::ObjCDictionaryLiteralClass:
341 case Stmt::ObjCBoxedExprClass:
342 case Stmt::ObjCSubscriptRefExprClass:
343 case Stmt::RecoveryExprClass:
344 case Stmt::SYCLUniqueStableNameExprClass:
345 case Stmt::EmbedExprClass:
346 case Stmt::HLSLOutArgExprClass:
347 case Stmt::OpenACCAsteriskSizeExprClass:
348 K = CXCursor_UnexposedExpr;
349 break;
350
351 case Stmt::OpaqueValueExprClass:
352 if (Expr *Src = cast<OpaqueValueExpr>(Val: S)->getSourceExpr())
353 return MakeCXCursor(S: Src, Parent, TU, RegionOfInterest);
354 K = CXCursor_UnexposedExpr;
355 break;
356
357 case Stmt::PseudoObjectExprClass:
358 return MakeCXCursor(S: cast<PseudoObjectExpr>(Val: S)->getSyntacticForm(), Parent,
359 TU, RegionOfInterest);
360
361 case Stmt::CompoundStmtClass:
362 K = CXCursor_CompoundStmt;
363 break;
364
365 case Stmt::NullStmtClass:
366 K = CXCursor_NullStmt;
367 break;
368
369 case Stmt::LabelStmtClass:
370 K = CXCursor_LabelStmt;
371 break;
372
373 case Stmt::AttributedStmtClass:
374 K = CXCursor_UnexposedStmt;
375 break;
376
377 case Stmt::DeclStmtClass:
378 K = CXCursor_DeclStmt;
379 break;
380
381 case Stmt::CapturedStmtClass:
382 K = CXCursor_UnexposedStmt;
383 break;
384
385 case Stmt::SYCLKernelCallStmtClass:
386 K = CXCursor_UnexposedStmt;
387 break;
388
389 case Stmt::IntegerLiteralClass:
390 K = CXCursor_IntegerLiteral;
391 break;
392
393 case Stmt::FixedPointLiteralClass:
394 K = CXCursor_FixedPointLiteral;
395 break;
396
397 case Stmt::FloatingLiteralClass:
398 K = CXCursor_FloatingLiteral;
399 break;
400
401 case Stmt::ImaginaryLiteralClass:
402 K = CXCursor_ImaginaryLiteral;
403 break;
404
405 case Stmt::StringLiteralClass:
406 K = CXCursor_StringLiteral;
407 break;
408
409 case Stmt::CharacterLiteralClass:
410 K = CXCursor_CharacterLiteral;
411 break;
412
413 case Stmt::ConstantExprClass:
414 return MakeCXCursor(S: cast<ConstantExpr>(Val: S)->getSubExpr(), Parent, TU,
415 RegionOfInterest);
416
417 case Stmt::ParenExprClass:
418 K = CXCursor_ParenExpr;
419 break;
420
421 case Stmt::UnaryOperatorClass:
422 K = CXCursor_UnaryOperator;
423 break;
424
425 case Stmt::UnaryExprOrTypeTraitExprClass:
426 case Stmt::CXXNoexceptExprClass:
427 K = CXCursor_UnaryExpr;
428 break;
429
430 case Stmt::MSPropertySubscriptExprClass:
431 case Stmt::ArraySubscriptExprClass:
432 K = CXCursor_ArraySubscriptExpr;
433 break;
434
435 case Stmt::MatrixSingleSubscriptExprClass:
436 // TODO: add support for MatrixSingleSubscriptExpr.
437 K = CXCursor_UnexposedExpr;
438 break;
439
440 case Stmt::MatrixSubscriptExprClass:
441 // TODO: add support for MatrixSubscriptExpr.
442 K = CXCursor_UnexposedExpr;
443 break;
444
445 case Stmt::ArraySectionExprClass:
446 K = CXCursor_ArraySectionExpr;
447 break;
448
449 case Stmt::OMPArrayShapingExprClass:
450 K = CXCursor_OMPArrayShapingExpr;
451 break;
452
453 case Stmt::OMPIteratorExprClass:
454 K = CXCursor_OMPIteratorExpr;
455 break;
456
457 case Stmt::BinaryOperatorClass:
458 K = CXCursor_BinaryOperator;
459 break;
460
461 case Stmt::CompoundAssignOperatorClass:
462 K = CXCursor_CompoundAssignOperator;
463 break;
464
465 case Stmt::ConditionalOperatorClass:
466 K = CXCursor_ConditionalOperator;
467 break;
468
469 case Stmt::CStyleCastExprClass:
470 K = CXCursor_CStyleCastExpr;
471 break;
472
473 case Stmt::CompoundLiteralExprClass:
474 K = CXCursor_CompoundLiteralExpr;
475 break;
476
477 case Stmt::InitListExprClass:
478 K = CXCursor_InitListExpr;
479 break;
480
481 case Stmt::AddrLabelExprClass:
482 K = CXCursor_AddrLabelExpr;
483 break;
484
485 case Stmt::StmtExprClass:
486 K = CXCursor_StmtExpr;
487 break;
488
489 case Stmt::GenericSelectionExprClass:
490 K = CXCursor_GenericSelectionExpr;
491 break;
492
493 case Stmt::GNUNullExprClass:
494 K = CXCursor_GNUNullExpr;
495 break;
496
497 case Stmt::CXXStaticCastExprClass:
498 K = CXCursor_CXXStaticCastExpr;
499 break;
500
501 case Stmt::CXXDynamicCastExprClass:
502 K = CXCursor_CXXDynamicCastExpr;
503 break;
504
505 case Stmt::CXXReinterpretCastExprClass:
506 K = CXCursor_CXXReinterpretCastExpr;
507 break;
508
509 case Stmt::CXXConstCastExprClass:
510 K = CXCursor_CXXConstCastExpr;
511 break;
512
513 case Stmt::CXXFunctionalCastExprClass:
514 K = CXCursor_CXXFunctionalCastExpr;
515 break;
516
517 case Stmt::CXXAddrspaceCastExprClass:
518 K = CXCursor_CXXAddrspaceCastExpr;
519 break;
520
521 case Stmt::CXXTypeidExprClass:
522 K = CXCursor_CXXTypeidExpr;
523 break;
524
525 case Stmt::CXXBoolLiteralExprClass:
526 K = CXCursor_CXXBoolLiteralExpr;
527 break;
528
529 case Stmt::CXXNullPtrLiteralExprClass:
530 K = CXCursor_CXXNullPtrLiteralExpr;
531 break;
532
533 case Stmt::CXXThisExprClass:
534 K = CXCursor_CXXThisExpr;
535 break;
536
537 case Stmt::CXXThrowExprClass:
538 K = CXCursor_CXXThrowExpr;
539 break;
540
541 case Stmt::CXXNewExprClass:
542 K = CXCursor_CXXNewExpr;
543 break;
544
545 case Stmt::CXXDeleteExprClass:
546 K = CXCursor_CXXDeleteExpr;
547 break;
548
549 case Stmt::ObjCStringLiteralClass:
550 K = CXCursor_ObjCStringLiteral;
551 break;
552
553 case Stmt::ObjCEncodeExprClass:
554 K = CXCursor_ObjCEncodeExpr;
555 break;
556
557 case Stmt::ObjCSelectorExprClass:
558 K = CXCursor_ObjCSelectorExpr;
559 break;
560
561 case Stmt::ObjCProtocolExprClass:
562 K = CXCursor_ObjCProtocolExpr;
563 break;
564
565 case Stmt::ObjCBoolLiteralExprClass:
566 K = CXCursor_ObjCBoolLiteralExpr;
567 break;
568
569 case Stmt::ObjCAvailabilityCheckExprClass:
570 K = CXCursor_ObjCAvailabilityCheckExpr;
571 break;
572
573 case Stmt::ObjCBridgedCastExprClass:
574 K = CXCursor_ObjCBridgedCastExpr;
575 break;
576
577 case Stmt::BlockExprClass:
578 K = CXCursor_BlockExpr;
579 break;
580
581 case Stmt::PackExpansionExprClass:
582 K = CXCursor_PackExpansionExpr;
583 break;
584
585 case Stmt::SizeOfPackExprClass:
586 K = CXCursor_SizeOfPackExpr;
587 break;
588
589 case Stmt::PackIndexingExprClass:
590 K = CXCursor_PackIndexingExpr;
591 break;
592
593 case Stmt::DeclRefExprClass:
594 if (const ImplicitParamDecl *IPD = dyn_cast_or_null<ImplicitParamDecl>(
595 Val: cast<DeclRefExpr>(Val: S)->getDecl())) {
596 if (const ObjCMethodDecl *MD =
597 dyn_cast<ObjCMethodDecl>(Val: IPD->getDeclContext())) {
598 if (MD->getSelfDecl() == IPD) {
599 K = CXCursor_ObjCSelfExpr;
600 break;
601 }
602 }
603 }
604
605 K = CXCursor_DeclRefExpr;
606 break;
607
608 case Stmt::DependentScopeDeclRefExprClass:
609 case Stmt::SubstNonTypeTemplateParmExprClass:
610 case Stmt::SubstNonTypeTemplateParmPackExprClass:
611 case Stmt::FunctionParmPackExprClass:
612 case Stmt::UnresolvedLookupExprClass:
613 K = CXCursor_DeclRefExpr;
614 break;
615
616 case Stmt::CXXDependentScopeMemberExprClass:
617 case Stmt::CXXPseudoDestructorExprClass:
618 case Stmt::MemberExprClass:
619 case Stmt::MSPropertyRefExprClass:
620 case Stmt::ObjCIsaExprClass:
621 case Stmt::ObjCIvarRefExprClass:
622 case Stmt::ObjCPropertyRefExprClass:
623 case Stmt::UnresolvedMemberExprClass:
624 K = CXCursor_MemberRefExpr;
625 break;
626
627 case Stmt::CallExprClass:
628 case Stmt::CXXOperatorCallExprClass:
629 case Stmt::CXXMemberCallExprClass:
630 case Stmt::CUDAKernelCallExprClass:
631 case Stmt::CXXConstructExprClass:
632 case Stmt::CXXInheritedCtorInitExprClass:
633 case Stmt::CXXTemporaryObjectExprClass:
634 case Stmt::CXXUnresolvedConstructExprClass:
635 case Stmt::UserDefinedLiteralClass:
636 K = CXCursor_CallExpr;
637 break;
638
639 case Stmt::LambdaExprClass:
640 K = CXCursor_LambdaExpr;
641 break;
642
643 case Stmt::ObjCMessageExprClass: {
644 K = CXCursor_ObjCMessageExpr;
645 int SelectorIdIndex = -1;
646 // Check if cursor points to a selector id.
647 if (RegionOfInterest.isValid() &&
648 RegionOfInterest.getBegin() == RegionOfInterest.getEnd()) {
649 SmallVector<SourceLocation, 16> SelLocs;
650 cast<ObjCMessageExpr>(Val: S)->getSelectorLocs(SelLocs);
651 SmallVectorImpl<SourceLocation>::iterator I =
652 llvm::find(Range&: SelLocs, Val: RegionOfInterest.getBegin());
653 if (I != SelLocs.end())
654 SelectorIdIndex = I - SelLocs.begin();
655 }
656 CXCursor C = {.kind: K, .xdata: 0, .data: {Parent, S, TU}};
657 return getSelectorIdentifierCursor(SelIdx: SelectorIdIndex, cursor: C);
658 }
659
660 case Stmt::ConceptSpecializationExprClass:
661 K = CXCursor_ConceptSpecializationExpr;
662 break;
663
664 case Stmt::RequiresExprClass:
665 K = CXCursor_RequiresExpr;
666 break;
667
668 case Stmt::CXXParenListInitExprClass:
669 K = CXCursor_CXXParenListInitExpr;
670 break;
671
672 case Stmt::MSDependentExistsStmtClass:
673 K = CXCursor_UnexposedStmt;
674 break;
675 case Stmt::OMPCanonicalLoopClass:
676 K = CXCursor_OMPCanonicalLoop;
677 break;
678 case Stmt::OMPMetaDirectiveClass:
679 K = CXCursor_OMPMetaDirective;
680 break;
681 case Stmt::OMPParallelDirectiveClass:
682 K = CXCursor_OMPParallelDirective;
683 break;
684 case Stmt::OMPSimdDirectiveClass:
685 K = CXCursor_OMPSimdDirective;
686 break;
687 case Stmt::OMPTileDirectiveClass:
688 K = CXCursor_OMPTileDirective;
689 break;
690 case Stmt::OMPStripeDirectiveClass:
691 K = CXCursor_OMPStripeDirective;
692 break;
693 case Stmt::OMPUnrollDirectiveClass:
694 K = CXCursor_OMPUnrollDirective;
695 break;
696 case Stmt::OMPReverseDirectiveClass:
697 K = CXCursor_OMPReverseDirective;
698 break;
699 case Stmt::OMPInterchangeDirectiveClass:
700 K = CXCursor_OMPInterchangeDirective;
701 break;
702 case Stmt::OMPFuseDirectiveClass:
703 K = CXCursor_OMPFuseDirective;
704 break;
705 case Stmt::OMPForDirectiveClass:
706 K = CXCursor_OMPForDirective;
707 break;
708 case Stmt::OMPForSimdDirectiveClass:
709 K = CXCursor_OMPForSimdDirective;
710 break;
711 case Stmt::OMPSectionsDirectiveClass:
712 K = CXCursor_OMPSectionsDirective;
713 break;
714 case Stmt::OMPSectionDirectiveClass:
715 K = CXCursor_OMPSectionDirective;
716 break;
717 case Stmt::OMPScopeDirectiveClass:
718 K = CXCursor_OMPScopeDirective;
719 break;
720 case Stmt::OMPSingleDirectiveClass:
721 K = CXCursor_OMPSingleDirective;
722 break;
723 case Stmt::OMPMasterDirectiveClass:
724 K = CXCursor_OMPMasterDirective;
725 break;
726 case Stmt::OMPCriticalDirectiveClass:
727 K = CXCursor_OMPCriticalDirective;
728 break;
729 case Stmt::OMPParallelForDirectiveClass:
730 K = CXCursor_OMPParallelForDirective;
731 break;
732 case Stmt::OMPParallelForSimdDirectiveClass:
733 K = CXCursor_OMPParallelForSimdDirective;
734 break;
735 case Stmt::OMPParallelMasterDirectiveClass:
736 K = CXCursor_OMPParallelMasterDirective;
737 break;
738 case Stmt::OMPParallelMaskedDirectiveClass:
739 K = CXCursor_OMPParallelMaskedDirective;
740 break;
741 case Stmt::OMPParallelSectionsDirectiveClass:
742 K = CXCursor_OMPParallelSectionsDirective;
743 break;
744 case Stmt::OMPTaskDirectiveClass:
745 K = CXCursor_OMPTaskDirective;
746 break;
747 case Stmt::OMPTaskyieldDirectiveClass:
748 K = CXCursor_OMPTaskyieldDirective;
749 break;
750 case Stmt::OMPBarrierDirectiveClass:
751 K = CXCursor_OMPBarrierDirective;
752 break;
753 case Stmt::OMPTaskwaitDirectiveClass:
754 K = CXCursor_OMPTaskwaitDirective;
755 break;
756 case Stmt::OMPErrorDirectiveClass:
757 K = CXCursor_OMPErrorDirective;
758 break;
759 case Stmt::OMPTaskgroupDirectiveClass:
760 K = CXCursor_OMPTaskgroupDirective;
761 break;
762 case Stmt::OMPFlushDirectiveClass:
763 K = CXCursor_OMPFlushDirective;
764 break;
765 case Stmt::OMPDepobjDirectiveClass:
766 K = CXCursor_OMPDepobjDirective;
767 break;
768 case Stmt::OMPScanDirectiveClass:
769 K = CXCursor_OMPScanDirective;
770 break;
771 case Stmt::OMPOrderedDirectiveClass:
772 K = CXCursor_OMPOrderedDirective;
773 break;
774 case Stmt::OMPAtomicDirectiveClass:
775 K = CXCursor_OMPAtomicDirective;
776 break;
777 case Stmt::OMPTargetDirectiveClass:
778 K = CXCursor_OMPTargetDirective;
779 break;
780 case Stmt::OMPTargetDataDirectiveClass:
781 K = CXCursor_OMPTargetDataDirective;
782 break;
783 case Stmt::OMPTargetEnterDataDirectiveClass:
784 K = CXCursor_OMPTargetEnterDataDirective;
785 break;
786 case Stmt::OMPTargetExitDataDirectiveClass:
787 K = CXCursor_OMPTargetExitDataDirective;
788 break;
789 case Stmt::OMPTargetParallelDirectiveClass:
790 K = CXCursor_OMPTargetParallelDirective;
791 break;
792 case Stmt::OMPTargetParallelForDirectiveClass:
793 K = CXCursor_OMPTargetParallelForDirective;
794 break;
795 case Stmt::OMPTargetUpdateDirectiveClass:
796 K = CXCursor_OMPTargetUpdateDirective;
797 break;
798 case Stmt::OMPTeamsDirectiveClass:
799 K = CXCursor_OMPTeamsDirective;
800 break;
801 case Stmt::OMPCancellationPointDirectiveClass:
802 K = CXCursor_OMPCancellationPointDirective;
803 break;
804 case Stmt::OMPCancelDirectiveClass:
805 K = CXCursor_OMPCancelDirective;
806 break;
807 case Stmt::OMPTaskLoopDirectiveClass:
808 K = CXCursor_OMPTaskLoopDirective;
809 break;
810 case Stmt::OMPTaskLoopSimdDirectiveClass:
811 K = CXCursor_OMPTaskLoopSimdDirective;
812 break;
813 case Stmt::OMPMasterTaskLoopDirectiveClass:
814 K = CXCursor_OMPMasterTaskLoopDirective;
815 break;
816 case Stmt::OMPMaskedTaskLoopDirectiveClass:
817 K = CXCursor_OMPMaskedTaskLoopDirective;
818 break;
819 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
820 K = CXCursor_OMPMasterTaskLoopSimdDirective;
821 break;
822 case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
823 K = CXCursor_OMPMaskedTaskLoopSimdDirective;
824 break;
825 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
826 K = CXCursor_OMPParallelMasterTaskLoopDirective;
827 break;
828 case Stmt::OMPParallelMaskedTaskLoopDirectiveClass:
829 K = CXCursor_OMPParallelMaskedTaskLoopDirective;
830 break;
831 case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
832 K = CXCursor_OMPParallelMasterTaskLoopSimdDirective;
833 break;
834 case Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:
835 K = CXCursor_OMPParallelMaskedTaskLoopSimdDirective;
836 break;
837 case Stmt::OMPDistributeDirectiveClass:
838 K = CXCursor_OMPDistributeDirective;
839 break;
840 case Stmt::OMPDistributeParallelForDirectiveClass:
841 K = CXCursor_OMPDistributeParallelForDirective;
842 break;
843 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
844 K = CXCursor_OMPDistributeParallelForSimdDirective;
845 break;
846 case Stmt::OMPDistributeSimdDirectiveClass:
847 K = CXCursor_OMPDistributeSimdDirective;
848 break;
849 case Stmt::OMPTargetParallelForSimdDirectiveClass:
850 K = CXCursor_OMPTargetParallelForSimdDirective;
851 break;
852 case Stmt::OMPTargetSimdDirectiveClass:
853 K = CXCursor_OMPTargetSimdDirective;
854 break;
855 case Stmt::OMPTeamsDistributeDirectiveClass:
856 K = CXCursor_OMPTeamsDistributeDirective;
857 break;
858 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
859 K = CXCursor_OMPTeamsDistributeSimdDirective;
860 break;
861 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
862 K = CXCursor_OMPTeamsDistributeParallelForSimdDirective;
863 break;
864 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
865 K = CXCursor_OMPTeamsDistributeParallelForDirective;
866 break;
867 case Stmt::OMPTargetTeamsDirectiveClass:
868 K = CXCursor_OMPTargetTeamsDirective;
869 break;
870 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
871 K = CXCursor_OMPTargetTeamsDistributeDirective;
872 break;
873 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
874 K = CXCursor_OMPTargetTeamsDistributeParallelForDirective;
875 break;
876 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
877 K = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective;
878 break;
879 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
880 K = CXCursor_OMPTargetTeamsDistributeSimdDirective;
881 break;
882 case Stmt::OMPInteropDirectiveClass:
883 K = CXCursor_OMPInteropDirective;
884 break;
885 case Stmt::OMPDispatchDirectiveClass:
886 K = CXCursor_OMPDispatchDirective;
887 break;
888 case Stmt::OMPMaskedDirectiveClass:
889 K = CXCursor_OMPMaskedDirective;
890 break;
891 case Stmt::OMPGenericLoopDirectiveClass:
892 K = CXCursor_OMPGenericLoopDirective;
893 break;
894 case Stmt::OMPTeamsGenericLoopDirectiveClass:
895 K = CXCursor_OMPTeamsGenericLoopDirective;
896 break;
897 case Stmt::OMPTargetTeamsGenericLoopDirectiveClass:
898 K = CXCursor_OMPTargetTeamsGenericLoopDirective;
899 break;
900 case Stmt::OMPParallelGenericLoopDirectiveClass:
901 K = CXCursor_OMPParallelGenericLoopDirective;
902 break;
903 case Stmt::OpenACCComputeConstructClass:
904 K = CXCursor_OpenACCComputeConstruct;
905 break;
906 case Stmt::OpenACCLoopConstructClass:
907 K = CXCursor_OpenACCLoopConstruct;
908 break;
909 case Stmt::OpenACCCombinedConstructClass:
910 K = CXCursor_OpenACCCombinedConstruct;
911 break;
912 case Stmt::OpenACCDataConstructClass:
913 K = CXCursor_OpenACCDataConstruct;
914 break;
915 case Stmt::OpenACCEnterDataConstructClass:
916 K = CXCursor_OpenACCEnterDataConstruct;
917 break;
918 case Stmt::OpenACCExitDataConstructClass:
919 K = CXCursor_OpenACCExitDataConstruct;
920 break;
921 case Stmt::OpenACCHostDataConstructClass:
922 K = CXCursor_OpenACCHostDataConstruct;
923 break;
924 case Stmt::OpenACCWaitConstructClass:
925 K = CXCursor_OpenACCWaitConstruct;
926 break;
927 case Stmt::OpenACCCacheConstructClass:
928 K = CXCursor_OpenACCCacheConstruct;
929 break;
930 case Stmt::OpenACCInitConstructClass:
931 K = CXCursor_OpenACCInitConstruct;
932 break;
933 case Stmt::OpenACCShutdownConstructClass:
934 K = CXCursor_OpenACCShutdownConstruct;
935 break;
936 case Stmt::OpenACCSetConstructClass:
937 K = CXCursor_OpenACCSetConstruct;
938 break;
939 case Stmt::OpenACCUpdateConstructClass:
940 K = CXCursor_OpenACCUpdateConstruct;
941 break;
942 case Stmt::OpenACCAtomicConstructClass:
943 K = CXCursor_OpenACCAtomicConstruct;
944 break;
945 case Stmt::OMPTargetParallelGenericLoopDirectiveClass:
946 K = CXCursor_OMPTargetParallelGenericLoopDirective;
947 break;
948 case Stmt::BuiltinBitCastExprClass:
949 K = CXCursor_BuiltinBitCastExpr;
950 break;
951 case Stmt::OMPAssumeDirectiveClass:
952 K = CXCursor_OMPAssumeDirective;
953 break;
954 }
955
956 CXCursor C = {.kind: K, .xdata: 0, .data: {Parent, S, TU}};
957 return C;
958}
959
960CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super,
961 SourceLocation Loc,
962 CXTranslationUnit TU) {
963 assert(Super && TU && "Invalid arguments!");
964 void *RawLoc = Loc.getPtrEncoding();
965 CXCursor C = {.kind: CXCursor_ObjCSuperClassRef, .xdata: 0, .data: {Super, RawLoc, TU}};
966 return C;
967}
968
969std::pair<const ObjCInterfaceDecl *, SourceLocation>
970cxcursor::getCursorObjCSuperClassRef(CXCursor C) {
971 assert(C.kind == CXCursor_ObjCSuperClassRef);
972 return std::make_pair(x: static_cast<const ObjCInterfaceDecl *>(C.data[0]),
973 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
974}
975
976CXCursor cxcursor::MakeCursorObjCProtocolRef(const ObjCProtocolDecl *Proto,
977 SourceLocation Loc,
978 CXTranslationUnit TU) {
979 assert(Proto && TU && "Invalid arguments!");
980 void *RawLoc = Loc.getPtrEncoding();
981 CXCursor C = {.kind: CXCursor_ObjCProtocolRef, .xdata: 0, .data: {Proto, RawLoc, TU}};
982 return C;
983}
984
985std::pair<const ObjCProtocolDecl *, SourceLocation>
986cxcursor::getCursorObjCProtocolRef(CXCursor C) {
987 assert(C.kind == CXCursor_ObjCProtocolRef);
988 return std::make_pair(x: static_cast<const ObjCProtocolDecl *>(C.data[0]),
989 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
990}
991
992CXCursor cxcursor::MakeCursorObjCClassRef(const ObjCInterfaceDecl *Class,
993 SourceLocation Loc,
994 CXTranslationUnit TU) {
995 // 'Class' can be null for invalid code.
996 if (!Class)
997 return MakeCXCursorInvalid(K: CXCursor_InvalidCode);
998 assert(TU && "Invalid arguments!");
999 void *RawLoc = Loc.getPtrEncoding();
1000 CXCursor C = {.kind: CXCursor_ObjCClassRef, .xdata: 0, .data: {Class, RawLoc, TU}};
1001 return C;
1002}
1003
1004std::pair<const ObjCInterfaceDecl *, SourceLocation>
1005cxcursor::getCursorObjCClassRef(CXCursor C) {
1006 assert(C.kind == CXCursor_ObjCClassRef);
1007 return std::make_pair(x: static_cast<const ObjCInterfaceDecl *>(C.data[0]),
1008 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1009}
1010
1011CXCursor cxcursor::MakeCursorTypeRef(const TypeDecl *Type, SourceLocation Loc,
1012 CXTranslationUnit TU) {
1013 assert(Type && TU && "Invalid arguments!");
1014 void *RawLoc = Loc.getPtrEncoding();
1015 CXCursor C = {.kind: CXCursor_TypeRef, .xdata: 0, .data: {Type, RawLoc, TU}};
1016 return C;
1017}
1018
1019std::pair<const TypeDecl *, SourceLocation>
1020cxcursor::getCursorTypeRef(CXCursor C) {
1021 assert(C.kind == CXCursor_TypeRef);
1022 return std::make_pair(x: static_cast<const TypeDecl *>(C.data[0]),
1023 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1024}
1025
1026CXCursor cxcursor::MakeCursorTemplateRef(const TemplateDecl *Template,
1027 SourceLocation Loc,
1028 CXTranslationUnit TU) {
1029 assert(Template && TU && "Invalid arguments!");
1030 void *RawLoc = Loc.getPtrEncoding();
1031 CXCursor C = {.kind: CXCursor_TemplateRef, .xdata: 0, .data: {Template, RawLoc, TU}};
1032 return C;
1033}
1034
1035std::pair<const TemplateDecl *, SourceLocation>
1036cxcursor::getCursorTemplateRef(CXCursor C) {
1037 assert(C.kind == CXCursor_TemplateRef);
1038 return std::make_pair(x: static_cast<const TemplateDecl *>(C.data[0]),
1039 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1040}
1041
1042CXCursor cxcursor::MakeCursorNamespaceRef(const NamedDecl *NS,
1043 SourceLocation Loc,
1044 CXTranslationUnit TU) {
1045
1046 assert(NS && (isa<NamespaceDecl>(NS) || isa<NamespaceAliasDecl>(NS)) && TU &&
1047 "Invalid arguments!");
1048 void *RawLoc = Loc.getPtrEncoding();
1049 CXCursor C = {.kind: CXCursor_NamespaceRef, .xdata: 0, .data: {NS, RawLoc, TU}};
1050 return C;
1051}
1052
1053std::pair<const NamedDecl *, SourceLocation>
1054cxcursor::getCursorNamespaceRef(CXCursor C) {
1055 assert(C.kind == CXCursor_NamespaceRef);
1056 return std::make_pair(x: static_cast<const NamedDecl *>(C.data[0]),
1057 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1058}
1059
1060CXCursor cxcursor::MakeCursorVariableRef(const VarDecl *Var, SourceLocation Loc,
1061 CXTranslationUnit TU) {
1062
1063 assert(Var && TU && "Invalid arguments!");
1064 void *RawLoc = Loc.getPtrEncoding();
1065 CXCursor C = {.kind: CXCursor_VariableRef, .xdata: 0, .data: {Var, RawLoc, TU}};
1066 return C;
1067}
1068
1069std::pair<const VarDecl *, SourceLocation>
1070cxcursor::getCursorVariableRef(CXCursor C) {
1071 assert(C.kind == CXCursor_VariableRef);
1072 return std::make_pair(x: static_cast<const VarDecl *>(C.data[0]),
1073 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1074}
1075
1076CXCursor cxcursor::MakeCursorMemberRef(const FieldDecl *Field,
1077 SourceLocation Loc,
1078 CXTranslationUnit TU) {
1079
1080 assert(Field && TU && "Invalid arguments!");
1081 void *RawLoc = Loc.getPtrEncoding();
1082 CXCursor C = {.kind: CXCursor_MemberRef, .xdata: 0, .data: {Field, RawLoc, TU}};
1083 return C;
1084}
1085
1086std::pair<const FieldDecl *, SourceLocation>
1087cxcursor::getCursorMemberRef(CXCursor C) {
1088 assert(C.kind == CXCursor_MemberRef);
1089 return std::make_pair(x: static_cast<const FieldDecl *>(C.data[0]),
1090 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1091}
1092
1093CXCursor cxcursor::MakeCursorCXXBaseSpecifier(const CXXBaseSpecifier *B,
1094 CXTranslationUnit TU) {
1095 CXCursor C = {.kind: CXCursor_CXXBaseSpecifier, .xdata: 0, .data: {B, nullptr, TU}};
1096 return C;
1097}
1098
1099const CXXBaseSpecifier *cxcursor::getCursorCXXBaseSpecifier(CXCursor C) {
1100 assert(C.kind == CXCursor_CXXBaseSpecifier);
1101 return static_cast<const CXXBaseSpecifier *>(C.data[0]);
1102}
1103
1104CXCursor cxcursor::MakePreprocessingDirectiveCursor(SourceRange Range,
1105 CXTranslationUnit TU) {
1106 CXCursor C = {
1107 .kind: CXCursor_PreprocessingDirective,
1108 .xdata: 0,
1109 .data: {Range.getBegin().getPtrEncoding(), Range.getEnd().getPtrEncoding(), TU}};
1110 return C;
1111}
1112
1113SourceRange cxcursor::getCursorPreprocessingDirective(CXCursor C) {
1114 assert(C.kind == CXCursor_PreprocessingDirective);
1115 SourceRange Range(SourceLocation::getFromPtrEncoding(Encoding: C.data[0]),
1116 SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1117 ASTUnit *TU = getCursorASTUnit(Cursor: C);
1118 return TU->mapRangeFromPreamble(R: Range);
1119}
1120
1121CXCursor cxcursor::MakeMacroDefinitionCursor(const MacroDefinitionRecord *MI,
1122 CXTranslationUnit TU) {
1123 CXCursor C = {.kind: CXCursor_MacroDefinition, .xdata: 0, .data: {MI, nullptr, TU}};
1124 return C;
1125}
1126
1127const MacroDefinitionRecord *cxcursor::getCursorMacroDefinition(CXCursor C) {
1128 assert(C.kind == CXCursor_MacroDefinition);
1129 return static_cast<const MacroDefinitionRecord *>(C.data[0]);
1130}
1131
1132CXCursor cxcursor::MakeMacroExpansionCursor(MacroExpansion *MI,
1133 CXTranslationUnit TU) {
1134 CXCursor C = {.kind: CXCursor_MacroExpansion, .xdata: 0, .data: {MI, nullptr, TU}};
1135 return C;
1136}
1137
1138CXCursor cxcursor::MakeMacroExpansionCursor(MacroDefinitionRecord *MI,
1139 SourceLocation Loc,
1140 CXTranslationUnit TU) {
1141 assert(Loc.isValid());
1142 CXCursor C = {.kind: CXCursor_MacroExpansion, .xdata: 0, .data: {MI, Loc.getPtrEncoding(), TU}};
1143 return C;
1144}
1145
1146const IdentifierInfo *cxcursor::MacroExpansionCursor::getName() const {
1147 if (isPseudo())
1148 return getAsMacroDefinition()->getName();
1149 return getAsMacroExpansion()->getName();
1150}
1151const MacroDefinitionRecord *
1152cxcursor::MacroExpansionCursor::getDefinition() const {
1153 if (isPseudo())
1154 return getAsMacroDefinition();
1155 return getAsMacroExpansion()->getDefinition();
1156}
1157SourceRange cxcursor::MacroExpansionCursor::getSourceRange() const {
1158 if (isPseudo())
1159 return getPseudoLoc();
1160 return getAsMacroExpansion()->getSourceRange();
1161}
1162
1163CXCursor cxcursor::MakeInclusionDirectiveCursor(InclusionDirective *ID,
1164 CXTranslationUnit TU) {
1165 CXCursor C = {.kind: CXCursor_InclusionDirective, .xdata: 0, .data: {ID, nullptr, TU}};
1166 return C;
1167}
1168
1169const InclusionDirective *cxcursor::getCursorInclusionDirective(CXCursor C) {
1170 assert(C.kind == CXCursor_InclusionDirective);
1171 return static_cast<const InclusionDirective *>(C.data[0]);
1172}
1173
1174CXCursor cxcursor::MakeCursorLabelRef(LabelStmt *Label, SourceLocation Loc,
1175 CXTranslationUnit TU) {
1176
1177 assert(Label && TU && "Invalid arguments!");
1178 void *RawLoc = Loc.getPtrEncoding();
1179 CXCursor C = {.kind: CXCursor_LabelRef, .xdata: 0, .data: {Label, RawLoc, TU}};
1180 return C;
1181}
1182
1183std::pair<const LabelStmt *, SourceLocation>
1184cxcursor::getCursorLabelRef(CXCursor C) {
1185 assert(C.kind == CXCursor_LabelRef);
1186 return std::make_pair(x: static_cast<const LabelStmt *>(C.data[0]),
1187 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1188}
1189
1190CXCursor cxcursor::MakeCursorOverloadedDeclRef(const OverloadExpr *E,
1191 CXTranslationUnit TU) {
1192 assert(E && TU && "Invalid arguments!");
1193 OverloadedDeclRefStorage Storage(E);
1194 void *RawLoc = E->getNameLoc().getPtrEncoding();
1195 CXCursor C = {
1196 .kind: CXCursor_OverloadedDeclRef, .xdata: 0, .data: {Storage.getOpaqueValue(), RawLoc, TU}};
1197 return C;
1198}
1199
1200CXCursor cxcursor::MakeCursorOverloadedDeclRef(const Decl *D,
1201 SourceLocation Loc,
1202 CXTranslationUnit TU) {
1203 assert(D && TU && "Invalid arguments!");
1204 void *RawLoc = Loc.getPtrEncoding();
1205 OverloadedDeclRefStorage Storage(D);
1206 CXCursor C = {
1207 .kind: CXCursor_OverloadedDeclRef, .xdata: 0, .data: {Storage.getOpaqueValue(), RawLoc, TU}};
1208 return C;
1209}
1210
1211CXCursor cxcursor::MakeCursorOverloadedDeclRef(TemplateName Name,
1212 SourceLocation Loc,
1213 CXTranslationUnit TU) {
1214 assert(Name.getAsOverloadedTemplate() && TU && "Invalid arguments!");
1215 void *RawLoc = Loc.getPtrEncoding();
1216 OverloadedDeclRefStorage Storage(Name.getAsOverloadedTemplate());
1217 CXCursor C = {
1218 .kind: CXCursor_OverloadedDeclRef, .xdata: 0, .data: {Storage.getOpaqueValue(), RawLoc, TU}};
1219 return C;
1220}
1221
1222std::pair<cxcursor::OverloadedDeclRefStorage, SourceLocation>
1223cxcursor::getCursorOverloadedDeclRef(CXCursor C) {
1224 assert(C.kind == CXCursor_OverloadedDeclRef);
1225 return std::make_pair(x: OverloadedDeclRefStorage::getFromOpaqueValue(
1226 VP: const_cast<void *>(C.data[0])),
1227 y: SourceLocation::getFromPtrEncoding(Encoding: C.data[1]));
1228}
1229
1230const Decl *cxcursor::getCursorDecl(CXCursor Cursor) {
1231 return static_cast<const Decl *>(Cursor.data[0]);
1232}
1233
1234const Expr *cxcursor::getCursorExpr(CXCursor Cursor) {
1235 return dyn_cast_or_null<Expr>(Val: getCursorStmt(Cursor));
1236}
1237
1238const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
1239 if (Cursor.kind == CXCursor_ObjCSuperClassRef ||
1240 Cursor.kind == CXCursor_ObjCProtocolRef ||
1241 Cursor.kind == CXCursor_ObjCClassRef)
1242 return nullptr;
1243
1244 return static_cast<const Stmt *>(Cursor.data[1]);
1245}
1246
1247const Attr *cxcursor::getCursorAttr(CXCursor Cursor) {
1248 return static_cast<const Attr *>(Cursor.data[1]);
1249}
1250
1251ASTContext &cxcursor::getCursorContext(CXCursor Cursor) {
1252 return getCursorASTUnit(Cursor)->getASTContext();
1253}
1254
1255ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
1256 CXTranslationUnit TU = getCursorTU(Cursor);
1257 if (!TU)
1258 return nullptr;
1259 return cxtu::getASTUnit(TU);
1260}
1261
1262CXTranslationUnit cxcursor::getCursorTU(CXCursor Cursor) {
1263 return static_cast<CXTranslationUnit>(const_cast<void *>(Cursor.data[2]));
1264}
1265
1266void cxcursor::getOverriddenCursors(CXCursor cursor,
1267 SmallVectorImpl<CXCursor> &overridden) {
1268 assert(clang_isDeclaration(cursor.kind));
1269 const NamedDecl *D = dyn_cast_or_null<NamedDecl>(Val: getCursorDecl(Cursor: cursor));
1270 if (!D)
1271 return;
1272
1273 CXTranslationUnit TU = getCursorTU(Cursor: cursor);
1274 SmallVector<const NamedDecl *, 8> OverDecls;
1275 D->getASTContext().getOverriddenMethods(Method: D, Overridden&: OverDecls);
1276
1277 for (SmallVectorImpl<const NamedDecl *>::iterator I = OverDecls.begin(),
1278 E = OverDecls.end();
1279 I != E; ++I) {
1280 overridden.push_back(Elt: MakeCXCursor(D: *I, TU));
1281 }
1282}
1283
1284std::pair<int, SourceLocation>
1285cxcursor::getSelectorIdentifierIndexAndLoc(CXCursor cursor) {
1286 if (cursor.kind == CXCursor_ObjCMessageExpr) {
1287 if (cursor.xdata != -1)
1288 return std::make_pair(x&: cursor.xdata,
1289 y: cast<ObjCMessageExpr>(Val: getCursorExpr(Cursor: cursor))
1290 ->getSelectorLoc(Index: cursor.xdata));
1291 } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
1292 cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
1293 if (cursor.xdata != -1)
1294 return std::make_pair(x&: cursor.xdata,
1295 y: cast<ObjCMethodDecl>(Val: getCursorDecl(Cursor: cursor))
1296 ->getSelectorLoc(Index: cursor.xdata));
1297 }
1298
1299 return std::make_pair(x: -1, y: SourceLocation());
1300}
1301
1302CXCursor cxcursor::getSelectorIdentifierCursor(int SelIdx, CXCursor cursor) {
1303 CXCursor newCursor = cursor;
1304
1305 if (cursor.kind == CXCursor_ObjCMessageExpr) {
1306 if (SelIdx == -1 ||
1307 unsigned(SelIdx) >=
1308 cast<ObjCMessageExpr>(Val: getCursorExpr(Cursor: cursor))->getNumSelectorLocs())
1309 newCursor.xdata = -1;
1310 else
1311 newCursor.xdata = SelIdx;
1312 } else if (cursor.kind == CXCursor_ObjCClassMethodDecl ||
1313 cursor.kind == CXCursor_ObjCInstanceMethodDecl) {
1314 if (SelIdx == -1 ||
1315 unsigned(SelIdx) >=
1316 cast<ObjCMethodDecl>(Val: getCursorDecl(Cursor: cursor))->getNumSelectorLocs())
1317 newCursor.xdata = -1;
1318 else
1319 newCursor.xdata = SelIdx;
1320 }
1321
1322 return newCursor;
1323}
1324
1325CXCursor cxcursor::getTypeRefCursor(CXCursor cursor) {
1326 if (cursor.kind != CXCursor_CallExpr)
1327 return cursor;
1328
1329 if (cursor.xdata == 0)
1330 return cursor;
1331
1332 const Expr *E = getCursorExpr(Cursor: cursor);
1333 TypeSourceInfo *Type = nullptr;
1334 if (const CXXUnresolvedConstructExpr *UnCtor =
1335 dyn_cast<CXXUnresolvedConstructExpr>(Val: E)) {
1336 Type = UnCtor->getTypeSourceInfo();
1337 } else if (const CXXTemporaryObjectExpr *Tmp =
1338 dyn_cast<CXXTemporaryObjectExpr>(Val: E)) {
1339 Type = Tmp->getTypeSourceInfo();
1340 }
1341
1342 if (!Type)
1343 return cursor;
1344
1345 CXTranslationUnit TU = getCursorTU(Cursor: cursor);
1346 QualType Ty = Type->getType();
1347 TypeLoc TL = Type->getTypeLoc();
1348 SourceLocation Loc = TL.getBeginLoc();
1349
1350 if (const TypedefType *Typedef = Ty->getAs<TypedefType>())
1351 return MakeCursorTypeRef(Type: Typedef->getDecl(), Loc, TU);
1352 if (const TagType *Tag = Ty->getAs<TagType>())
1353 return MakeCursorTypeRef(Type: Tag->getDecl(), Loc, TU);
1354 if (const TemplateTypeParmType *TemplP = Ty->getAs<TemplateTypeParmType>())
1355 return MakeCursorTypeRef(Type: TemplP->getDecl(), Loc, TU);
1356
1357 return cursor;
1358}
1359
1360bool cxcursor::operator==(CXCursor X, CXCursor Y) {
1361 return X.kind == Y.kind && X.data[0] == Y.data[0] && X.data[1] == Y.data[1] &&
1362 X.data[2] == Y.data[2];
1363}
1364
1365// FIXME: Remove once we can model DeclGroups and their appropriate ranges
1366// properly in the ASTs.
1367bool cxcursor::isFirstInDeclGroup(CXCursor C) {
1368 assert(clang_isDeclaration(C.kind));
1369 return ((uintptr_t)(C.data[1])) != 0;
1370}
1371
1372//===----------------------------------------------------------------------===//
1373// libclang CXCursor APIs
1374//===----------------------------------------------------------------------===//
1375
1376int clang_Cursor_isNull(CXCursor cursor) {
1377 return clang_equalCursors(cursor, clang_getNullCursor());
1378}
1379
1380CXTranslationUnit clang_Cursor_getTranslationUnit(CXCursor cursor) {
1381 return getCursorTU(Cursor: cursor);
1382}
1383
1384int clang_Cursor_getNumArguments(CXCursor C) {
1385 if (clang_isDeclaration(C.kind)) {
1386 const Decl *D = cxcursor::getCursorDecl(Cursor: C);
1387 if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Val: D))
1388 return MD->param_size();
1389 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Val: D))
1390 return FD->param_size();
1391 }
1392
1393 if (clang_isExpression(C.kind)) {
1394 const Expr *E = cxcursor::getCursorExpr(Cursor: C);
1395 if (const CallExpr *CE = dyn_cast<CallExpr>(Val: E)) {
1396 return CE->getNumArgs();
1397 }
1398 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Val: E)) {
1399 return CE->getNumArgs();
1400 }
1401 }
1402
1403 return -1;
1404}
1405
1406CXCursor clang_Cursor_getArgument(CXCursor C, unsigned i) {
1407 if (clang_isDeclaration(C.kind)) {
1408 const Decl *D = cxcursor::getCursorDecl(Cursor: C);
1409 if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Val: D)) {
1410 if (i < MD->param_size())
1411 return cxcursor::MakeCXCursor(D: MD->parameters()[i],
1412 TU: cxcursor::getCursorTU(Cursor: C));
1413 } else if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Val: D)) {
1414 if (i < FD->param_size())
1415 return cxcursor::MakeCXCursor(D: FD->parameters()[i],
1416 TU: cxcursor::getCursorTU(Cursor: C));
1417 }
1418 }
1419
1420 if (clang_isExpression(C.kind)) {
1421 const Expr *E = cxcursor::getCursorExpr(Cursor: C);
1422 if (const CallExpr *CE = dyn_cast<CallExpr>(Val: E)) {
1423 if (i < CE->getNumArgs()) {
1424 return cxcursor::MakeCXCursor(S: CE->getArg(Arg: i), Parent: getCursorDecl(Cursor: C),
1425 TU: cxcursor::getCursorTU(Cursor: C));
1426 }
1427 }
1428 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Val: E)) {
1429 if (i < CE->getNumArgs()) {
1430 return cxcursor::MakeCXCursor(S: CE->getArg(Arg: i), Parent: getCursorDecl(Cursor: C),
1431 TU: cxcursor::getCursorTU(Cursor: C));
1432 }
1433 }
1434 }
1435
1436 return clang_getNullCursor();
1437}
1438
1439int clang_Cursor_getNumTemplateArguments(CXCursor C) {
1440 CXCursorKind kind = clang_getCursorKind(C);
1441 if (kind != CXCursor_FunctionDecl && kind != CXCursor_StructDecl &&
1442 kind != CXCursor_ClassDecl &&
1443 kind != CXCursor_ClassTemplatePartialSpecialization) {
1444 return -1;
1445 }
1446
1447 if (const auto *FD =
1448 llvm::dyn_cast_if_present<clang::FunctionDecl>(Val: getCursorDecl(Cursor: C))) {
1449 const FunctionTemplateSpecializationInfo *SpecInfo =
1450 FD->getTemplateSpecializationInfo();
1451 if (!SpecInfo) {
1452 return -1;
1453 }
1454 return SpecInfo->TemplateArguments->size();
1455 }
1456
1457 if (const auto *SD =
1458 llvm::dyn_cast_if_present<clang::ClassTemplateSpecializationDecl>(
1459 Val: getCursorDecl(Cursor: C))) {
1460 return SD->getTemplateArgs().size();
1461 }
1462
1463 return -1;
1464}
1465
1466enum CXGetTemplateArgumentStatus {
1467 /** The operation completed successfully */
1468 CXGetTemplateArgumentStatus_Success = 0,
1469
1470 /** The specified cursor did not represent a FunctionDecl or
1471 ClassTemplateSpecializationDecl. */
1472 CXGetTemplateArgumentStatus_CursorNotCompatibleDecl = -1,
1473
1474 /** The specified cursor was not castable to a FunctionDecl or
1475 ClassTemplateSpecializationDecl. */
1476 CXGetTemplateArgumentStatus_BadDeclCast = -2,
1477
1478 /** A NULL FunctionTemplateSpecializationInfo was retrieved. */
1479 CXGetTemplateArgumentStatus_NullTemplSpecInfo = -3,
1480
1481 /** An invalid (OOB) argument index was specified */
1482 CXGetTemplateArgumentStatus_InvalidIndex = -4
1483};
1484
1485static int clang_Cursor_getTemplateArgument(CXCursor C, unsigned I,
1486 TemplateArgument *TA) {
1487 CXCursorKind kind = clang_getCursorKind(C);
1488 if (kind != CXCursor_FunctionDecl && kind != CXCursor_StructDecl &&
1489 kind != CXCursor_ClassDecl &&
1490 kind != CXCursor_ClassTemplatePartialSpecialization) {
1491 return -1;
1492 }
1493
1494 if (const auto *FD =
1495 llvm::dyn_cast_if_present<clang::FunctionDecl>(Val: getCursorDecl(Cursor: C))) {
1496
1497 const FunctionTemplateSpecializationInfo *SpecInfo =
1498 FD->getTemplateSpecializationInfo();
1499 if (!SpecInfo) {
1500 return CXGetTemplateArgumentStatus_NullTemplSpecInfo;
1501 }
1502
1503 if (I >= SpecInfo->TemplateArguments->size()) {
1504 return CXGetTemplateArgumentStatus_InvalidIndex;
1505 }
1506
1507 *TA = SpecInfo->TemplateArguments->get(Idx: I);
1508 return 0;
1509 }
1510
1511 if (const auto *SD =
1512 llvm::dyn_cast_if_present<clang::ClassTemplateSpecializationDecl>(
1513 Val: getCursorDecl(Cursor: C))) {
1514 if (I >= SD->getTemplateArgs().size()) {
1515 return CXGetTemplateArgumentStatus_InvalidIndex;
1516 }
1517
1518 *TA = SD->getTemplateArgs()[I];
1519 return 0;
1520 }
1521
1522 return CXGetTemplateArgumentStatus_BadDeclCast;
1523}
1524
1525enum CXTemplateArgumentKind clang_Cursor_getTemplateArgumentKind(CXCursor C,
1526 unsigned I) {
1527 TemplateArgument TA;
1528 if (clang_Cursor_getTemplateArgument(C, I, TA: &TA)) {
1529 return CXTemplateArgumentKind_Invalid;
1530 }
1531
1532 switch (TA.getKind()) {
1533 case TemplateArgument::Null:
1534 return CXTemplateArgumentKind_Null;
1535 case TemplateArgument::Type:
1536 return CXTemplateArgumentKind_Type;
1537 case TemplateArgument::Declaration:
1538 return CXTemplateArgumentKind_Declaration;
1539 case TemplateArgument::NullPtr:
1540 return CXTemplateArgumentKind_NullPtr;
1541 case TemplateArgument::Integral:
1542 return CXTemplateArgumentKind_Integral;
1543 case TemplateArgument::StructuralValue:
1544 // FIXME: Expose these values.
1545 return CXTemplateArgumentKind_Invalid;
1546 case TemplateArgument::Template:
1547 return CXTemplateArgumentKind_Template;
1548 case TemplateArgument::TemplateExpansion:
1549 return CXTemplateArgumentKind_TemplateExpansion;
1550 case TemplateArgument::Expression:
1551 return CXTemplateArgumentKind_Expression;
1552 case TemplateArgument::Pack:
1553 return CXTemplateArgumentKind_Pack;
1554 }
1555
1556 return CXTemplateArgumentKind_Invalid;
1557}
1558
1559CXType clang_Cursor_getTemplateArgumentType(CXCursor C, unsigned I) {
1560 TemplateArgument TA;
1561 if (clang_Cursor_getTemplateArgument(C, I, TA: &TA) !=
1562 CXGetTemplateArgumentStatus_Success) {
1563 return cxtype::MakeCXType(T: QualType(), TU: getCursorTU(Cursor: C));
1564 }
1565
1566 if (TA.getKind() != TemplateArgument::Type) {
1567 return cxtype::MakeCXType(T: QualType(), TU: getCursorTU(Cursor: C));
1568 }
1569
1570 return cxtype::MakeCXType(T: TA.getAsType(), TU: getCursorTU(Cursor: C));
1571}
1572
1573long long clang_Cursor_getTemplateArgumentValue(CXCursor C, unsigned I) {
1574 TemplateArgument TA;
1575 if (clang_Cursor_getTemplateArgument(C, I, TA: &TA) !=
1576 CXGetTemplateArgumentStatus_Success) {
1577 assert(0 && "Unable to retrieve TemplateArgument");
1578 return 0;
1579 }
1580
1581 if (TA.getKind() != TemplateArgument::Integral) {
1582 assert(0 && "Passed template argument is not Integral");
1583 return 0;
1584 }
1585
1586 return TA.getAsIntegral().getSExtValue();
1587}
1588
1589unsigned long long clang_Cursor_getTemplateArgumentUnsignedValue(CXCursor C,
1590 unsigned I) {
1591 TemplateArgument TA;
1592 if (clang_Cursor_getTemplateArgument(C, I, TA: &TA) !=
1593 CXGetTemplateArgumentStatus_Success) {
1594 assert(0 && "Unable to retrieve TemplateArgument");
1595 return 0;
1596 }
1597
1598 if (TA.getKind() != TemplateArgument::Integral) {
1599 assert(0 && "Passed template argument is not Integral");
1600 return 0;
1601 }
1602
1603 return TA.getAsIntegral().getZExtValue();
1604}
1605
1606//===----------------------------------------------------------------------===//
1607// CXCursorSet.
1608//===----------------------------------------------------------------------===//
1609
1610typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;
1611
1612static inline CXCursorSet packCXCursorSet(CXCursorSet_Impl *setImpl) {
1613 return (CXCursorSet)setImpl;
1614}
1615static inline CXCursorSet_Impl *unpackCXCursorSet(CXCursorSet set) {
1616 return (CXCursorSet_Impl *)set;
1617}
1618namespace llvm {
1619template <> struct DenseMapInfo<CXCursor> {
1620public:
1621 static inline CXCursor getEmptyKey() {
1622 return MakeCXCursorInvalid(K: CXCursor_InvalidFile);
1623 }
1624 static inline CXCursor getTombstoneKey() {
1625 return MakeCXCursorInvalid(K: CXCursor_NoDeclFound);
1626 }
1627 static inline unsigned getHashValue(const CXCursor &cursor) {
1628 return llvm::DenseMapInfo<std::pair<const void *, const void *>>::
1629 getHashValue(PairVal: std::make_pair(x: cursor.data[0], y: cursor.data[1]));
1630 }
1631 static inline bool isEqual(const CXCursor &x, const CXCursor &y) {
1632 return x.kind == y.kind && x.data[0] == y.data[0] && x.data[1] == y.data[1];
1633 }
1634};
1635} // namespace llvm
1636
1637CXCursorSet clang_createCXCursorSet() {
1638 return packCXCursorSet(setImpl: new CXCursorSet_Impl());
1639}
1640
1641void clang_disposeCXCursorSet(CXCursorSet set) {
1642 delete unpackCXCursorSet(set);
1643}
1644
1645unsigned clang_CXCursorSet_contains(CXCursorSet set, CXCursor cursor) {
1646 CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1647 if (!setImpl)
1648 return 0;
1649 return setImpl->contains(Val: cursor);
1650}
1651
1652unsigned clang_CXCursorSet_insert(CXCursorSet set, CXCursor cursor) {
1653 // Do not insert invalid cursors into the set.
1654 if (cursor.kind >= CXCursor_FirstInvalid &&
1655 cursor.kind <= CXCursor_LastInvalid)
1656 return 1;
1657
1658 CXCursorSet_Impl *setImpl = unpackCXCursorSet(set);
1659 if (!setImpl)
1660 return 1;
1661 unsigned &entry = (*setImpl)[cursor];
1662 unsigned flag = entry == 0 ? 1 : 0;
1663 entry = 1;
1664 return flag;
1665}
1666
1667CXCompletionString clang_getCursorCompletionString(CXCursor cursor) {
1668 enum CXCursorKind kind = clang_getCursorKind(cursor);
1669 if (clang_isDeclaration(kind)) {
1670 const Decl *decl = getCursorDecl(Cursor: cursor);
1671 if (const NamedDecl *namedDecl = dyn_cast_or_null<NamedDecl>(Val: decl)) {
1672 ASTUnit *unit = getCursorASTUnit(Cursor: cursor);
1673 CodeCompletionResult Result(namedDecl, CCP_Declaration);
1674 CodeCompletionString *String = Result.CreateCodeCompletionString(
1675 Ctx&: unit->getASTContext(), PP&: unit->getPreprocessor(),
1676 CCContext: CodeCompletionContext::CCC_Other,
1677 Allocator&: unit->getCodeCompletionTUInfo().getAllocator(),
1678 CCTUInfo&: unit->getCodeCompletionTUInfo(), IncludeBriefComments: true);
1679 return String;
1680 }
1681 } else if (kind == CXCursor_MacroDefinition) {
1682 const MacroDefinitionRecord *definition = getCursorMacroDefinition(C: cursor);
1683 const IdentifierInfo *Macro = definition->getName();
1684 ASTUnit *unit = getCursorASTUnit(Cursor: cursor);
1685 CodeCompletionResult Result(
1686 Macro,
1687 unit->getPreprocessor().getMacroDefinition(II: Macro).getMacroInfo());
1688 CodeCompletionString *String = Result.CreateCodeCompletionString(
1689 Ctx&: unit->getASTContext(), PP&: unit->getPreprocessor(),
1690 CCContext: CodeCompletionContext::CCC_Other,
1691 Allocator&: unit->getCodeCompletionTUInfo().getAllocator(),
1692 CCTUInfo&: unit->getCodeCompletionTUInfo(), IncludeBriefComments: false);
1693 return String;
1694 }
1695 return nullptr;
1696}
1697
1698namespace {
1699struct OverridenCursorsPool {
1700 typedef SmallVector<CXCursor, 2> CursorVec;
1701 std::vector<CursorVec *> AllCursors;
1702 std::vector<CursorVec *> AvailableCursors;
1703
1704 ~OverridenCursorsPool() {
1705 for (std::vector<CursorVec *>::iterator I = AllCursors.begin(),
1706 E = AllCursors.end();
1707 I != E; ++I) {
1708 delete *I;
1709 }
1710 }
1711};
1712} // namespace
1713
1714void *cxcursor::createOverridenCXCursorsPool() {
1715 return new OverridenCursorsPool();
1716}
1717
1718void cxcursor::disposeOverridenCXCursorsPool(void *pool) {
1719 delete static_cast<OverridenCursorsPool *>(pool);
1720}
1721
1722void clang_getOverriddenCursors(CXCursor cursor, CXCursor **overridden,
1723 unsigned *num_overridden) {
1724 if (overridden)
1725 *overridden = nullptr;
1726 if (num_overridden)
1727 *num_overridden = 0;
1728
1729 CXTranslationUnit TU = cxcursor::getCursorTU(Cursor: cursor);
1730
1731 if (!overridden || !num_overridden || !TU)
1732 return;
1733
1734 if (!clang_isDeclaration(cursor.kind))
1735 return;
1736
1737 OverridenCursorsPool &pool =
1738 *static_cast<OverridenCursorsPool *>(TU->OverridenCursorsPool);
1739
1740 OverridenCursorsPool::CursorVec *Vec = nullptr;
1741
1742 if (!pool.AvailableCursors.empty()) {
1743 Vec = pool.AvailableCursors.back();
1744 pool.AvailableCursors.pop_back();
1745 } else {
1746 Vec = new OverridenCursorsPool::CursorVec();
1747 pool.AllCursors.push_back(x: Vec);
1748 }
1749
1750 // Clear out the vector, but don't free the memory contents. This
1751 // reduces malloc() traffic.
1752 Vec->clear();
1753
1754 // Use the first entry to contain a back reference to the vector.
1755 // This is a complete hack.
1756 CXCursor backRefCursor = MakeCXCursorInvalid(K: CXCursor_InvalidFile, TU);
1757 backRefCursor.data[0] = Vec;
1758 assert(cxcursor::getCursorTU(backRefCursor) == TU);
1759 Vec->push_back(Elt: backRefCursor);
1760
1761 // Get the overridden cursors.
1762 cxcursor::getOverriddenCursors(cursor, overridden&: *Vec);
1763
1764 // Did we get any overridden cursors? If not, return Vec to the pool
1765 // of available cursor vectors.
1766 if (Vec->size() == 1) {
1767 pool.AvailableCursors.push_back(x: Vec);
1768 return;
1769 }
1770
1771 // Now tell the caller about the overridden cursors.
1772 assert(Vec->size() > 1);
1773 *overridden = &((*Vec)[1]);
1774 *num_overridden = Vec->size() - 1;
1775}
1776
1777void clang_disposeOverriddenCursors(CXCursor *overridden) {
1778 if (!overridden)
1779 return;
1780
1781 // Use pointer arithmetic to get back the first faux entry
1782 // which has a back-reference to the TU and the vector.
1783 --overridden;
1784 OverridenCursorsPool::CursorVec *Vec =
1785 static_cast<OverridenCursorsPool::CursorVec *>(
1786 const_cast<void *>(overridden->data[0]));
1787 CXTranslationUnit TU = getCursorTU(Cursor: *overridden);
1788
1789 assert(Vec && TU);
1790
1791 OverridenCursorsPool &pool =
1792 *static_cast<OverridenCursorsPool *>(TU->OverridenCursorsPool);
1793
1794 pool.AvailableCursors.push_back(x: Vec);
1795}
1796
1797int clang_Cursor_isDynamicCall(CXCursor C) {
1798 const Expr *E = nullptr;
1799 if (clang_isExpression(C.kind))
1800 E = getCursorExpr(Cursor: C);
1801 if (!E)
1802 return 0;
1803
1804 if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(Val: E)) {
1805 if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance)
1806 return false;
1807 if (auto *RecE = dyn_cast<ObjCMessageExpr>(
1808 Val: MsgE->getInstanceReceiver()->IgnoreParenCasts())) {
1809 if (RecE->getMethodFamily() == OMF_alloc)
1810 return false;
1811 }
1812 return true;
1813 }
1814
1815 if (auto *PropRefE = dyn_cast<ObjCPropertyRefExpr>(Val: E)) {
1816 return !PropRefE->isSuperReceiver();
1817 }
1818
1819 const MemberExpr *ME = nullptr;
1820 if (isa<MemberExpr>(Val: E))
1821 ME = cast<MemberExpr>(Val: E);
1822 else if (const CallExpr *CE = dyn_cast<CallExpr>(Val: E))
1823 ME = dyn_cast_or_null<MemberExpr>(Val: CE->getCallee());
1824
1825 if (ME) {
1826 if (const CXXMethodDecl *MD =
1827 dyn_cast_or_null<CXXMethodDecl>(Val: ME->getMemberDecl()))
1828 return MD->isVirtual() &&
1829 ME->performsVirtualDispatch(
1830 LO: cxcursor::getCursorContext(Cursor: C).getLangOpts());
1831 }
1832
1833 return 0;
1834}
1835
1836CXType clang_Cursor_getReceiverType(CXCursor C) {
1837 CXTranslationUnit TU = cxcursor::getCursorTU(Cursor: C);
1838 const Expr *E = nullptr;
1839 if (clang_isExpression(C.kind))
1840 E = getCursorExpr(Cursor: C);
1841
1842 if (const ObjCMessageExpr *MsgE = dyn_cast_or_null<ObjCMessageExpr>(Val: E))
1843 return cxtype::MakeCXType(T: MsgE->getReceiverType(), TU);
1844
1845 if (auto *PropRefE = dyn_cast<ObjCPropertyRefExpr>(Val: E)) {
1846 return cxtype::MakeCXType(
1847 T: PropRefE->getReceiverType(ctx: cxcursor::getCursorContext(Cursor: C)), TU);
1848 }
1849
1850 const MemberExpr *ME = nullptr;
1851 if (isa<MemberExpr>(Val: E))
1852 ME = cast<MemberExpr>(Val: E);
1853 else if (const CallExpr *CE = dyn_cast<CallExpr>(Val: E))
1854 ME = dyn_cast_or_null<MemberExpr>(Val: CE->getCallee());
1855
1856 if (ME) {
1857 if (isa_and_nonnull<CXXMethodDecl>(Val: ME->getMemberDecl())) {
1858 auto receiverTy = ME->getBase()->IgnoreImpCasts()->getType();
1859 return cxtype::MakeCXType(T: receiverTy, TU);
1860 }
1861 }
1862
1863 return cxtype::MakeCXType(T: QualType(), TU);
1864}
1865