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