DeclBase.cpp Source File (original) (raw)

37#include "llvm/ADT/PointerIntPair.h"

38#include "llvm/ADT/StringRef.h"

39#include "llvm/Support/ErrorHandling.h"

40#include "llvm/Support/MathExtras.h"

41#include "llvm/Support/VersionTuple.h"

42#include "llvm/Support/raw_ostream.h"

43#include

44#include

45#include

46#include

47#include

48#include

50using namespace clang;

56#define DECL(DERIVED, BASE) static int n##DERIVED##s = 0;

57#define ABSTRACT_DECL(DECL)

58#include "clang/AST/DeclNodes.inc"

62}

64#define DECL(DERIVED, BASE) \

65 static_assert(alignof(Decl) >= alignof(DERIVED##Decl), \

66 "Alignment sufficient after objects prepended to " #DERIVED);

67#define ABSTRACT_DECL(DECL)

68#include "clang/AST/DeclNodes.inc"

70void *Decl::operator new(std::size_t Size, const ASTContext &Context,

74 static_assert(sizeof(uint64_t) >= alignof(Decl), "Decl won't be misaligned");

75 void *Start = Context.Allocate(Size + Extra + 8);

76 void *Result = (char*)Start + 8;

78 uint64_t *PrefixPtr = (uint64_t *)Result - 1;

80 *PrefixPtr = ID.getRawValue();

84 assert(*PrefixPtr < llvm::maskTrailingOnes<uint64_t>(48));

87}

89void *Decl::operator new(std::size_t Size, const ASTContext &Ctx,

91 assert( Parent || &Parent->getParentASTContext() == &Ctx);

98 size_t ExtraAlign =

99 llvm::offsetToAlignment(sizeof(Module *), llvm::Align(alignof(Decl)));

100 auto *Buffer = reinterpret_cast<char *>(

101 ::operator new(ExtraAlign + sizeof(Module *) + Size + Extra, Ctx));

102 Buffer += ExtraAlign;

103 auto *ParentModule =

104 Parent ? cast(Parent)->getOwningModule() : nullptr;

105 return new (Buffer) Module*(ParentModule) + 1;

106 }

107 return ::operator new(Size + Extra, Ctx);

108}

109

113

114 uint64_t ID = *((const uint64_t *)this - 1);

115 return GlobalDeclID(ID & llvm::maskTrailingOnes<uint64_t>(48));

116}

117

120 return 0;

121

122 uint64_t ID = *((const uint64_t *)this - 1);

123 return ID >> 48;

124}

125

127 assert(isFromASTFile() && "Only works on a deserialized declaration");

128 uint64_t *IDAddress = (uint64_t *)this - 1;

129 *IDAddress &= llvm::maskTrailingOnes<uint64_t>(48);

130 *IDAddress |= (uint64_t)ID << 48;

131}

132

137

138 return nullptr;

139}

140

141Module *Decl::getOwningModuleSlow() const {

144}

145

148}

149

151 switch (DeclKind) {

152 default: llvm_unreachable("Declaration not in DeclNodes.inc!");

153#define DECL(DERIVED, BASE) case DERIVED: return #DERIVED;

154#define ABSTRACT_DECL(DECL)

155#include "clang/AST/DeclNodes.inc"

156 }

157}

158

161 assert(!isa(this) || !cast(this)->isCompleteDefinition());

163 return;

164 }

165

166 if (!isa(this)) {

167

168

169

171 }

172

173

174

175 if (auto *DD = dyn_cast(this)) {

176 for (auto *Binding : DD->bindings()) {

177 Binding->setInvalidDecl();

178 }

179 }

180}

181

184#define DECL(DERIVED, BASE) case Decl::DERIVED: return true;

185#define ABSTRACT_DECL(DECL)

186#include "clang/AST/DeclNodes.inc"

187 }

188 return false;

189}

190

193#define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED;

194#define ABSTRACT_DECL(DECL)

195#include "clang/AST/DeclNodes.inc"

196 }

197 llvm_unreachable("Declaration context not in DeclNodes.inc!");

198}

199

200bool Decl::StatisticsEnabled = false;

202 StatisticsEnabled = true;

203}

204

206 llvm::errs() << "\n*** Decl Stats:\n";

207

208 int totalDecls = 0;

209#define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s;

210#define ABSTRACT_DECL(DECL)

211#include "clang/AST/DeclNodes.inc"

212 llvm::errs() << " " << totalDecls << " decls total.\n";

213

214 int totalBytes = 0;

215#define DECL(DERIVED, BASE) \

216 if (n##DERIVED##s > 0) { \

217 totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl)); \

218 llvm::errs() << " " << n##DERIVED##s << " " #DERIVED " decls, " \

219 << sizeof(DERIVED##Decl) << " each (" \

220 << n##DERIVED##s * sizeof(DERIVED##Decl) \

221 << " bytes)\n"; \

222 }

223#define ABSTRACT_DECL(DECL)

224#include "clang/AST/DeclNodes.inc"

225

226 llvm::errs() << "Total bytes = " << totalBytes << "\n";

227}

228

230 switch (k) {

231#define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break;

232#define ABSTRACT_DECL(DECL)

233#include "clang/AST/DeclNodes.inc"

234 }

235}

236

238 if (const auto *TTP = dyn_cast(this))

239 return TTP->isParameterPack();

240 if (const auto *NTTP = dyn_cast(this))

241 return NTTP->isParameterPack();

242 if (const auto *TTP = dyn_cast(this))

243 return TTP->isParameterPack();

244 return false;

245}

246

248 if (const auto *Var = dyn_cast(this))

249 return Var->isParameterPack();

250

252}

253

255 if (auto *FD = dyn_cast(this))

256 return FD;

257 if (const auto *FTD = dyn_cast(this))

258 return FTD->getTemplatedDecl();

259 return nullptr;

260}

261

263 return isa(this);

264}

265

267 if (auto *FD = dyn_cast(this))

268 return FD->getDescribedFunctionTemplate();

269 if (auto *RD = dyn_cast(this))

270 return RD->getDescribedClassTemplate();

271 if (auto *VD = dyn_cast(this))

272 return VD->getDescribedVarTemplate();

273 if (auto *AD = dyn_cast(this))

274 return AD->getDescribedAliasTemplate();

275

276 return nullptr;

277}

278

281 return TD->getTemplateParameters();

282 if (auto *CTPSD = dyn_cast(this))

283 return CTPSD->getTemplateParameters();

284 if (auto *VTPSD = dyn_cast(this))

285 return VTPSD->getTemplateParameters();

286 return nullptr;

287}

288

290

291

292

293 if (auto *AsDC = dyn_cast(this))

294 return AsDC->isDependentContext();

297 return DC->isDependentContext() || isTemplateDecl() ||

299}

300

302 if (auto *DC = dyn_cast(this))

303 if (DC->isFileContext())

304 return 0;

305

307 return TPL->getDepth() + 1;

308

309

310

311

312 auto *RD = dyn_cast(this);

313 if (RD && RD->isDependentLambda())

314 if (Decl *Context = RD->getLambdaContextDecl())

315 return Context->getTemplateDepth();

316

319 return cast(DC)->getTemplateDepth();

320}

321

325 DC && !DC->isFileContext(); DC = DC->getParent())

326 if (DC->isFunctionOrMethod())

327 return DC;

328

329 return nullptr;

330}

331

332

333

334

335

338 if (TheLoc.isInvalid() && TheDecl)

340

342 TheLoc.print(OS, SM);

343 OS << ": ";

344 }

345

346 OS << Message;

347

348 if (const auto *DN = dyn_cast_or_null(TheDecl)) {

349 OS << " '";

350 DN->printQualifiedName(OS);

351 OS << '\'';

352 }

353 OS << '\n';

354}

355

356

357

358

359

360

362

364 DeclCtx = DC;

365}

366

369 return;

370

371 if (isInSemaDC()) {

373 } else {

374 getMultipleDC()->LexicalDC = DC;

375 }

376

377

378

383 }

384

385 assert(

388 "hidden declaration has no owning module");

389}

390

393 if (SemaDC == LexicalDC) {

394 DeclCtx = SemaDC;

395 } else {

396 auto *MDC = new (Ctx) Decl::MultipleDC();

397 MDC->SemanticDC = SemaDC;

398 MDC->LexicalDC = LexicalDC;

399 DeclCtx = MDC;

400 }

401}

402

406 return false;

407 while (true) {

409 return true;

410 if (!isa(LDC))

411 return false;

412 if (const auto *CRD = dyn_cast(LDC))

413 if (CRD->isLambda())

414 return true;

416 }

417 return false;

418}

419

422 if (const auto *ND = dyn_cast(DC))

423 if (ND->isAnonymousNamespace())

424 return true;

425 }

426

427 return false;

428}

429

433}

434

436 const auto *DC = dyn_cast(this);

437 return DC && DC->isFileContext();

438}

439

443 bool IgnoreTemplateOrMacroSubstitution) {

444

445

447 if (CAT) {

449

450 llvm::APInt Size = CAT->getSize();

451 if (StrictFlexArraysLevel == FAMKind::IncompleteOnly)

452 return false;

453

454

455 if (Size.isZero())

456 return true;

457

458 if (StrictFlexArraysLevel == FAMKind::ZeroOrIncomplete && Size.uge(1))

459 return false;

460

461 if (StrictFlexArraysLevel == FAMKind::OneZeroOrIncomplete && Size.uge(2))

462 return false;

464 return false;

465 }

466

467 if (const auto *OID = dyn_cast_if_present(D))

468 return OID->getNextIvar() == nullptr;

469

470 const auto *FD = dyn_cast_if_present(D);

471 if (!FD)

472 return false;

473

474 if (CAT) {

475

476

477 llvm::APInt Size = CAT->getSize();

478 if (FD->getParent()->isUnion() && (Size.isZero() || Size.isOne()))

479 return true;

480 }

481

482

483

484 if (IgnoreTemplateOrMacroSubstitution) {

486 while (TInfo) {

488

489

493 continue;

494 }

495

497 if (const Expr *SizeExpr =

498 dyn_cast_if_present(CTL.getSizeExpr());

500 return false;

501 }

502

503 break;

504 }

505 }

506

507

510 return ++FI == FD->getParent()->field_end();

511}

512

514 if (auto *TUD = dyn_cast(this))

515 return TUD;

516

518 assert(DC && "This decl is not contained in a translation unit!");

519

522 assert(DC && "This decl is not contained in a translation unit!");

523 }

524

525 return cast(DC);

526}

527

530}

531

532

533

536}

537

540}

541

544 return 0;

545

546 unsigned Align = 0;

550 for (; I != E; ++I) {

551 if (!I->isAlignmentErrorDependent())

552 Align = std::max(Align, I->getAlignment(Ctx));

553 }

554 return Align;

555}

556

559 if (CanonD->Used)

560 return true;

561

562

563

565 return true;

566

567

568

570}

571

574 return;

575

576 if (C.getASTMutationListener())

577 C.getASTMutationListener()->DeclarationMarkedUsed(this);

578

580}

581

583 if (Referenced)

584 return true;

585

586

587 for (const auto *I : redecls())

588 if (I->Referenced)

589 return true;

590

591 return false;

592}

593

596 if (auto *ID = dyn_cast(this)) {

598 } else if (auto *PD = dyn_cast(this)) {

600 } else if (auto *TD = dyn_cast(this)) {

602 }

605

606 if (auto *attr = Definition->getAttr())

609 return dcd->getAttr();

610 }

611

612 return nullptr;

613}

614

616 return hasAttr() || hasAttr() ||

617 hasAttr();

618}

619

621 if (auto *AA = getAttr())

622 return AA;

623 if (auto *IFA = getAttr())

624 return IFA;

625 if (auto *NZA = getAttr())

626 return NZA;

627 return nullptr;

628}

629

632

633

634 StringRef RealizedPlatform = A->getPlatform()->getName();

636 return RealizedPlatform;

637 size_t suffix = RealizedPlatform.rfind("_app_extension");

638 if (suffix != StringRef::npos)

639 return RealizedPlatform.slice(0, suffix);

640 return RealizedPlatform;

641}

642

643

644

645

646

647

648

649

650

651

653 const AvailabilityAttr *A,

654 std::string *Message,

655 VersionTuple EnclosingVersion) {

656 if (EnclosingVersion.empty())

658

659 if (EnclosingVersion.empty())

661

662 StringRef ActualPlatform = A->getPlatform()->getName();

664

665

668

669 StringRef PrettyPlatformName

670 = AvailabilityAttr::getPrettyPlatformName(ActualPlatform);

671

672 if (PrettyPlatformName.empty())

673 PrettyPlatformName = ActualPlatform;

674

675 std::string HintMessage;

676 if (!A->getMessage().empty()) {

677 HintMessage = " - ";

678 HintMessage += A->getMessage();

679 }

680

681

682 if (A->getUnavailable()) {

683 if (Message) {

684 Message->clear();

685 llvm::raw_string_ostream Out(*Message);

686 Out << "not available on " << PrettyPlatformName

687 << HintMessage;

688 }

689

691 }

692

693

694 if (!A->getIntroduced().empty() &&

695 EnclosingVersion < A->getIntroduced()) {

697 StringRef TargetEnv =

699 StringRef EnvName = llvm::Triple::getEnvironmentTypeName(

701

702 if (!IIEnv || (!TargetEnv.empty() && IIEnv->getName() == TargetEnv)) {

703 if (Message) {

704 Message->clear();

705 llvm::raw_string_ostream Out(*Message);

706 VersionTuple VTI(A->getIntroduced());

707 Out << "introduced in " << PrettyPlatformName << " " << VTI << " "

708 << EnvName << HintMessage;

709 }

710 }

711

712 else {

713 if (Message) {

714 Message->clear();

715 llvm::raw_string_ostream Out(*Message);

716 Out << "not available on " << PrettyPlatformName << " " << EnvName

717 << HintMessage;

718 }

719 }

720

722 }

723

724

725 if (!A->getObsoleted().empty() && EnclosingVersion >= A->getObsoleted()) {

726 if (Message) {

727 Message->clear();

728 llvm::raw_string_ostream Out(*Message);

729 VersionTuple VTO(A->getObsoleted());

730 Out << "obsoleted in " << PrettyPlatformName << ' '

731 << VTO << HintMessage;

732 }

733

735 }

736

737

738 if (!A->getDeprecated().empty() && EnclosingVersion >= A->getDeprecated()) {

739 if (Message) {

740 Message->clear();

741 llvm::raw_string_ostream Out(*Message);

742 VersionTuple VTD(A->getDeprecated());

743 Out << "first deprecated in " << PrettyPlatformName << ' '

744 << VTD << HintMessage;

745 }

746

748 }

749

751}

752

754 VersionTuple EnclosingVersion,

755 StringRef *RealizedPlatform) const {

756 if (auto *FTD = dyn_cast(this))

757 return FTD->getTemplatedDecl()->getAvailability(Message, EnclosingVersion,

758 RealizedPlatform);

759

761 std::string ResultMessage;

762

763 for (const auto *A : attrs()) {

764 if (const auto *Deprecated = dyn_cast(A)) {

766 continue;

767

768 if (Message)

769 ResultMessage = std::string(Deprecated->getMessage());

770

772 continue;

773 }

774

775 if (const auto *Unavailable = dyn_cast(A)) {

776 if (Message)

777 *Message = std::string(Unavailable->getMessage());

779 }

780

781 if (const auto *Availability = dyn_cast(A)) {

783 Message, EnclosingVersion);

784

786 if (RealizedPlatform)

787 *RealizedPlatform = Availability->getPlatform()->getName();

789 }

790

793 if (Message)

794 ResultMessage.swap(*Message);

795 }

796 continue;

797 }

798 }

799

800 if (Message)

801 Message->swap(ResultMessage);

803}

804

808 for (const auto *A : attrs()) {

809 if (const auto *Availability = dyn_cast(A)) {

811 continue;

812 if (!Availability->getIntroduced().empty())

813 return Availability->getIntroduced();

814 }

815 }

816 return {};

817}

818

820 IsDefinition = false;

821

822

823 if (const auto *Var = dyn_cast(this)) {

824 if (Var->isThisDeclarationADefinition()) {

825 IsDefinition = true;

826 return false;

827 }

828 return true;

829 }

830

831 if (const auto *FD = dyn_cast(this)) {

832 if (FD->hasBody()) {

833 IsDefinition = true;

834 return false;

835 }

836 return true;

837

838 }

839

840 if (isa(this) &&

842 return true;

843 }

844

845 return false;

846}

847

849 bool IsDefinition;

851 return false;

852

854 if (isa(A))

855 return true;

856

857 if (const auto *Availability = dyn_cast(A)) {

860 return true;

861 }

862 }

863

864 return false;

865}

866

868 switch (DeclKind) {

870 case CXXDeductionGuide:

871 case CXXMethod:

872 case CXXConstructor:

873 case ConstructorUsingShadow:

874 case CXXDestructor:

875 case CXXConversion:

876 case EnumConstant:

877 case Var:

878 case ImplicitParam:

879 case ParmVar:

880 case ObjCMethod:

881 case ObjCProperty:

882 case MSProperty:

883 case HLSLBuffer:

887

888 case Binding:

889 case NonTypeTemplateParm:

890 case VarTemplate:

891 case Concept:

892

893

895

896 case ObjCCompatibleAlias:

897 case ObjCInterface:

899

900 case Typedef:

901 case TypeAlias:

902 case TemplateTypeParm:

903 case ObjCTypeParam:

905

906 case UnresolvedUsingTypename:

908

909 case UsingShadow:

910 return 0;

911

912 case UnresolvedUsingValue:

914

915 case Using:

916 case UsingPack:

917 case UsingEnum:

919

920 case ObjCProtocol:

922

923 case Field:

924 case IndirectField:

925 case ObjCAtDefsField:

926 case ObjCIvar:

928

930 case CXXRecord:

933

934 case Namespace:

935 case NamespaceAlias:

937

938 case FunctionTemplate:

940

941 case ClassTemplate:

942 case TemplateTemplateParm:

943 case TypeAliasTemplate:

945

946 case UnresolvedUsingIfExists:

948

949 case OMPDeclareReduction:

951

952 case OMPDeclareMapper:

954

955

957 case FriendTemplate:

958 case AccessSpec:

959 case LinkageSpec:

960 case Export:

961 case FileScopeAsm:

962 case TopLevelStmt:

963 case StaticAssert:

964 case ObjCPropertyImpl:

965 case PragmaComment:

966 case PragmaDetectMismatch:

968 case Captured:

969 case OutlinedFunction:

970 case TranslationUnit:

971 case ExternCContext:

972 case Decomposition:

973 case MSGuid:

974 case UnnamedGlobalConstant:

975 case TemplateParamObject:

976

977 case UsingDirective:

978 case BuiltinTemplate:

979 case ClassTemplateSpecialization:

980 case ClassTemplatePartialSpecialization:

981 case VarTemplateSpecialization:

982 case VarTemplatePartialSpecialization:

983 case ObjCImplementation:

984 case ObjCCategory:

985 case ObjCCategoryImpl:

986 case Import:

987 case OMPThreadPrivate:

988 case OMPAllocate:

989 case OMPRequires:

990 case OMPCapturedExpr:

992 case LifetimeExtendedTemporary:

993 case RequiresExprBody:

994 case ImplicitConceptSpecialization:

995

996 return 0;

997 }

998

999 llvm_unreachable("Invalid DeclKind!");

1000}

1001

1003 assert(!HasAttrs && "Decl already contains attrs.");

1004

1006 assert(AttrBlank.empty() && "HasAttrs was wrong?");

1007

1008 AttrBlank = attrs;

1009 HasAttrs = true;

1010}

1011

1013 if (!HasAttrs) return;

1014

1015 HasAttrs = false;

1017}

1018

1022 return;

1023 }

1024

1027 Attrs.push_back(A);

1028 return;

1029 }

1030

1031

1032

1033

1034 auto I = Attrs.begin(), E = Attrs.end();

1035 for (; I != E; ++I) {

1036 if (!(*I)->isInherited())

1037 break;

1038 }

1039 Attrs.insert(I, A);

1040}

1041

1043 assert(HasAttrs && "No attrs to get!");

1045}

1046

1049 switch (DK) {

1050#define DECL(NAME, BASE)

1051#define DECL_CONTEXT(NAME) \

1052 case Decl::NAME: \

1053 return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));

1054#include "clang/AST/DeclNodes.inc"

1055 default:

1056 llvm_unreachable("a decl that inherits DeclContext isn't handled");

1057 }

1058}

1059

1062 switch(DK) {

1063#define DECL(NAME, BASE)

1064#define DECL_CONTEXT(NAME) \

1065 case Decl::NAME: \

1066 return static_cast<NAME##Decl *>(const_cast<Decl *>(D));

1067#include "clang/AST/DeclNodes.inc"

1068 default:

1069 llvm_unreachable("a decl that inherits DeclContext isn't handled");

1070 }

1071}

1072

1074

1075

1076 if (const auto *FD = dyn_cast(this)) {

1079 return Definition->getSourceRange().getEnd();

1080 return {};

1081 }

1082

1084 return Body->getSourceRange().getEnd();

1085

1086 return {};

1087}

1088

1089bool Decl::AccessDeclContextCheck() const {

1090#ifndef NDEBUG

1091

1092

1093

1094

1095

1096

1097

1098

1099

1100 if (isa(this) || isa(this) ||

1101 isa(this) || getDeclContext () ||

1103 isa(this) || isa(this) ||

1104

1105

1106 isa(this) ||

1107

1108

1109 isa(this) || isa(this))

1110 return true;

1111

1113 "Access specifier is AS_none inside a record decl");

1114#endif

1115 return true;

1116}

1117

1120

1121 while (DC && !isa(DC))

1123

1124 return isa_and_nonnull(DC);

1125}

1126

1129

1130 if (!M)

1131 return false;

1132

1133

1134

1135

1136

1137

1138

1139

1140

1141 M = M->getTopLevelModule();

1142 if (!M->isNamedModule())

1143 return false;

1144

1146}

1147

1150

1151 if (!M || !M->isNamedModule())

1152 return false;

1153

1155}

1156

1159 if (!Source)

1160 return false;

1161

1163}

1164

1167}

1168

1171}

1172

1175}

1176

1179}

1180

1183

1186}

1187

1190 if (const auto *D = dyn_cast(this))

1191 Ty = D->getType();

1192 else if (const auto *D = dyn_cast(this))

1193 Ty = D->getUnderlyingType();

1194 else

1195 return nullptr;

1196

1198

1199

1200 assert(isa(this));

1201 return nullptr;

1202 }

1203

1210

1212}

1213

1216 if (const auto *D = dyn_cast(this))

1217 Ty = D->getType();

1218 else if (const auto *D = dyn_cast(this))

1219 Ty = D->getUnderlyingType();

1220 else

1221 return false;

1222

1224}

1225

1229}

1230

1231

1232

1234 if (getKind(D) == Decl::CXXMethod) {

1235 auto *MD = cast(D);

1236 if (MD->getOverloadedOperator() == OO_Call &&

1237 MD->getParent()->isLambda())

1239 return MD;

1240 }

1241 if (auto *FD = dyn_cast(D))

1242 return FD;

1243 if (auto *MD = dyn_cast(D))

1244 return MD;

1245 if (auto *BD = dyn_cast(D))

1247 if (auto *CD = dyn_cast(D))

1249 if (auto *OFD = dyn_cast(D))

1251 return nullptr;

1252}

1253

1255 return ::getNonClosureContext(this);

1256}

1257

1259 return ::getNonClosureContext(this);

1260}

1261

1262

1263

1264

1265

1270 setNeedToReconcileExternalVisibleStorage(false);

1271 setHasLazyLocalLexicalLookups(false);

1272 setHasLazyExternalLexicalLookups(false);

1274}

1275

1278 switch (DK) {

1279#define DECL(NAME, BASE)

1280#define DECL_CONTEXT(NAME) case Decl::NAME:

1281#include "clang/AST/DeclNodes.inc"

1282 return true;

1283 default:

1284 return false;

1285 }

1286}

1287

1289

1290

1291

1292

1293

1294

1295

1297

1298 if (isa(this))

1302

1303

1304

1305

1308

1310}

1311

1314

1315 do {

1316 if (Ctx->isClosure())

1317 return cast(Ctx);

1318 Ctx = Ctx->getParent();

1319 } while (Ctx);

1320

1321 return nullptr;

1322}

1323

1326 cast(this)->isInline();

1327}

1328

1331 return false;

1332

1333 const auto *ND = cast(this);

1334 if (ND->isInline()) {

1335 return ND->getParent()->isStdNamespace();

1336 }

1337

1339 return false;

1340

1342 return II && II->isStr("std");

1343}

1344

1347 return false;

1348

1349 if (isa(this))

1350 return true;

1351

1352 if (const auto *Record = dyn_cast(this)) {

1353 if (Record->getDescribedClassTemplate())

1354 return true;

1355

1356 if (Record->isDependentLambda())

1357 return true;

1358 if (Record->isNeverDependentLambda())

1359 return false;

1360 }

1361

1362 if (const auto *Function = dyn_cast(this)) {

1363 if (Function->getDescribedFunctionTemplate())

1364 return true;

1365

1366

1367

1368 if (cast(this)->getFriendObjectKind())

1370 }

1371

1372

1373

1374

1375

1377}

1378

1381 return !cast(this)->isScoped();

1382

1383 return isa<LinkageSpecDecl, ExportDecl, HLSLBufferDecl>(this);

1384}

1385

1388 while (DC->getDeclKind() != Decl::TranslationUnit) {

1389 if (DC->getDeclKind() == Decl::LinkageSpec)

1390 return cast(DC)->getLanguage() == ID;

1392 }

1393 return false;

1394}

1395

1398}

1399

1402 while (DC->getDeclKind() != Decl::TranslationUnit) {

1403 if (DC->getDeclKind() == Decl::LinkageSpec &&

1405 return cast(DC);

1407 }

1408 return nullptr;

1409}

1410

1413}

1414

1418

1419 for (; DC; DC = DC->getParent())

1420 if (!isa(DC) && !isa(DC) &&

1422 return true;

1423 return false;

1424}

1425

1430 assert(DC && "All transparent contexts should have a parent!");

1431 }

1432 return DC;

1433}

1434

1437 case Decl::ExternCContext:

1438 case Decl::LinkageSpec:

1439 case Decl::Export:

1440 case Decl::TopLevelStmt:

1441 case Decl::Block:

1442 case Decl::Captured:

1443 case Decl::OutlinedFunction:

1444 case Decl::OMPDeclareReduction:

1445 case Decl::OMPDeclareMapper:

1446 case Decl::RequiresExprBody:

1447

1448 return this;

1449

1450 case Decl::HLSLBuffer:

1451

1452

1453

1454

1455

1456

1457 return this;

1458

1459 case Decl::TranslationUnit:

1461 case Decl::Namespace:

1462 return static_cast<NamespaceDecl *>(this)->getFirstDecl();

1463

1464 case Decl::ObjCMethod:

1465 return this;

1466

1467 case Decl::ObjCInterface:

1468 if (auto *OID = dyn_cast(this))

1469 if (auto *Def = OID->getDefinition())

1470 return Def;

1471 return this;

1472

1473 case Decl::ObjCProtocol:

1474 if (auto *OPD = dyn_cast(this))

1475 if (auto *Def = OPD->getDefinition())

1476 return Def;

1477 return this;

1478

1479 case Decl::ObjCCategory:

1480 return this;

1481

1482 case Decl::ObjCImplementation:

1483 case Decl::ObjCCategoryImpl:

1484 return this;

1485

1486 default:

1488

1489

1490 auto *Tag = cast(this);

1491

1492 if (TagDecl *Def = Tag->getDefinition())

1493 return Def;

1494

1495 if (const auto *TagTy = dyn_cast(Tag->getTypeForDecl())) {

1496

1497 TagDecl *PossiblePartialDef = TagTy->getDecl();

1499 return PossiblePartialDef;

1500 } else {

1501 assert(isa(Tag->getTypeForDecl()));

1502 }

1503

1504 return Tag;

1505 }

1506

1507 assert(getDeclKind() >= Decl::firstFunction &&

1509 "Unknown DeclContext kind");

1510 return this;

1511 }

1512}

1513

1514template

1518 Contexts.push_back(D);

1519

1520 std::reverse(Contexts.begin(), Contexts.end());

1521}

1522

1524 Contexts.clear();

1525

1527

1528 if (Kind == Decl::TranslationUnit)

1530 else if (Kind == Decl::Namespace)

1532 else

1533 Contexts.push_back(this);

1534}

1535

1536std::pair<Decl *, Decl *>

1538 bool FieldsAlreadyLoaded) {

1539

1540 Decl *FirstNewDecl = nullptr;

1541 Decl *PrevDecl = nullptr;

1542 for (auto *D : Decls) {

1543 if (FieldsAlreadyLoaded && isa(D))

1544 continue;

1545

1546 if (PrevDecl)

1548 else

1549 FirstNewDecl = D;

1550

1551 PrevDecl = D;

1552 }

1553

1554 return std::make_pair(FirstNewDecl, PrevDecl);

1555}

1556

1557

1558

1559

1560void DeclContext::reconcileExternalVisibleStorage() const {

1561 assert(hasNeedToReconcileExternalVisibleStorage() && LookupPtr);

1562 setNeedToReconcileExternalVisibleStorage(false);

1563

1565 Lookup.second.setHasExternalDecls();

1566}

1567

1568

1569

1570

1571bool

1572DeclContext::LoadLexicalDeclsFromExternalStorage() const {

1575

1576

1578

1579

1583

1584 if (Decls.empty())

1585 return false;

1586

1587

1588

1589 bool FieldsAlreadyLoaded = false;

1590 if (const auto *RD = dyn_cast(this))

1591 FieldsAlreadyLoaded = RD->hasLoadedFieldsFromExternalStorage();

1592

1593

1594

1595 Decl *ExternalFirst, *ExternalLast;

1596 std::tie(ExternalFirst, ExternalLast) =

1602 return true;

1603}

1604

1611 Map = DC->CreateStoredDeclsMap(Context);

1612 if (DC->hasNeedToReconcileExternalVisibleStorage())

1613 DC->reconcileExternalVisibleStorage();

1614

1615 (*Map)[Name].removeExternalDecls();

1616

1618}

1619

1627 Map = DC->CreateStoredDeclsMap(Context);

1628 if (DC->hasNeedToReconcileExternalVisibleStorage())

1629 DC->reconcileExternalVisibleStorage();

1630

1632 List.replaceExternalDecls(Decls);

1633 return List.getLookupResult();

1634}

1635

1638 LoadLexicalDeclsFromExternalStorage();

1640}

1641

1644 LoadLexicalDeclsFromExternalStorage();

1645

1647}

1648

1652}

1653

1656 LoadLexicalDeclsFromExternalStorage();

1658}

1659

1660

1661

1663

1664 if (->getDeclName())

1665 return true;

1666

1667

1668

1671 return true;

1672

1673

1674

1677 return true;

1678

1679

1680

1681

1682

1683 if (isa(D))

1684 return true;

1685 if (auto *FD = dyn_cast(D))

1686 if (FD->isFunctionTemplateSpecialization())

1687 return true;

1688

1689

1690

1691

1692

1694 return true;

1695

1696 return false;

1697}

1698

1701 "decl being removed from non-lexical context");

1703 "decl is not in decls list");

1704

1705

1709 else

1711 } else {

1713 assert(I && "decl not found in linked list");

1714 if (I->NextInContextAndBits.getPointer() == D) {

1717 break;

1718 }

1719 }

1720 }

1721

1722

1724

1725

1726 if (isa(D)) {

1727 auto *ND = cast(D);

1728

1729

1730

1732 return;

1733

1734

1735 if (!ND->getDeclName())

1736 return;

1737

1739 do {

1740 StoredDeclsMap *Map = DC->getPrimaryContext()->LookupPtr;

1741 if (Map) {

1742 StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName());

1743 assert(Pos != Map->end() && "no lookup entry for decl");

1745 List.remove(ND);

1746

1747 if (List.isNull())

1748 Map->erase(Pos);

1749 }

1750 } while (DC->isTransparentContext() && (DC = DC->getParent()));

1751 }

1752}

1753

1756 "Decl inserted into wrong lexical context");

1758 "Decl already inserted into a DeclContext");

1759

1763 } else {

1765 }

1766

1767

1768

1769 if (auto *Record = dyn_cast(this))

1771

1772

1773

1775 if (auto *Import = dyn_cast(D))

1777 }

1778}

1779

1782

1783 if (auto *ND = dyn_cast(D))

1784 ND->getDeclContext()->getPrimaryContext()->

1785 makeDeclVisibleInContextWithFlags(ND, false, true);

1786}

1787

1790

1791 if (auto *ND = dyn_cast(D))

1792 ND->getDeclContext()->getPrimaryContext()->

1793 makeDeclVisibleInContextWithFlags(ND, true, true);

1794}

1795

1796

1797

1798

1799

1800

1801

1802

1804 assert(this == getPrimaryContext() && "buildLookup called on non-primary DC");

1805

1806 if (!hasLazyLocalLexicalLookups() &&

1807 !hasLazyExternalLexicalLookups())

1809

1812

1813 if (hasLazyExternalLexicalLookups()) {

1814 setHasLazyExternalLexicalLookups(false);

1815 for (auto *DC : Contexts) {

1816 if (DC->hasExternalLexicalStorage()) {

1817 bool LoadedDecls = DC->LoadLexicalDeclsFromExternalStorage();

1818 setHasLazyLocalLexicalLookups(

1819 hasLazyLocalLexicalLookups() | LoadedDecls );

1820 }

1821 }

1822

1823 if (!hasLazyLocalLexicalLookups())

1825 }

1826

1827 for (auto *DC : Contexts)

1829

1830

1831 setHasLazyLocalLexicalLookups(false);

1833}

1834

1835

1836

1837

1838

1841

1842

1843

1844

1845

1846

1847

1848

1849 if (auto *ND = dyn_cast(D))

1850 if (ND->getDeclContext() == DCtx && shouldBeHidden (ND) &&

1851 (!ND->isFromASTFile() ||

1854 makeDeclVisibleInContextImpl(ND, Internal);

1855

1856

1857

1858

1859 if (auto *InnerCtx = dyn_cast(D))

1860 if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace())

1861 buildLookupImpl(InnerCtx, Internal);

1862 }

1863}

1864

1867

1870

1872}

1873

1876 const DeclContext *OriginalLookupDC) const {

1878 "lookupImpl should only be called with primary DC!");

1880 "We shouldn't lookup in transparent DC.");

1881

1882

1883

1884

1886 if (Source)

1887 (void)cast(this)->getMostRecentDecl();

1888

1890 assert(Source && "external visible storage but no external source?");

1891

1892 if (hasNeedToReconcileExternalVisibleStorage())

1893 reconcileExternalVisibleStorage();

1894

1896

1897 if (hasLazyLocalLexicalLookups() ||

1898 hasLazyExternalLexicalLookups())

1899

1901

1902 if (!Map)

1904

1905

1906 std::pair<StoredDeclsMap::iterator, bool> R =

1908 if (!R.second && !R.first->second.hasExternalDecls())

1909 return R.first->second.getLookupResult();

1910

1912 !R.second) {

1914 StoredDeclsMap::iterator I = Map->find(Name);

1915 if (I != Map->end())

1916 return I->second.getLookupResult();

1917 }

1918 }

1919

1920 return {};

1921 }

1922

1924 if (hasLazyLocalLexicalLookups() ||

1925 hasLazyExternalLexicalLookups())

1927

1928 if (!Map)

1929 return {};

1930

1931 StoredDeclsMap::iterator I = Map->find(Name);

1932 if (I == Map->end())

1933 return {};

1934

1935 return I->second.getLookupResult();

1936}

1937

1940

1943

1945 if (PrimaryContext != this)

1947

1948 loadLazyLocalLexicalLookups();

1950 if (!Map)

1951 return {};

1952

1953 StoredDeclsMap::iterator I = Map->find(Name);

1954 return I != Map->end() ? I->second.getLookupResult()

1956}

1957

1958

1959

1960

1961void DeclContext::loadLazyLocalLexicalLookups() {

1962 if (hasLazyLocalLexicalLookups()) {

1965 for (auto *Context : Contexts)

1967 setHasLazyLocalLexicalLookups(false);

1968 }

1969}

1970

1973 Results.clear();

1974

1975

1976

1979 Results.insert(Results.end(), LookupResults.begin(), LookupResults.end());

1980 if (!Results.empty())

1981 return;

1982 }

1983

1984

1985

1986 if (Name && !hasLazyLocalLexicalLookups() &&

1987 !hasLazyExternalLexicalLookups()) {

1989 StoredDeclsMap::iterator Pos = Map->find(Name);

1990 if (Pos != Map->end()) {

1991 Results.insert(Results.end(),

1992 Pos->second.getLookupResult().begin(),

1993 Pos->second.getLookupResult().end());

1994 return;

1995 }

1996 }

1997 }

1998

1999

2000

2001

2002

2004 if (auto *ND = dyn_cast(D))

2005 if (ND->getDeclName() == Name)

2006 Results.push_back(ND);

2007 }

2008}

2009

2012

2013

2014

2015

2016

2017

2018 bool SkipRecords = getDeclKind() == Decl::Kind::Enum &&

2020

2021

2022

2023 while ((SkipRecords && Ctx->isRecord()) || Ctx->isTransparentContext())

2024 Ctx = Ctx->getParent();

2025 return Ctx;

2026}

2027

2030

2031 while (!Ctx->isFileContext())

2032 Ctx = Ctx->getParent();

2033 return Ctx->getPrimaryContext();

2034}

2035

2037

2041 OutermostRD = cast(DC);

2043 }

2044 return OutermostRD;

2045}

2046

2048

2050 return O->Equals(this);

2051

2052 do {

2053 if (O->Equals(this))

2054 return true;

2055

2056 const auto *NS = dyn_cast(O);

2057 if (!NS || !NS->isInline())

2058 break;

2060 } while (O);

2061

2062 return false;

2063}

2064

2068

2069

2070 PrimaryDC->makeDeclVisibleInContextWithFlags(D, false, PrimaryDC == DeclDC);

2071}

2072

2073void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,

2074 bool Recoverable) {

2076

2080 ->makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);

2081 return;

2082 }

2083

2084

2086 return;

2087

2088

2089

2090

2091

2092

2093

2094

2095

2100

2101

2102

2104 makeDeclVisibleInContextImpl(D, Internal);

2105 } else {

2106 setHasLazyLocalLexicalLookups(true);

2107 }

2108

2109

2110

2113 makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);

2114

2115 auto *DCAsDecl = cast(this);

2116

2117 if (!(isa(DCAsDecl) && cast(DCAsDecl)->isBeingDefined()))

2119 L->AddedVisibleDecl(this, D);

2120}

2121

2122void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal) {

2123

2125 if (!Map) {

2127 Map = CreateStoredDeclsMap(*C);

2128 }

2129

2130

2131

2132

2133

2137 Map->find(D->getDeclName()) == Map->end())

2140

2141

2142 StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()];

2143

2145

2146

2147

2148

2151 return;

2152 }

2153

2155}

2156

2158 return cast(*I);

2159}

2160

2161

2162

2164

2165

2168}

2169

2170

2171

2172

2173

2175 assert( LookupPtr && "context already has a decls map");

2177 "creating decls map on non-primary context");

2178

2183 else

2185 M->Previous = C.LastSDM;

2186 C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent);

2188 return M;

2189}

2190

2191void ASTContext::ReleaseDeclContextMaps() {

2192

2193

2194

2196 LastSDM.setPointer(nullptr);

2197}

2198

2200 while (Map) {

2201

2202 llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous;

2203

2206 else

2207 delete Map;

2208

2209 Map = Next.getPointer();

2211 }

2212}

2213

2217 assert(Parent->isDependentContext()

2218 && "cannot iterate dependent diagnostics of non-dependent context");

2220 if ( Parent ->LookupPtr)

2221 Parent->CreateStoredDeclsMap(C);

2222

2224

2225

2226

2230

2232

2233

2234 DD->NextDiagnostic = Map->FirstDiagnostic;

2235 Map->FirstDiagnostic = DD;

2236

2237 return DD;

2238}

2239

2241 return ID & llvm::maskTrailingOnes(32);

2242}

Defines the clang::ASTContext interface.

This file provides some common utility functions for processing Lambda related AST Constructs.

static bool shouldBeHidden(NamedDecl *D)

shouldBeHidden - Determine whether a declaration which was declared within its semantic context shoul...

static void collectAllContextsImpl(T *Self, SmallVectorImpl< DeclContext * > &Contexts)

static bool isLinkageSpecContext(const DeclContext *DC, LinkageSpecLanguageIDs ID)

static Decl::Kind getKind(const Decl *D)

static Decl * getNonClosureContext(T *D)

Starting at a given context (a Decl or DeclContext), look for a code context that is not a closure (a...

static AvailabilityResult CheckAvailability(ASTContext &Context, const AvailabilityAttr *A, std::string *Message, VersionTuple EnclosingVersion)

Determine the availability of the given declaration based on the target platform.

static StringRef getRealizedPlatform(const AvailabilityAttr *A, const ASTContext &Context)

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

This file defines OpenMP nodes for declarative directives.

Defines the C++ template declaration subclasses.

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

llvm::MachO::Record Record

Defines the clang::Module class, which describes a module in the source code.

Defines types useful for describing an Objective-C runtime.

Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.

Defines the clang::SourceLocation class and associated facilities.

static QualType getPointeeType(const MemRegion *R)

C Language Family Type Representation.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

const ConstantArrayType * getAsConstantArrayType(QualType T) const

ASTMutationListener * getASTMutationListener() const

Retrieve a pointer to the AST mutation listener associated with this AST context, if any.

const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const

const LangOptions & getLangOpts() const

llvm::BumpPtrAllocator & getAllocator() const

void eraseDeclAttrs(const Decl *D)

Erase the attributes corresponding to the given declaration.

void addedLocalImportDecl(ImportDecl *Import)

Notify the AST context that a new import declaration has been parsed or implicitly created within thi...

void * Allocate(size_t Size, unsigned Align=8) const

const TargetInfo & getTargetInfo() const

ExternalASTSource * getExternalSource() const

Retrieve a pointer to the external AST source associated with this AST context, if any.

Module * getCurrentNamedModule() const

Get module under construction, nullptr if this is not a C++20 module.

AttrVec & getDeclAttrs(const Decl *D)

Retrieve the attributes for the given declaration.

An abstract interface that should be implemented by listeners that want to be notified when an AST en...

Attr - This represents one attribute.

Represents a block literal declaration, which is like an unnamed FunctionDecl.

The results of name lookup within a DeclContext.

decl_iterator - Iterates through the declarations stored within this context.

specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

udir_range using_directives() const

Returns iterator range [First, Last) of UsingDirectiveDecls stored within this context.

bool Equals(const DeclContext *DC) const

Determine whether this declaration context is equivalent to the declaration context DC.

bool isFileContext() const

void setHasExternalVisibleStorage(bool ES=true) const

State whether this DeclContext has external storage for declarations visible in this context.

void makeDeclVisibleInContext(NamedDecl *D)

Makes a declaration visible within this context.

DeclContextLookupResult lookup_result

static std::pair< Decl *, Decl * > BuildDeclChain(ArrayRef< Decl * > Decls, bool FieldsAlreadyLoaded)

Build up a chain of declarations.

bool isTransparentContext() const

isTransparentContext - Determines whether this context is a "transparent" context,...

Decl * getNonClosureAncestor()

Find the nearest non-closure ancestor of this context, i.e.

ASTContext & getParentASTContext() const

bool isExternCXXContext() const

Determines whether this context or some of its ancestors is a linkage specification context that spec...

bool isDependentContext() const

Determines whether this context is dependent on a template parameter.

bool InEnclosingNamespaceSetOf(const DeclContext *NS) const

Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...

DeclContext * getLexicalParent()

getLexicalParent - Returns the containing lexical DeclContext.

lookup_result lookup(DeclarationName Name) const

lookup - Find the declarations (if any) with the given Name in this context.

bool isLookupContext() const

Test whether the context supports looking up names.

const BlockDecl * getInnermostBlockDecl() const

Return this DeclContext if it is a BlockDecl.

bool hasExternalVisibleStorage() const

Whether this DeclContext has external storage containing additional declarations that are visible in ...

const char * getDeclKindName() const

bool isTranslationUnit() const

void collectAllContexts(SmallVectorImpl< DeclContext * > &Contexts)

Collects all of the declaration contexts that are semantically connected to this declaration context.

DeclContext * getRedeclContext()

getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...

llvm::iterator_range< udir_iterator > udir_range

Decl * FirstDecl

FirstDecl - The first declaration stored within this declaration context.

DeclContext(Decl::Kind K)

void addDeclInternal(Decl *D)

Add the declaration D into this context, but suppress searches for external declarations with the sam...

bool containsDeclAndLoad(Decl *D) const

Checks whether a declaration is in this context.

void removeDecl(Decl *D)

Removes a declaration from this context.

void addDecl(Decl *D)

Add the declaration D into this context.

StoredDeclsMap * buildLookup()

Ensure the lookup structure is fully-built and return it.

bool hasValidDeclKind() const

bool isStdNamespace() const

lookup_result noload_lookup(DeclarationName Name)

Find the declarations with the given name that are visible within this context; don't attempt to retr...

static bool classof(const Decl *D)

bool containsDecl(Decl *D) const

Checks whether a declaration is in this context.

bool hasExternalLexicalStorage() const

Whether this DeclContext has external storage containing additional declarations that are lexically i...

void setUseQualifiedLookup(bool use=true) const

DeclContext * getEnclosingNamespaceContext()

Retrieve the nearest enclosing namespace context.

Decl * LastDecl

LastDecl - The last declaration stored within this declaration context.

decl_range noload_decls() const

noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...

friend class DependentDiagnostic

For CreateStoredDeclsMap.

DeclContext * getPrimaryContext()

getPrimaryContext - There may be many different declarations of the same entity (including forward de...

RecordDecl * getOuterLexicalRecordContext()

Retrieve the outermost lexically enclosing record context.

bool isInlineNamespace() const

DeclContextBitfields DeclContextBits

bool isFunctionOrMethod() const

void setHasExternalLexicalStorage(bool ES=true) const

State whether this DeclContext has external storage for declarations lexically in this context.

DeclContext * getLookupParent()

Find the parent context of this context that will be used for unqualified name lookup.

StoredDeclsMap * LookupPtr

Pointer to the data structure used to lookup declarations within this context (or a DependentStoredDe...

bool isExternCContext() const

Determines whether this context or some of its ancestors is a linkage specification context that spec...

const LinkageSpecDecl * getExternCContext() const

Retrieve the nearest enclosing C linkage specification context.

bool Encloses(const DeclContext *DC) const

Determine whether this declaration context encloses the declaration context DC.

void addHiddenDecl(Decl *D)

Add the declaration D to this context without modifying any lookup tables.

void localUncachedLookup(DeclarationName Name, SmallVectorImpl< NamedDecl * > &Results)

A simplistic name lookup mechanism that performs name lookup into this declaration context without co...

Decl::Kind getDeclKind() const

DeclContext * getNonTransparentContext()

decl_iterator decls_begin() const

unsigned getLocalDeclIndex() const

Decl - This represents one declaration (or definition), e.g.

Decl * getPreviousDecl()

Retrieve the previous declaration that declares the same entity as this declaration,...

Decl * getMostRecentDecl()

Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...

const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const

If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...

bool isInStdNamespace() const

bool isInCurrentModuleUnit() const

Whether this declaration comes from the same module unit being compiled.

TemplateDecl * getDescribedTemplate() const

If this is a declaration that describes some template, this method returns that template declaration.

bool isTemplateDecl() const

returns true if this declaration is a template

Module * getTopLevelOwningNamedModule() const

Get the top level owning named module that owns this declaration if any.

FriendObjectKind getFriendObjectKind() const

Determines whether this declaration is the object of a friend declaration and, if so,...

bool isFromGlobalModule() const

Whether this declaration comes from global module.

ASTContext & getASTContext() const LLVM_READONLY

void setOwningModuleID(unsigned ID)

Set the owning module ID.

void setAttrs(const AttrVec &Attrs)

bool hasLocalOwningModuleStorage() const

bool isFunctionPointerType() const

bool isInNamedModule() const

Whether this declaration comes from a named module.

ExternalSourceSymbolAttr * getExternalSourceSymbolAttr() const

Looks on this and related declarations for an applicable external source symbol attribute.

bool isWeakImported() const

Determine whether this is a weak-imported symbol.

ModuleOwnershipKind getModuleOwnershipKind() const

Get the kind of module ownership for this declaration.

bool isParameterPack() const

Whether this declaration is a parameter pack.

ASTMutationListener * getASTMutationListener() const

unsigned getMaxAlignment() const

getMaxAlignment - return the maximum alignment specified by attributes on this decl,...

AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const

Determine the availability of the given declaration.

void setInvalidDecl(bool Invalid=true)

setInvalidDecl - Indicates the Decl had a semantic error.

Kind

Lists the kind of concrete classes of Decl.

static unsigned getIdentifierNamespaceForKind(Kind DK)

virtual Stmt * getBody() const

getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...

void markUsed(ASTContext &C)

Mark the declaration used, in the sense of odr-use.

bool isFileContextDecl() const

static Decl * castFromDeclContext(const DeclContext *)

Decl * getNextDeclInContext()

bool isTemplated() const

Determine whether this declaration is a templated entity (whether it is.

bool isInExportDeclContext() const

Whether this declaration was exported in a lexical context.

SourceLocation getBodyRBrace() const

getBodyRBrace - Gets the right brace of the body, if a body exists.

bool isReferenced() const

Whether any declaration of this entity was referenced.

const FunctionType * getFunctionType(bool BlocksToo=true) const

Looks through the Decl's underlying type to extract a FunctionType when possible.

bool isInAnotherModuleUnit() const

Whether this declaration comes from another module unit.

llvm::PointerIntPair< Decl *, 3, ModuleOwnershipKind > NextInContextAndBits

The next declaration within the same lexical DeclContext.

Module * getOwningModule() const

Get the module that owns this declaration (for visibility purposes).

unsigned getTemplateDepth() const

Determine the number of levels of template parameter surrounding this declaration.

bool isFromExplicitGlobalModule() const

Whether this declaration comes from explicit global module.

FunctionDecl * getAsFunction() LLVM_READONLY

Returns the function itself, or the templated function if this is a function template.

bool canBeWeakImported(bool &IsDefinition) const

Determines whether this symbol can be weak-imported, e.g., whether it would be well-formed to add the...

static DeclContext * castToDeclContext(const Decl *)

const TemplateParameterList * getDescribedTemplateParams() const

If this is a declaration that describes some template or partial specialization, this returns the cor...

bool isFromASTFile() const

Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...

bool isInLocalScopeForInstantiation() const

Determine whether a substitution into this declaration would occur as part of a substitution into a d...

const Attr * getDefiningAttr() const

Return this declaration's defining attribute if it has one.

bool isTemplateParameter() const

isTemplateParameter - Determines whether this declaration is a template parameter.

DeclContext * getNonTransparentDeclContext()

Return the non transparent context.

Decl * getNonClosureContext()

Find the innermost non-closure ancestor of this declaration, walking up through blocks,...

bool isInvalidDecl() const

unsigned getIdentifierNamespace() const

bool hasDefiningAttr() const

Return true if this declaration has an attribute which acts as definition of the entity,...

bool isLocalExternDecl() const

Determine whether this is a block-scope declaration with linkage.

void setAccess(AccessSpecifier AS)

SourceLocation getLocation() const

const char * getDeclKindName() const

@ IDNS_Ordinary

Ordinary names.

@ IDNS_Type

Types, declared with 'struct foo', typedefs, etc.

@ IDNS_OMPReduction

This declaration is an OpenMP user defined reduction construction.

@ IDNS_Label

Labels, declared with 'x:' and referenced with 'goto x'.

@ IDNS_Member

Members, declared with object declarations within tag definitions.

@ IDNS_OMPMapper

This declaration is an OpenMP user defined mapper.

@ IDNS_ObjCProtocol

Objective C @protocol.

@ IDNS_Namespace

Namespaces, declared with 'namespace foo {}'.

@ IDNS_Using

This declaration is a using declaration.

@ IDNS_Tag

Tags, declared with 'struct foo;' and referenced with 'struct foo'.

bool isTemplateParameterPack() const

isTemplateParameter - Determines whether this declaration is a template parameter pack.

void setLocalOwningModule(Module *M)

redecl_range redecls() const

Returns an iterator range for all the redeclarations of the same decl.

void setIsUsed()

Set whether the declaration is used, in the sense of odr-use.

unsigned Access

Access - Used by C++ decls for the access specifier.

bool isUsed(bool CheckUsedAttr=true) const

Whether any (re-)declaration of the entity was used, meaning that a definition is required.

DeclContext * getDeclContext()

bool isInAnonymousNamespace() const

static void EnableStatistics()

TranslationUnitDecl * getTranslationUnitDecl()

VersionTuple getVersionIntroduced() const

Retrieve the version of the target platform in which this declaration was introduced.

bool hasOwningModule() const

Is this declaration owned by some module?

bool isFromHeaderUnit() const

Whether this declaration comes from a header unit.

void updateOutOfDate(IdentifierInfo &II) const

Update a potentially out-of-date declaration.

static bool isFlexibleArrayMemberLike(ASTContext &Context, const Decl *D, QualType Ty, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution)

Whether it resembles a flexible array member.

void setDeclContext(DeclContext *DC)

setDeclContext - Set both the semantic and lexical DeclContext to DC.

DeclContext * getLexicalDeclContext()

getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).

void setLexicalDeclContext(DeclContext *DC)

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

@ VisibleWhenImported

This declaration has an owning module, and is visible when that module is imported.

void setModuleOwnershipKind(ModuleOwnershipKind MOK)

Set whether this declaration is hidden from name lookup.

const LangOptions & getLangOpts() const LLVM_READONLY

Helper to get the language options from the ASTContext.

GlobalDeclID getGlobalID() const

Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...

unsigned getOwningModuleID() const

Retrieve the global ID of the module that owns this particular declaration.

bool shouldEmitInExternalSource() const

Whether the definition of the declaration should be emitted in external sources.

The name of a declaration.

A dependently-generated diagnostic.

static DependentDiagnostic * Create(ASTContext &Context, DeclContext *Parent, AccessNonce _, SourceLocation Loc, bool IsMemberAccess, AccessSpecifier AS, NamedDecl *TargetDecl, CXXRecordDecl *NamingClass, QualType BaseObjectType, const PartialDiagnostic &PDiag)

This represents one expression.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.

Abstract interface for external sources of AST nodes.

virtual ExtKind hasExternalDefinitions(const Decl *D)

static DeclContextLookupResult SetExternalVisibleDeclsForName(const DeclContext *DC, DeclarationName Name, ArrayRef< NamedDecl * > Decls)

static DeclContextLookupResult SetNoExternalVisibleDeclsForName(const DeclContext *DC, DeclarationName Name)

virtual Module * getModule(unsigned ID)

Retrieve the module that corresponds to the given module ID.

virtual bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name, const DeclContext *OriginalDC)

Find all declarations with the given name in the given context, and add them to the context by callin...

virtual void updateOutOfDateIdentifier(const IdentifierInfo &II)

Update an out-of-date identifier.

virtual void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl * > &Result)

Finds all declarations lexically contained within the given DeclContext, after applying an optional f...

Represents a member of a struct/union/class.

Represents a function declaration or definition.

FunctionType - C99 6.7.5.3 - Function Declarators.

One of these records is kept for each identifier that is lexed.

bool isStr(const char(&Str)[StrLen]) const

Return true if this is the identifier for the specified string.

StringRef getName() const

Return the actual identifier string.

StrictFlexArraysLevelKind

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

bool trackLocalOwningModule() const

Do we need to track the owning module for a local declaration?

Represents a linkage specification.

Describes a module or submodule.

bool isExplicitGlobalModule() const

bool isGlobalModule() const

Does this Module scope describe a fragment of the global module within some C++ module.

bool isHeaderUnit() const

Is this module a header unit.

bool isNamedModule() const

Does this Module is a named module of a standard named module?

Module * getTopLevelModule()

Retrieve the top-level module for this (sub)module, which may be this module.

This represents a decl that may have a name.

Represent a C++ namespace.

The basic abstraction for the target Objective-C runtime.

bool hasWeakClassImport() const

Does this runtime support weakly importing classes?

PointerType - C99 6.7.5.1 - Pointer Declarators.

void print(raw_ostream &OS) const override

A (possibly-)qualified type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

QualType getCanonicalType() const

Represents a struct/union/class.

Base for LValueReferenceType and RValueReferenceType.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

void print(raw_ostream &OS, const SourceManager &SM) const

Stmt - This represents one statement.

An array of decls optimized for the common case of only containing one entry.

void setHasExternalDecls()

void addOrReplaceDecl(NamedDecl *D)

If this is a redeclaration of an existing decl, replace the old one with D.

void prependDeclNoReplace(NamedDecl *D)

Add a declaration to the list without checking if it replaces anything.

static void DestroyAll(StoredDeclsMap *Map, bool Dependent)

Represents the declaration of a struct/union/class/enum.

bool isBeingDefined() const

Return true if this decl is currently being defined.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

StringRef getPlatformName() const

Retrieve the name of the platform as it is used in the availability attribute.

VersionTuple getPlatformMinVersion() const

Retrieve the minimum desired version of the platform, to which the program should be compiled.

The base class of all kinds of template declarations (e.g., class, function, etc.).

Stores a list of template parameters for a TemplateDecl and its derived classes.

The top declaration context.

ASTContext & getASTContext() const

Base wrapper for a particular "section" of type source info.

T getAs() const

Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...

T getAsAdjusted() const

Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...

A container of type source information.

TypeLoc getTypeLoc() const

Return the TypeLoc wrapper for the type source info.

bool isBlockPointerType() const

bool isFunctionReferenceType() const

bool isFunctionPointerType() const

const T * castAs() const

Member-template castAs.

const T * getAs() const

Member-template getAs'.

Base class for declarations which introduce a typedef-name.

TypeSourceInfo * getTypeSourceInfo() const

Wrapper for source info for typedefs.

Represents C++ using-directive.

specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are o...

Defines the clang::TargetInfo interface.

const internal::VariadicAllOfMatcher< Attr > attr

Matches attributes.

The JSON file list parser is used to communicate input to InstallAPI.

SmallVector< Attr *, 4 > AttrVec

AttrVec - A vector of Attr, which is how they are stored on the AST.

LinkageSpecLanguageIDs

Represents the language in a linkage specification.

@ Self

'self' clause, allowed on Compute and Combined Constructs, plus 'update'.

@ Internal

Internal linkage, which indicates that the entity can be referred to from within the translation unit...

bool isLambdaCallOperator(const CXXMethodDecl *MD)

@ Result

The result type of a method or function.

AvailabilityResult

Captures the result of checking the availability of a declaration.

const FunctionProtoType * T

@ Enum

The "enum" keyword introduces the elaborated-type-specifier.

UsingDirectiveDecl * operator*() const