DeclTemplate.cpp Source File (original) (raw)

29#include "llvm/ADT/ArrayRef.h"

30#include "llvm/ADT/FoldingSet.h"

31#include "llvm/ADT/PointerUnion.h"

32#include "llvm/ADT/STLExtras.h"

33#include "llvm/ADT/SmallVector.h"

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

35#include

36#include

37#include

38#include

40using namespace clang;

46template

47static bool

49 return P.hasDefaultArgument() &&

50 P.getDefaultArgument().getArgument().containsUnexpandedParameterPack();

51}

53TemplateParameterList::TemplateParameterList(const ASTContext &C,

58 Expr *RequiresClause)

59 : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),

60 NumParams(Params.size()), ContainsUnexpandedParameterPack(false),

61 HasRequiresClause(RequiresClause != nullptr),

62 HasConstrainedParameters(false) {

63 for (unsigned Idx = 0; Idx < NumParams; ++Idx) {

65 begin()[Idx] = P;

67 bool IsPack = P->isTemplateParameterPack();

68 if (const auto *NTTP = dyn_cast(P)) {

69 if (!IsPack && (NTTP->getType()->containsUnexpandedParameterPack() ||

71 ContainsUnexpandedParameterPack = true;

72 if (NTTP->hasPlaceholderTypeConstraint())

73 HasConstrainedParameters = true;

74 } else if (const auto *TTP = dyn_cast(P)) {

75 if (!IsPack &&

76 (TTP->getTemplateParameters()->containsUnexpandedParameterPack() ||

78 ContainsUnexpandedParameterPack = true;

79 }

80 } else if (const auto *TTP = dyn_cast(P)) {

82 ContainsUnexpandedParameterPack = true;

83 } else if (const TypeConstraint *TC = TTP->getTypeConstraint();

86 ContainsUnexpandedParameterPack = true;

87 }

88 if (TTP->hasTypeConstraint())

89 HasConstrainedParameters = true;

90 } else {

91 llvm_unreachable("unexpected template parameter type");

92 }

93 }

95 if (HasRequiresClause) {

97 ContainsUnexpandedParameterPack = true;

98 *getTrailingObjects<Expr *>() = RequiresClause;

99 }

100}

101

102bool TemplateParameterList::containsUnexpandedParameterPack() const {

103 if (ContainsUnexpandedParameterPack)

104 return true;

105 if (!HasConstrainedParameters)

106 return false;

107

108

109

110

112 if (!Param->isImplicit())

113 break;

114

115 if (const auto *TTP = dyn_cast(Param)) {

116 const auto *TC = TTP->getTypeConstraint();

117 if (TC && TC->getImmediatelyDeclaredConstraint()

118 ->containsUnexpandedParameterPack())

119 return true;

120 }

121 }

122

123 return false;

124}

125

131 void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(

132 Params.size(), RequiresClause ? 1u : 0u),

135 RAngleLoc, RequiresClause);

136}

137

141 ID.AddBoolean(RC != nullptr);

142 if (RC)

143 RC->Profile(ID, C, true);

144 ID.AddInteger(size());

146 if (const auto *NTTP = dyn_cast(D)) {

147 ID.AddInteger(0);

148 ID.AddBoolean(NTTP->isParameterPack());

149 NTTP->getType().getCanonicalType().Profile(ID);

150 ID.AddBoolean(NTTP->hasPlaceholderTypeConstraint());

151 if (const Expr *E = NTTP->getPlaceholderTypeConstraint())

152 E->Profile(ID, C, true);

153 continue;

154 }

155 if (const auto *TTP = dyn_cast(D)) {

156 ID.AddInteger(1);

157 ID.AddBoolean(TTP->isParameterPack());

158 ID.AddBoolean(TTP->hasTypeConstraint());

159 if (const TypeConstraint *TC = TTP->getTypeConstraint())

160 TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,

161 true);

162 continue;

163 }

164 const auto *TTP = cast(D);

165 ID.AddInteger(2);

166 ID.AddBoolean(TTP->isParameterPack());

167 TTP->getTemplateParameters()->Profile(ID, C);

168 }

169}

170

172 unsigned NumRequiredArgs = 0;

174 if (P->isTemplateParameterPack()) {

176 NumRequiredArgs += *Expansions;

177 continue;

178 }

179 break;

180 }

181

182 if (const auto *TTP = dyn_cast(P)) {

183 if (TTP->hasDefaultArgument())

184 break;

185 } else if (const auto *NTTP = dyn_cast(P)) {

186 if (NTTP->hasDefaultArgument())

187 break;

188 } else if (cast(P)->hasDefaultArgument())

189 break;

190

191 ++NumRequiredArgs;

192 }

193

194 return NumRequiredArgs;

195}

196

198 if (size() == 0)

199 return 0;

200

202 if (const auto *TTP = dyn_cast(FirstParm))

203 return TTP->getDepth();

204 else if (const auto *NTTP = dyn_cast(FirstParm))

205 return NTTP->getDepth();

206 else

207 return cast(FirstParm)->getDepth();

208}

209

214 P->setDeclContext(Owner);

215

216 if (const auto *TTP = dyn_cast(P))

219

220 if (P->isInvalidDecl())

222 }

224}

225

228 if (HasConstrainedParameters)

229 for (const NamedDecl *Param : *this) {

230 if (const auto *TTP = dyn_cast(Param)) {

231 if (const auto *TC = TTP->getTypeConstraint())

232 AC.push_back(TC->getImmediatelyDeclaredConstraint());

233 } else if (const auto *NTTP = dyn_cast(Param)) {

234 if (const Expr *E = NTTP->getPlaceholderTypeConstraint())

235 AC.push_back(E);

236 }

237 }

238 if (HasRequiresClause)

240}

241

243 return HasRequiresClause || HasConstrainedParameters;

244}

245

248 if (!InjectedArgs) {

250 llvm::transform(*this, InjectedArgs, [&](NamedDecl *ND) {

252 });

253 }

254 return {InjectedArgs, NumParams};

255}

256

259 unsigned Idx) {

261 return true;

263 if (const auto *ParamValueDecl =

264 dyn_cast(TemplParam))

265 if (ParamValueDecl->getType()->getContainedDeducedType())

266 return true;

267 return false;

268}

269

271

273 return new (C) char[sizeof(void*) * 2];

274}

275

276}

277

278

279

280

281

285 : NamedDecl(DK, DC, L, Name), TemplatedDecl(Decl), TemplateParams(Params) {}

286

287void TemplateDecl::anchor() {}

288

292 if (auto *FD = dyn_cast_or_null(getTemplatedDecl()))

293 if (const Expr *TRC = FD->getTrailingRequiresClause())

294 AC.push_back(TRC);

295}

296

299 return true;

300 if (auto *FD = dyn_cast_or_null(getTemplatedDecl()))

301 return FD->getTrailingRequiresClause();

302 return false;

303}

304

307 case TemplateDecl::TypeAliasTemplate:

308 case TemplateDecl::BuiltinTemplate:

309 return true;

310 default:

311 return false;

312 };

313}

314

315

316

317

318

319void RedeclarableTemplateDecl::anchor() {}

320

324

325

326

330 if (Prev->Common) {

331 Common = Prev->Common;

332 break;

333 }

334

335 PrevDecls.push_back(Prev);

336 }

337

338

340

341

342

344 }

345

346

348 Prev->Common = Common;

349

351}

352

354 bool OnlyPartial ) const {

357 return;

358

360 OnlyPartial);

361 return;

362}

363

368 return false;

369

370

371

372 if (TPL)

374 false);

375

377 Args);

378}

379

380template <class EntryType, typename... ProfileArguments>

383 llvm::FoldingSetVector &Specs, void *&InsertPos,

384 ProfileArguments &&...ProfileArgs) {

386

387 llvm::FoldingSetNodeID ID;

388 EntryType::Profile(ID, std::forward(ProfileArgs)...,

390 EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);

391 return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;

392}

393

394template <class EntryType, typename... ProfileArguments>

397 llvm::FoldingSetVector &Specs, void *&InsertPos,

398 ProfileArguments &&...ProfileArgs) {

399

401 Specs, InsertPos, std::forward(ProfileArgs)...))

403

405 std::forward(ProfileArgs)...))

406 return nullptr;

407

409 Specs, InsertPos, std::forward(ProfileArgs)...);

410}

411

412template<class Derived, class EntryType>

414 llvm::FoldingSetVector &Specializations, EntryType *Entry,

415 void *InsertPos) {

417

418 if (InsertPos) {

419#ifndef NDEBUG

420 auto Args = SETraits::getTemplateArgs(Entry);

421

422

423

424

426 void *CorrectInsertPos;

428 InsertPos == CorrectInsertPos &&

429 "given incorrect InsertPos for specialization");

430#endif

431 Specializations.InsertNode(Entry, InsertPos);

432 } else {

433 EntryType *Existing = Specializations.GetOrInsertNode(Entry);

434 (void)Existing;

436 "non-canonical specialization?");

437 }

438

440 L->AddedCXXTemplateSpecialization(cast(this),

441 SETraits::getDecl(Entry));

442}

443

444

445

446

447

456 return TD;

457}

458

463}

464

467 auto *CommonPtr = new (C) Common;

468 C.addDestruction(CommonPtr);

469 return CommonPtr;

470}

471

474}

475

476llvm::FoldingSetVector &

480}

481

484 void *&InsertPos) {

487}

488

493 InsertPos);

494}

495

498

499

500

501 if (!Base::Common)

502 return;

503

504 Common *ThisCommon = static_cast<Common *>(Base::Common);

505 Common *PrevCommon = nullptr;

508 if (Prev->Base::Common) {

509 PrevCommon = static_cast<Common *>(Prev->Base::Common);

510 break;

511 }

512 PreviousDecls.push_back(Prev);

513 }

514

515

516

517 if (!PrevCommon) {

518 for (auto *D : PreviousDecls)

519 D->Base::Common = ThisCommon;

520 return;

521 }

522

523

525 "Can't merge incompatible declarations!");

526

527 Base::Common = PrevCommon;

528}

529

530

531

532

533

543 return TD;

544}

545

550}

551

553 bool OnlyPartial ) const {

555}

556

557llvm::FoldingSetVector &

561}

562

563llvm::FoldingSetVector &

567}

568

571 auto *CommonPtr = new (C) Common;

572 C.addDestruction(CommonPtr);

573 return CommonPtr;

574}

575

578 void *&InsertPos) {

581}

582

584 void *InsertPos) {

587 InsertPos);

588}

589

595 TPL);

596}

597

601 ID.AddInteger(TemplateArgs.size());

604 TPL->Profile(ID, Context);

605}

606

609 void *InsertPos) {

610 if (InsertPos)

612 else {

615 (void)Existing;

616 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");

617 }

618

620 L->AddedCXXTemplateSpecialization(this, D);

621}

622

625 llvm::FoldingSetVector &PartialSpecs

627 PS.clear();

628 PS.reserve(PartialSpecs.size());

630 PS.push_back(P.getMostRecentDecl());

631}

632

638 if (Context.hasSameType(P.getInjectedSpecializationType(), T))

639 return P.getMostRecentDecl();

640 }

641

642 return nullptr;

643}

644

650 if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)

651 return P.getMostRecentDecl();

652 }

653

654 return nullptr;

655}

656

662

663

664

665

666

667

668

669

672 nullptr, false, TemplateName(this));

676}

677

678

679

680

681

685 bool Typename, bool ParameterPack, bool HasTypeConstraint,

686 std::optional NumExpanded) {

687 auto *TTPDecl =

688 new (C, DC,

689 additionalSizeToAlloc(HasTypeConstraint ? 1 : 0))

691 HasTypeConstraint, NumExpanded);

692 QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);

693 TTPDecl->setTypeForDecl(TTPType.getTypePtr());

694 return TTPDecl;

695}

696

699 return new (C, ID)

701 false, false, std::nullopt);

702}

703

706 bool HasTypeConstraint) {

707 return new (C, ID,

708 additionalSizeToAlloc(HasTypeConstraint ? 1 : 0))

710 false, HasTypeConstraint, std::nullopt);

711}

712

716}

717

722

723

724

728}

729

733 DefaultArgument.set(nullptr);

734 else

736}

737

740}

741

744}

745

748}

749

752 assert(HasTypeConstraint &&

753 "HasTypeConstraint=true must be passed at construction in order to "

754 "call setTypeConstraint");

755 assert(!TypeConstraintInitialized &&

756 "TypeConstraint was already initialized!");

757 new (getTrailingObjects())

759 TypeConstraintInitialized = true;

760}

761

762

763

764

765

766NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(

770 : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),

772 ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {

773 if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {

774 auto TypesAndInfos =

775 getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();

776 for (unsigned I = 0; I != NumExpandedTypes; ++I) {

777 new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);

778 TypesAndInfos[I].second = ExpandedTInfos[I];

779 }

780 }

781}

782

789 return new (C, DC,

790 additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,

794 TInfo);

795}

796

803 return new (C, DC,

804 additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,

806 ExpandedTypes.size(), AT && AT->isConstrained() ? 1 : 0))

808 ExpandedTypes, ExpandedTInfos);

809}

810

813 bool HasTypeConstraint) {

814 return new (C, ID, additionalSizeToAlloc<std::pair<QualType,

817 HasTypeConstraint ? 1 : 0))

819 0, 0, nullptr, QualType(), false, nullptr);

820}

821

824 unsigned NumExpandedTypes,

825 bool HasTypeConstraint) {

826 auto *NTTP =

827 new (C, ID,

828 additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>(

829 NumExpandedTypes, HasTypeConstraint ? 1 : 0))

831 0, 0, nullptr, QualType(), nullptr, {}, {});

832 NTTP->NumExpandedTypes = NumExpandedTypes;

833 return NTTP;

834}

835

841}

842

846}

847

851 DefaultArgument.set(nullptr);

852 else

854}

855

856

857

858

859

860void TemplateTemplateParmDecl::anchor() {}

861

862TemplateTemplateParmDecl::TemplateTemplateParmDecl(

866 : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),

868 ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {

869 if (!Expansions.empty())

870 std::uninitialized_copy(Expansions.begin(), Expansions.end(),

871 getTrailingObjects<TemplateParameterList *>());

872}

873

881}

882

889 return new (C, DC,

890 additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))

892}

893

897 false, nullptr, false, nullptr);

898}

899

902 unsigned NumExpansions) {

903 auto *TTP =

904 new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))

906 false, nullptr, {});

907 TTP->NumExpandedParams = NumExpansions;

908 return TTP;

909}

910

914}

915

919 DefaultArgument.set(nullptr);

920 else

922}

923

924

925

926

928 : NumArguments(Args.size()) {

929 std::uninitialized_copy(Args.begin(), Args.end(),

930 getTrailingObjects());

931}

932

936 void *Mem = Context.Allocate(totalSizeToAlloc(Args.size()));

938}

939

946 if (TemplateArgsAsWritten)

948 *TemplateArgsAsWritten);

949

950 void *Mem =

951 C.Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));

953 FD, Template, TSK, TemplateArgs, ArgsAsWritten, POI, MSInfo);

954}

955

956

957

958

959

967 : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,

969 SpecializedTemplate(SpecializedTemplate),

972}

973

975 Kind DK)

979

990 Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,

991 SpecializedTemplate, Args, PrevDecl);

992 Result->setMayHaveOutOfDateDef(false);

993

994

995

996

997

999 Result->setHasExternalLexicalStorage(

1001

1004}

1005

1011 Result->setMayHaveOutOfDateDef(false);

1013}

1014

1018

1019 const auto *PS = dyn_cast(this);

1021 PS ? PS->getTemplateArgsAsWritten() : nullptr) {

1023 OS, ArgsAsWritten->arguments(), Policy,

1025 } else {

1028 OS, TemplateArgs.asArray(), Policy,

1030 }

1031}

1032

1035 if (const auto *PartialSpec =

1036 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())

1037 return PartialSpec->PartialSpecialization->getSpecializedTemplate();

1038 return cast<ClassTemplateDecl *>(SpecializedTemplate);

1039}

1040

1049 assert(!Pattern.isNull() &&

1050 "Class template specialization without pattern?");

1051 if (const auto *CTPSD =

1053 return CTPSD->getSourceRange();

1054 return cast<ClassTemplateDecl *>(Pattern)->getSourceRange();

1055 }

1062 }

1074 }

1075 }

1076 llvm_unreachable("unhandled template specialization kind");

1077}

1078

1081 if (!Info) {

1082

1084 return;

1087 ExplicitInfo = Info;

1088 }

1089 Info->ExternKeywordLoc = Loc;

1090}

1091

1095 if (!Info) {

1096

1098 return;

1101 ExplicitInfo = Info;

1102 }

1103 Info->TemplateKeywordLoc = Loc;

1104}

1105

1106

1107

1108

1112 Expr *ConstraintExpr) {

1117 return TD;

1118}

1119

1123 nullptr, nullptr);

1124

1126}

1127

1128

1129

1130

1131ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl(

1134 : Decl(ImplicitConceptSpecialization, DC, SL),

1135 NumTemplateArgs(ConvertedArgs.size()) {

1136 setTemplateArguments(ConvertedArgs);

1137}

1138

1139ImplicitConceptSpecializationDecl::ImplicitConceptSpecializationDecl(

1140 EmptyShell Empty, unsigned NumTemplateArgs)

1141 : Decl(ImplicitConceptSpecialization, Empty),

1142 NumTemplateArgs(NumTemplateArgs) {}

1143

1147 return new (C, DC,

1148 additionalSizeToAlloc(ConvertedArgs.size()))

1150}

1151

1155 return new (C, ID, additionalSizeToAlloc(NumTemplateArgs))

1157}

1158

1161 assert(Converted.size() == NumTemplateArgs);

1162 std::uninitialized_copy(Converted.begin(), Converted.end(),

1163 getTrailingObjects());

1164}

1165

1166

1167

1168

1169void ClassTemplatePartialSpecializationDecl::anchor() {}

1170

1171ClassTemplatePartialSpecializationDecl::ClassTemplatePartialSpecializationDecl(

1177 Context, ClassTemplatePartialSpecialization, TK, DC, StartLoc, IdLoc,

1178 SpecializedTemplate, Args, PrevDecl),

1179 TemplateParams(Params), InstantiatedFromMember(nullptr, false) {

1182}

1183

1192 Context, TK, DC, StartLoc, IdLoc, Params, SpecializedTemplate, Args,

1193 PrevDecl);

1195 Result->setMayHaveOutOfDateDef(false);

1196

1199}

1200

1205 Result->setMayHaveOutOfDateDef(false);

1207}

1208

1213 return MT->getSourceRange();

1219}

1220

1221

1222

1223

1224

1225void FriendTemplateDecl::anchor() {}

1226

1233 if (!Params.empty()) {

1235 llvm::copy(Params, TPL);

1236 }

1237 return new (Context, DC)

1239}

1240

1244}

1245

1246

1247

1248

1249

1258 return TD;

1259}

1260

1265}

1266

1269 auto *CommonPtr = new (C) Common;

1270 C.addDestruction(CommonPtr);

1271 return CommonPtr;

1272}

1273

1274

1275

1276

1277

1280 while (CurD) {

1282 return CurD;

1284 }

1285 return nullptr;

1286}

1287

1296 return TD;

1297}

1298

1303}

1304

1306 bool OnlyPartial ) const {

1308}

1309

1310llvm::FoldingSetVector &

1314}

1315

1316llvm::FoldingSetVector &

1320}

1321

1324 auto *CommonPtr = new (C) Common;

1325 C.addDestruction(CommonPtr);

1326 return CommonPtr;

1327}

1328

1331 void *&InsertPos) {

1334}

1335

1337 void *InsertPos) {

1340}

1341

1346 TPL);

1347}

1348

1352 ID.AddInteger(TemplateArgs.size());

1355 TPL->Profile(ID, Context);

1356}

1357

1360 if (InsertPos)

1362 else {

1365 (void)Existing;

1366 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");

1367 }

1368

1370 L->AddedCXXTemplateSpecialization(this, D);

1371}

1372

1375 llvm::FoldingSetVector &PartialSpecs =

1377 PS.clear();

1378 PS.reserve(PartialSpecs.size());

1380 PS.push_back(P.getMostRecentDecl());

1381}

1382

1388 if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)

1389 return P.getMostRecentDecl();

1390 }

1391

1392 return nullptr;

1393}

1394

1395

1396

1397

1398

1403 : VarDecl(DK, Context, DC, StartLoc, IdLoc,

1405 SpecializedTemplate(SpecializedTemplate),

1408

1414

1420 VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,

1421 SpecializedTemplate, T, TInfo, S, Args);

1422}

1423

1427 return new (C, ID)

1429}

1430

1434

1435 const auto *PS = dyn_cast(this);

1437 PS ? PS->getTemplateArgsAsWritten() : nullptr) {

1439 OS, ArgsAsWritten->arguments(), Policy,

1441 } else {

1444 OS, TemplateArgs.asArray(), Policy,

1446 }

1447}

1448

1450 if (const auto *PartialSpec =

1451 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())

1452 return PartialSpec->PartialSpecialization->getSpecializedTemplate();

1453 return cast<VarTemplateDecl *>(SpecializedTemplate);

1454}

1455

1463 assert(!Pattern.isNull() &&

1464 "Variable template specialization without pattern?");

1465 if (const auto *VTPSD =

1467 return VTPSD->getSourceRange();

1468 VarTemplateDecl *VTD = cast<VarTemplateDecl *>(Pattern);

1471 return Definition->getSourceRange();

1472 }

1474 }

1481 }

1493 }

1494 }

1495 llvm_unreachable("unhandled template specialization kind");

1496}

1497

1500 if (!Info) {

1501

1503 return;

1506 ExplicitInfo = Info;

1507 }

1508 Info->ExternKeywordLoc = Loc;

1509}

1510

1513 if (!Info) {

1514

1516 return;

1519 ExplicitInfo = Info;

1520 }

1521 Info->TemplateKeywordLoc = Loc;

1522}

1523

1524

1525

1526

1527

1528void VarTemplatePartialSpecializationDecl::anchor() {}

1529

1530VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(

1536 DC, StartLoc, IdLoc, SpecializedTemplate, T,

1537 TInfo, S, Args),

1538 TemplateParams(Params), InstantiatedFromMember(nullptr, false) {

1541}

1542

1550 Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo, S,

1551 Args);

1554}

1555

1560}

1561

1566 return MT->getSourceRange();

1572}

1573

1576

1579 nullptr, true, false,

1580 false);

1581 T->setImplicit(true);

1582

1583

1585 C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));

1588 nullptr, TI->getType(), true, TI);

1589 N->setImplicit(true);

1590

1591

1595

1596

1599 false, nullptr, false, TPL);

1600 TemplateTemplateParm->setImplicit(true);

1601

1602

1605 nullptr, true, false,

1606 false);

1607 TemplateTypeParm->setImplicit(true);

1608

1609

1611 QualType(TemplateTypeParm->getTypeForDecl(), 0));

1614 nullptr, TInfo->getType(), false, TInfo);

1615 NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,

1616 NonTypeTemplateParm};

1617

1618

1621}

1622

1625

1626 TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());

1629 nullptr, TInfo->getType(), false, TInfo);

1630

1631

1634 nullptr, true, true,

1635 false);

1636 Ts->setImplicit(true);

1637

1638

1639 NamedDecl *Params[] = {Index, Ts};

1642 nullptr);

1643}

1644

1647

1648 auto *Args =

1650 1, 0, nullptr,

1651 false, true);

1652

1653

1656

1657

1660 false, nullptr,

1661 false, BaseTemplateList);

1662

1663

1664 auto *TypeMember =

1666 1, 0, nullptr,

1667 false, false);

1668

1669

1670 auto *HasTypeMemberList =

1673

1674

1677 false, nullptr,

1678 false, HasTypeMemberList);

1679

1680

1682 C, DC, {}, {}, 0, 2, nullptr,

1683 false, false);

1684

1685

1688 nullptr, false, true);

1689

1690

1691

1692

1695 {BaseTemplate, HasTypeMember, HasNoTypeMember, Ts}, SourceLocation(),

1696 nullptr);

1697}

1698

1701 switch (BTK) {

1708 }

1709

1710 llvm_unreachable("unhandled BuiltinTemplateKind!");

1711}

1712

1713void BuiltinTemplateDecl::anchor() {}

1714

1720 BTK(BTK) {}

1721

1725 DeclContext *DC = C.getTranslationUnitDecl();

1727 C.addDestruction(&TPOD->Value);

1728 return TPOD;

1729}

1730

1734 C.addDestruction(&TPOD->Value);

1735 return TPOD;

1736}

1737

1740 OS << "<template param ";

1742 OS << ">";

1743}

1744

1747}

1748

1753}

1754

1757}

1758

1762}

1763

1766 case Decl::Kind::CXXRecord:

1767 return cast(D)

1768 ->getDescribedTemplate()

1769 ->getTemplateParameters();

1770 case Decl::Kind::ClassTemplate:

1771 return cast(D)->getTemplateParameters();

1772 case Decl::Kind::ClassTemplateSpecialization: {

1773 const auto *CTSD = cast(D);

1774 auto P = CTSD->getSpecializedTemplateOrPartial();

1775 if (const auto *CTPSD =

1777 return CTPSD->getTemplateParameters();

1778 return cast<ClassTemplateDecl *>(P)->getTemplateParameters();

1779 }

1780 case Decl::Kind::ClassTemplatePartialSpecialization:

1781 return cast(D)

1782 ->getTemplateParameters();

1783 case Decl::Kind::TypeAliasTemplate:

1784 return cast(D)->getTemplateParameters();

1785 case Decl::Kind::BuiltinTemplate:

1786 return cast(D)->getTemplateParameters();

1787 case Decl::Kind::CXXDeductionGuide:

1788 case Decl::Kind::CXXConversion:

1789 case Decl::Kind::CXXConstructor:

1790 case Decl::Kind::CXXDestructor:

1791 case Decl::Kind::CXXMethod:

1792 case Decl::Kind::Function:

1793 return cast(D)

1794 ->getTemplateSpecializationInfo()

1795 ->getTemplate()

1796 ->getTemplateParameters();

1797 case Decl::Kind::FunctionTemplate:

1798 return cast(D)->getTemplateParameters();

1799 case Decl::Kind::VarTemplate:

1800 return cast(D)->getTemplateParameters();

1801 case Decl::Kind::VarTemplateSpecialization: {

1802 const auto *VTSD = cast(D);

1803 auto P = VTSD->getSpecializedTemplateOrPartial();

1804 if (const auto *VTPSD =

1806 return VTPSD->getTemplateParameters();

1807 return cast<VarTemplateDecl *>(P)->getTemplateParameters();

1808 }

1809 case Decl::Kind::VarTemplatePartialSpecialization:

1810 return cast(D)

1811 ->getTemplateParameters();

1812 case Decl::Kind::TemplateTemplateParm:

1813 return cast(D)->getTemplateParameters();

1814 case Decl::Kind::Concept:

1815 return cast(D)->getTemplateParameters();

1816 default:

1817 llvm_unreachable("Unhandled templated declaration kind");

1818 }

1819}

Defines the clang::ASTContext interface.

Defines enum values for all the target-independent builtin functions.

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

static TemplateParameterList * createTypePackElementParameterList(const ASTContext &C, DeclContext *DC)

static bool DefaultTemplateArgumentContainsUnexpandedPack(const TemplateParam &P)

static TemplateParameterList * createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC)

static bool AdoptTemplateParameterList(TemplateParameterList *Params, DeclContext *Owner)

static TemplateParameterList * createBuiltinTemplateParameterList(const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK)

static TemplateParameterList * createBuiltinCommonTypeList(const ASTContext &C, DeclContext *DC)

Defines the C++ template declaration subclasses.

Defines the clang::Expr interface and subclasses for C++ expressions.

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

This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes,...

static StringRef getIdentifier(const Token &Tok)

Defines the clang::SourceLocation class and associated facilities.

Defines the clang::TypeLoc interface and its subclasses.

C Language Family Type Representation.

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

void printPretty(raw_ostream &OS, const ASTContext &Ctx, QualType Ty) const

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

QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const

QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const

getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...

bool hasSameType(QualType T1, QualType T2) const

Determine whether the given types T1 and T2 are equivalent.

TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const

Retrieve the template name that represents a qualified template name such as std::vector.

QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const

Return the unique reference to the type for the specified type declaration.

TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl) const

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

ExternalASTSource * getExternalSource() const

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

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

Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.

bool isConstrained() const

Represents a C++ struct/union/class.

Declaration of a class template.

void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D, void *InsertPos)

Insert the specified partial specialization knowing that it is not already in.

llvm::FoldingSetVector< ClassTemplateSpecializationDecl > & getSpecializations() const

Retrieve the set of specializations of this class template.

CXXRecordDecl * getTemplatedDecl() const

Get the underlying class declarations of the template.

llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations() const

Retrieve the set of partial specializations of this class template.

ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)

Return the partial specialization with the provided arguments if it exists, otherwise return the inse...

CommonBase * newCommon(ASTContext &C) const override

static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)

Create a class template node.

ClassTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *D)

Find a class template partial specialization which was instantiated from the given member partial spe...

void LoadLazySpecializations(bool OnlyPartial=false) const

Load any lazily-loaded specializations from the external source.

void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos)

Insert the specified specialization knowing that it is not already in.

QualType getInjectedClassNameSpecialization()

Retrieve the template specialization type of the injected-class-name for this class template.

Common * getCommonPtr() const

ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)

Return the specialization with the provided arguments if it exists, otherwise return the insertion po...

static ClassTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create an empty class template node.

ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const

Retrieve the member class template partial specialization from which this particular class template p...

static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)

void Profile(llvm::FoldingSetNodeID &ID) const

bool isMemberSpecialization() const

Determines whether this class template partial specialization template was a specialization of a memb...

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

static ClassTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

Represents a class template specialization, which refers to a class template with a given set of temp...

TemplateSpecializationKind getSpecializationKind() const

Determine the kind of specialization that this declaration represents.

const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const

Retrieve the template argument list as written in the sources, if any.

ClassTemplateDecl * getSpecializedTemplate() const

Retrieve the template that this specialization specializes.

ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)

static ClassTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const

Retrieve the class template or class template partial specialization which was specialized by this.

void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override

Appends a human-readable name for this declaration into the given stream.

void setExternKeywordLoc(SourceLocation Loc)

Sets the location of the extern keyword.

const TemplateArgumentList & getTemplateArgs() const

Retrieve the template arguments of the class template specialization.

SourceLocation getExternKeywordLoc() const

Gets the location of the extern keyword, if present.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

SourceLocation getTemplateKeywordLoc() const

Gets the location of the template keyword, if present.

void setTemplateKeywordLoc(SourceLocation Loc)

Sets the location of the template keyword.

static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)

Declaration of a C++20 concept.

static ConceptDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

static ConceptDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, Expr *ConstraintExpr=nullptr)

A reference to a concept and its template args, as it appears in the code.

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

bool hasExternalLexicalStorage() const

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

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

ASTContext & getASTContext() const LLVM_READONLY

ASTMutationListener * getASTMutationListener() const

void setInvalidDecl(bool Invalid=true)

setInvalidDecl - Indicates the Decl had a semantic error.

Kind

Lists the kind of concrete classes of Decl.

bool isCanonicalDecl() const

Whether this particular Decl is a canonical one.

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

The name of a declaration.

Represents a ValueDecl that came out of a declarator.

SourceLocation getOuterLocStart() const

Return start of source range taking into account any outer template declarations.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

unsigned getNumTemplateParameterLists() const

void set(ArgType Arg)

Set the default argument.

This represents one expression.

bool containsUnexpandedParameterPack() const

Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).

virtual bool LoadExternalSpecializations(const Decl *D, bool OnlyPartial)

Load all the external specializations for the Decl.

Declaration of a friend template.

static FriendTemplateDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation Loc, MutableArrayRef< TemplateParameterList * > Params, FriendUnion Friend, SourceLocation FriendLoc)

llvm::PointerUnion< NamedDecl *, TypeSourceInfo * > FriendUnion

static FriendTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a function declaration or definition.

Declaration of a template function.

FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)

Return the specialization with the provided arguments if it exists, otherwise return the insertion po...

void addSpecialization(FunctionTemplateSpecializationInfo *Info, void *InsertPos)

Add a specialization of this function template.

CommonBase * newCommon(ASTContext &C) const override

Common * getCommonPtr() const

FunctionTemplateDecl * getPreviousDecl()

Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...

static FunctionTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create an empty function template node.

static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)

Create a function template node.

llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > & getSpecializations() const

Retrieve the set of function template specializations of this function template.

void mergePrevDecl(FunctionTemplateDecl *Prev)

Merge Prev with our RedeclarableTemplateDecl::Common.

void LoadLazySpecializations() const

Load any lazily-loaded specializations from the external source.

Provides information about a function template specialization, which is a FunctionDecl that has been ...

static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI, MemberSpecializationInfo *MSInfo)

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

void setTemplateArguments(ArrayRef< TemplateArgument > Converted)

static ImplicitConceptSpecializationDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation SL, ArrayRef< TemplateArgument > ConvertedArgs)

static ImplicitConceptSpecializationDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID, unsigned NumTemplateArgs)

Provides information a specialization of a member of a class template, which may be a member function...

This represents a decl that may have a name.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const

Appends a human-readable name for this declaration into the given stream.

NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.

static NonTypeTemplateParmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, bool HasTypeConstraint)

SourceLocation getDefaultArgumentLoc() const

Retrieve the location of the default argument, if any.

bool hasDefaultArgument() const

Determine whether this template parameter has a default argument.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

bool defaultArgumentWasInherited() const

Determines whether the default argument was inherited from a previous declaration of this template.

const TemplateArgumentLoc & getDefaultArgument() const

Retrieve the default argument, if any.

static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)

void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)

Set the default argument for this template parameter, and whether that default argument was inherited...

A (possibly-)qualified type.

bool isNull() const

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

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const

QualType getUnqualifiedType() const

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

Declaration of a redeclarable template.

SpecEntryTraits< EntryType >::DeclType * findSpecializationLocally(llvm::FoldingSetVector< EntryType > &Specs, void *&InsertPos, ProfileArguments &&...ProfileArgs)

void loadLazySpecializationsImpl(bool OnlyPartial=false) const

CommonBase * getCommonPtr() const

Retrieves the "common" pointer shared by all (re-)declarations of the same template.

SpecEntryTraits< EntryType >::DeclType * findSpecializationImpl(llvm::FoldingSetVector< EntryType > &Specs, void *&InsertPos, ProfileArguments &&...ProfileArgs)

CommonBase * Common

Pointer to the common data shared by all declarations of this template.

virtual CommonBase * newCommon(ASTContext &C) const =0

RedeclarableTemplateDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this template.

void addSpecializationImpl(llvm::FoldingSetVector< EntryType > &Specs, EntryType *Entry, void *InsertPos)

ArrayRef< TemplateArgument > getInjectedTemplateArgs(const ASTContext &Context) const

Retrieve the "injected" template arguments that correspond to the template parameters of this templat...

RedeclarableTemplateDecl * getPreviousDecl()

Return the previous declaration of this declaration or NULL if this is the first declaration.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

A trivial tuple used to represent a source range.

void setBegin(SourceLocation b)

SourceLocation getBegin() const

void setEnd(SourceLocation e)

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const

Produce a unique representation of the given statement.

bool isThisDeclarationADefinition() const

Return true if this declaration is a completion definition of the type.

bool isCompleteDefinition() const

Return true if this decl has its body fully specified.

unsigned getNumTemplateParameterLists() const

A convenient class for passing around template argument information.

A template argument list.

static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)

Create a new template argument list that copies the given set of template arguments.

ArrayRef< TemplateArgument > asArray() const

Produce this as an array ref.

Location wrapper for a TemplateArgument.

SourceLocation getLocation() const

const TemplateArgument & getArgument() const

SourceRange getSourceRange() const LLVM_READONLY

Represents a template argument.

bool isNull() const

Determine whether this template argument has no value.

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

TemplateParameterList * TemplateParams

bool hasAssociatedConstraints() const

NamedDecl * getTemplatedDecl() const

Get the underlying, templated declaration.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const

Get the total constraint-expression associated with this template, including constraint-expressions d...

TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

Represents a C++ template name within the type system.

A template parameter object.

void printAsExpr(llvm::raw_ostream &OS) const

Print this object as an equivalent expression.

const APValue & getValue() const

void printName(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const override

Print this template parameter object in a human-readable format.

void printAsInit(llvm::raw_ostream &OS) const

Print this object as an initializer suitable for a variable of the object's type.

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

NamedDecl * getParam(unsigned Idx)

ArrayRef< TemplateArgument > getInjectedTemplateArgs(const ASTContext &Context)

Get the template argument list of the template parameter list.

unsigned getDepth() const

Get the depth of this template parameter list in the set of template parameter lists.

bool hasAssociatedConstraints() const

unsigned getMinRequiredArguments() const

Returns the minimum number of arguments needed to form a template specialization.

static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)

Expr * getRequiresClause()

The constraint-expression of the associated requires-clause.

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) const

void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr * > &AC) const

All associated constraints derived from this template parameter list, including the requires clause a...

ArrayRef< NamedDecl * > asArray()

static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)

SourceLocation getTemplateLoc() const

Defines the position of a template parameter within a template parameter list.

TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.

const TemplateArgumentLoc & getDefaultArgument() const

Retrieve the default argument, if any.

static TemplateTemplateParmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

SourceLocation getDefaultArgumentLoc() const

Retrieve the location of the default argument, if any.

void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)

Set the default argument for this template parameter, and whether that default argument was inherited...

static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)

bool hasDefaultArgument() const

Determine whether this template parameter has a default argument.

Declaration of a template type parameter.

SourceLocation getDefaultArgumentLoc() const

Retrieves the location of the default argument declaration.

const TemplateArgumentLoc & getDefaultArgument() const

Retrieve the default argument, if any.

unsigned getIndex() const

Retrieve the index of the template parameter.

static TemplateTypeParmDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)

static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)

bool hasDefaultArgument() const

Determine whether this template parameter has a default argument.

bool defaultArgumentWasInherited() const

Determines whether the default argument was inherited from a previous declaration of this template.

bool isParameterPack() const

Returns whether this is a parameter pack.

unsigned getDepth() const

Retrieve the depth of the template parameter.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)

void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)

Set the default argument for this template parameter.

Declaration of an alias template.

CommonBase * newCommon(ASTContext &C) const override

static TypeAliasTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create an empty alias template node.

static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)

Create a function template node.

Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...

Expr * getImmediatelyDeclaredConstraint() const

Get the immediately-declared constraint expression introduced by this type-constraint,...

const Type * getTypeForDecl() const

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

SourceLocation getBeginLoc() const LLVM_READONLY

A container of type source information.

QualType getType() const

Return the type wrapped by this type source info.

const T * castAs() const

Member-template castAs.

AutoType * getContainedAutoType() const

Get the AutoType whose type will be deduced for a variable with an initializer of this type.

Represents a variable declaration or definition.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

@ Definition

This declaration is definitely a definition.

Declaration of a variable template.

VarTemplateDecl * getDefinition()

VarTemplateDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this template.

void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D, void *InsertPos)

Insert the specified partial specialization knowing that it is not already in.

Common * getCommonPtr() const

VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, TemplateParameterList *TPL, void *&InsertPos)

Return the partial specialization with the provided arguments if it exists, otherwise return the inse...

void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)

Insert the specified specialization knowing that it is not already in.

VarTemplateDecl * getPreviousDecl()

Retrieve the previous declaration of this variable template, or nullptr if no such declaration exists...

CommonBase * newCommon(ASTContext &C) const override

void LoadLazySpecializations(bool OnlyPartial=false) const

Load any lazily-loaded specializations from the external source.

static VarTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create an empty variable template node.

static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)

Create a variable template node.

llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations() const

Retrieve the set of partial specializations of this class template.

llvm::FoldingSetVector< VarTemplateSpecializationDecl > & getSpecializations() const

Retrieve the set of specializations of this variable template.

bool isThisDeclarationADefinition() const

Returns whether this template declaration defines the primary variable pattern.

VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)

Return the specialization with the provided arguments if it exists, otherwise return the insertion po...

VarTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(VarTemplatePartialSpecializationDecl *D)

Find a variable template partial specialization which was instantiated from the given member partial ...

static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

VarTemplatePartialSpecializationDecl * getInstantiatedFromMember() const

Retrieve the member variable template partial specialization from which this particular variable temp...

bool isMemberSpecialization() const

Determines whether this variable template partial specialization was a specialization of a member par...

void Profile(llvm::FoldingSetNodeID &ID) const

static VarTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a variable template specialization, which refers to a variable template with a given set o...

VarTemplateSpecializationDecl(Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)

const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const

Retrieve the template argument list as written in the sources, if any.

void setTemplateKeywordLoc(SourceLocation Loc)

Sets the location of the template keyword.

const TemplateArgumentList & getTemplateArgs() const

Retrieve the template arguments of the variable template specialization.

SourceLocation getTemplateKeywordLoc() const

Gets the location of the template keyword, if present.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)

llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const

Retrieve the variable template or variable template partial specialization which was specialized by t...

TemplateSpecializationKind getSpecializationKind() const

Determine the kind of specialization that this declaration represents.

VarTemplateDecl * getSpecializedTemplate() const

Retrieve the template that this specialization specializes.

SourceLocation getExternKeywordLoc() const

Gets the location of the extern keyword, if present.

static VarTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setExternKeywordLoc(SourceLocation Loc)

Sets the location of the extern keyword.

void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override

Appends a human-readable name for this declaration into the given stream.

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

StorageClass

Storage classes.

void * allocateDefaultArgStorageChain(const ASTContext &C)

@ Result

The result type of a method or function.

TemplateParameterList * getReplacedTemplateParameterList(Decl *D)

Internal helper used by Subst* nodes to retrieve the parameter list for their AssociatedDecl.

TagTypeKind

The kind of a tag type.

BuiltinTemplateKind

Kinds of BuiltinTemplateDecl.

@ BTK__type_pack_element

This names the __type_pack_element BuiltinTemplateDecl.

@ BTK__builtin_common_type

This names the __builtin_common_type BuiltinTemplateDecl.

@ BTK__make_integer_seq

This names the __make_integer_seq BuiltinTemplateDecl.

std::optional< unsigned > getExpandedPackSize(const NamedDecl *Param)

Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...

const FunctionProtoType * T

void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)

Print a template argument list, including the '<' and '>' enclosing the template arguments.

TemplateSpecializationKind

Describes the kind of template specialization that a particular template specialization declaration r...

@ TSK_ExplicitInstantiationDefinition

This template specialization was instantiated from a template due to an explicit instantiation defini...

@ TSK_ExplicitInstantiationDeclaration

This template specialization was instantiated from a template due to an explicit instantiation declar...

@ TSK_ExplicitSpecialization

This template specialization was declared or defined by an explicit specialization (C++ [temp....

@ TSK_ImplicitInstantiation

This template specialization was implicitly instantiated from a template.

@ TSK_Undeclared

This template specialization was formed from a template-id but has not yet been declared,...

@ Struct

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

@ Typename

The "typename" keyword precedes the qualified type name, e.g., typename T::type.

Represents an explicit template argument list in C++, e.g., the "" in "sort".

static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)

Data that is common to all of the declarations of a given class template.

llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > PartialSpecializations

The class template partial specializations for this class template.

llvm::FoldingSetVector< ClassTemplateSpecializationDecl > Specializations

The class template specializations for this class template, including explicit specializations and in...

QualType InjectedClassNameType

The injected-class-name type for this class template.

A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...

Provides information about an explicit instantiation of a variable or class template.

const ASTTemplateArgumentListInfo * TemplateArgsAsWritten

The template arguments as written..

Data that is common to all of the declarations of a given function template.

llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > Specializations

The function template specializations for this function template, including explicit specializations ...

Describes how types, statements, expressions, and declarations should be printed.

unsigned AlwaysIncludeTypeForTemplateArgument

Whether to use type suffixes (eg: 1U) on integral non-type template parameters.

Data that is common to all of the declarations of a given variable template.

llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > PartialSpecializations

The variable template partial specializations for this variable template.

llvm::FoldingSetVector< VarTemplateSpecializationDecl > Specializations

The variable template specializations for this variable template, including explicit specializations ...