DeclTemplate.h Source File (original) (raw)

14#ifndef LLVM_CLANG_AST_DECLTEMPLATE_H

15#define LLVM_CLANG_AST_DECLTEMPLATE_H

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

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

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

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

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

34#include "llvm/ADT/iterator_range.h"

35#include "llvm/Support/Casting.h"

36#include "llvm/Support/Compiler.h"

37#include "llvm/Support/TrailingObjects.h"

38#include

39#include

40#include

41#include

42#include

43#include

48class ClassTemplateDecl;

49class ClassTemplatePartialSpecializationDecl;

50class Expr;

51class FunctionTemplateDecl;

52class IdentifierInfo;

53class NonTypeTemplateParmDecl;

54class TemplateDecl;

55class TemplateTemplateParmDecl;

56class TemplateTypeParmDecl;

57class ConceptDecl;

58class UnresolvedSetImpl;

59class VarTemplateDecl;

60class VarTemplatePartialSpecializationDecl;

72 : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,

73 Expr *> {

85 unsigned NumParams : 29;

89 LLVM_PREFERRED_TYPE(bool)

90 unsigned ContainsUnexpandedParameterPack : 1;

93 LLVM_PREFERRED_TYPE(bool)

94 unsigned HasRequiresClause : 1;

98 LLVM_PREFERRED_TYPE(bool)

99 unsigned HasConstrainedParameters : 1;

100

101protected:

105

107 return NumParams;

108 }

109

111 return HasRequiresClause ? 1 : 0;

112 }

113

114public:

115 template <size_t N, bool HasRequiresClause>

118

124 Expr *RequiresClause);

125

127

128

130

131

133

134 iterator begin() { return getTrailingObjects<NamedDecl *>(); }

138

139 unsigned size() const { return NumParams; }

140 bool empty() const { return NumParams == 0; }

141

145 }

146

148 assert(Idx < size() && "Template parameter index out-of-range");

149 return begin()[Idx];

150 }

152 assert(Idx < size() && "Template parameter index out-of-range");

153 return begin()[Idx];

154 }

155

156

157

158

159

160

162

163

164

165

166

167

169

170

171

173

174

177 if (P->isParameterPack())

178 return true;

179 return false;

180 }

181

182

184 return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;

185 }

186

187

189 return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;

190 }

191

192

193

194

195

196

197

199

201

202

204

208

210 return SourceRange(TemplateLoc, RAngleLoc);

211 }

212

214 bool OmitTemplateKW = false) const;

216 const PrintingPolicy &Policy, bool OmitTemplateKW = false) const;

217

220 unsigned Idx);

221};

222

223

224

225

226template <size_t N, bool HasRequiresClause>

228 : public TemplateParameterList::FixedSizeStorageOwner {

229 typename TemplateParameterList::FixedSizeStorage<

231 N, HasRequiresClause ? 1u : 0u

233

234public:

240 Expr *RequiresClause)

241 : FixedSizeStorageOwner(

242 (assert(N == Params.size()),

243 assert(HasRequiresClause == (RequiresClause != nullptr)),

245 TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}

246};

247

248

250 : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {

251

252

253 unsigned NumArguments;

254

255

256

258

259public:

261

264

265

266

269

270

272 assert(Idx < NumArguments && "Invalid template argument index");

273 return data()[Idx];

274 }

275

276

278

279

282 }

283

284

285

286 unsigned size() const { return NumArguments; }

287

288

290 return getTrailingObjects();

291 }

292};

293

295

296

297

298

299

300

301

302

303

304template<typename ParmDecl, typename ArgType>

306

307

308

309 struct Chain {

310 ParmDecl *PrevDeclWithDefaultArg;

312 };

313 static_assert(sizeof(Chain) == sizeof(void *) * 2,

314 "non-pointer argument type?");

315

316 llvm::PointerUnion<ArgType, ParmDecl*, Chain*> ValueOrInherited;

317

318 static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {

320 if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())

321 Parm = Prev;

322 assert(!isa<ParmDecl *>(Parm->getDefaultArgStorage().ValueOrInherited) &&

323 "should only be one level of indirection");

324 return Parm;

325 }

326

327public:

329

330

331 bool isSet() const { return !ValueOrInherited.isNull(); }

332

333

334

335 bool isInherited() const { return isa<ParmDecl *>(ValueOrInherited); }

336

337

338

339 ArgType get() const {

341 if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())

342 Storage = &Prev->getDefaultArgStorage();

343 if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())

344 return C->Value;

345 return cast(Storage->ValueOrInherited);

346 }

347

348

349

351 if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())

352 return D;

353 if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())

354 return C->PrevDeclWithDefaultArg;

355 return nullptr;

356 }

357

358

359 void set(ArgType Arg) {

360 assert( isSet () && "default argument already set");

361 ValueOrInherited = Arg;

362 }

363

364

366 InheritedFrom = getParmOwningDefaultArg(InheritedFrom);

368 ValueOrInherited = InheritedFrom;

369 else if ([[maybe_unused]] auto *D =

370 dyn_cast<ParmDecl *>(ValueOrInherited)) {

371 assert(C.isSameDefaultTemplateArgument(D, InheritedFrom));

372 ValueOrInherited =

374 } else if (auto *Inherited = dyn_cast<Chain *>(ValueOrInherited)) {

375 assert(C.isSameDefaultTemplateArgument(Inherited->PrevDeclWithDefaultArg,

376 InheritedFrom));

377 Inherited->PrevDeclWithDefaultArg = InheritedFrom;

378 } else

380 Chain{InheritedFrom, cast(ValueOrInherited)};

381 }

382

383

385 ValueOrInherited = ArgType();

386 }

387};

388

389

390

391

392

393

394

395

396

397

399 void anchor() override;

400

401protected:

402

405

406

407

410 : TemplateDecl(DK, DC, L, Name, Params, nullptr) {}

411

412public:

415

416

419 }

420

421

422

423

424

426

428

429

431

432

434

435

437

439 return K >= firstTemplate && K <= lastTemplate;

440 }

441

445 }

446

447protected:

450

451public:

454 }

455

456

459 assert(TemplatedDecl == NewTemplatedDecl && "Inconsistent TemplatedDecl");

460 else

462 }

463};

464

465

466

467

469 : public llvm::FoldingSetNode,

470 private llvm::TrailingObjects<FunctionTemplateSpecializationInfo,

471 MemberSpecializationInfo *> {

472

473

474 llvm::PointerIntPair<FunctionDecl *, 1, bool> Function;

475

476

477

478

479

480 llvm::PointerIntPair<FunctionTemplateDecl *, 2> Template;

481

482public:

483

484

486

487

488

490

491

492

494

495private:

501 : Function(FD, MSInfo ? true : false), Template(Template, TSK - 1),

505 if (MSInfo)

506 getTrailingObjects<MemberSpecializationInfo *>()[0] = MSInfo;

507 }

508

509 size_t numTrailingObjects(OverloadToken<MemberSpecializationInfo*>) const {

511 }

512

513public:

515

521

522

524

525

527

528

531 }

532

535 }

536

537

538

539

543 }

544

545

548 "Cannot encode TSK_Undeclared for a function template specialization");

549 Template.setInt(TSK - 1);

550 }

551

552

553

554

555

556

559 }

560

561

562

565 }

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

598 return numTrailingObjects(OverloadToken<MemberSpecializationInfo *>())

599 ? getTrailingObjects<MemberSpecializationInfo *>()[0]

600 : nullptr;

601 }

602

605 }

606

607 static void

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

613 }

614};

615

616

617

618

620

621

622 llvm::PointerIntPair<NamedDecl *, 2> MemberAndTSK;

623

624

626

627public:

628 explicit

631 : MemberAndTSK(IF, TSK - 1), PointOfInstantiation(POI) {

633 "Cannot encode undeclared template specializations for members");

634 }

635

636

637

639

640

643 }

644

647 }

648

649

652 "Cannot encode undeclared template specializations for members");

653 MemberAndTSK.setInt(TSK - 1);

654 }

655

656

657

658

660 return PointOfInstantiation;

661 }

662

663

665 PointOfInstantiation = POI;

666 }

667};

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

692 : private llvm::TrailingObjects<DependentFunctionTemplateSpecializationInfo,

693 FunctionTemplateDecl *> {

694 friend TrailingObjects;

695

696

697 unsigned NumCandidates;

698

702

703public:

704

706

710

711

713 return {getTrailingObjects<FunctionTemplateDecl *>(), NumCandidates};

714 }

715};

716

717

719 public Redeclarable

720{

722

725 }

726

729 }

730

733 }

734

735 void anchor() override;

736

737protected:

740

742 return D;

743 }

744

746 return D->getTemplateArgs().asArray();

747 }

748 };

749

750 template <typename EntryType, typename SETraits = SpecEntryTraits,

751 typename DeclType = typename SETraits::DeclType>

753 : llvm::iterator_adaptor_base<

754 SpecIterator<EntryType, SETraits, DeclType>,

755 typename llvm::FoldingSetVector::iterator,

756 typename std::iterator_traits<typename llvm::FoldingSetVector<

757 EntryType>::iterator>::iterator_category,

758 DeclType *, ptrdiff_t, DeclType *, DeclType *> {

761 typename llvm::FoldingSetVector::iterator SetIter)

762 : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}

763

765 return SETraits::getDecl(&*this->I)->getMostRecentDecl();

766 }

767

769 };

770

771 template

772 static SpecIterator

775 }

776

778

781

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

785 void *&InsertPos, ProfileArguments &&...ProfileArgs);

786

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

790 void *&InsertPos,

791 ProfileArguments &&...ProfileArgs);

792

793 template <class Derived, class EntryType>

795 EntryType *Entry, void *InsertPos);

796

799

800

801

802

803

804

805 llvm::PointerIntPair<RedeclarableTemplateDecl *, 1, bool>

807 };

808

809

810

812

813

814

815

817

819

820

825

826public:

831

832

835 }

838 }

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

860 }

861

862

864 assert(getCommonPtr()->InstantiatedFromMember.getPointer() &&

865 "Only member templates can be member template specializations");

867 }

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

907 }

908

910 assert( getCommonPtr ()->InstantiatedFromMember.getPointer());

912 }

913

914

915

916

917

918

919

923 }

924

927

934

935

937

939 return K >= firstRedeclarableTemplate && K <= lastRedeclarableTemplate;

940 }

941};

942

946

949 }

950

954 }

955};

956

957

959protected:

961

962

963

965

966

967 llvm::FoldingSetVector Specializations;

968

970 };

971

977

979

982 }

983

984

985

986 llvm::FoldingSetVector &

988

989

990

991

992

994 void *InsertPos);

995

996public:

999

1000

1002

1003

1006 }

1007

1008

1009

1012 }

1013

1014

1015

1017 void *&InsertPos);

1018

1020 return cast(

1022 }

1024 return cast(

1026 }

1027

1028

1029

1031 return cast_or_null(

1033 }

1035 return cast_or_null(

1037 }

1038

1040 return cast(

1043 }

1046 }

1047

1049 return cast_or_null(

1051 }

1052

1054 using spec_range = llvm::iterator_range<spec_iterator>;

1055

1058 }

1059

1062 }

1063

1066 }

1067

1068

1069

1071

1072

1073

1074

1077 }

1078

1079

1081

1082

1088

1089

1092

1093

1096};

1097

1098

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109

1110

1112protected:

1116

1119

1121

1122

1124 "The depth of template parmeter position is more than 2^20!");

1126 "The position of template parmeter position is more than 2^12!");

1127 }

1128

1129public:

1131

1132

1136 "The depth of template parmeter position is more than 2^20!");

1138 }

1139

1140

1144 "The position of template parmeter position is more than 2^12!");

1146 }

1147

1148

1150};

1151

1152

1153

1154

1155

1156

1157

1159 private llvm::TrailingObjects<TemplateTypeParmDecl, TypeConstraint> {

1160

1162 friend TrailingObjects;

1164

1165

1166

1167

1168

1169 bool Typename : 1;

1170

1171

1172 bool HasTypeConstraint : 1;

1173

1174

1175

1176

1177 bool TypeConstraintInitialized : 1;

1178

1179

1180

1181

1182 bool ExpandedParameterPack : 1;

1183

1184

1185 unsigned NumExpanded = 0;

1186

1187

1191

1194 bool HasTypeConstraint,

1195 std::optional NumExpanded)

1197 HasTypeConstraint(HasTypeConstraint), TypeConstraintInitialized(false),

1198 ExpandedParameterPack(NumExpanded),

1199 NumExpanded(NumExpanded.value_or(0)) {}

1200

1201public:

1205 bool Typename, bool ParameterPack, bool HasTypeConstraint = false,

1206 std::optional NumExpanded = std::nullopt);

1211 bool HasTypeConstraint);

1212

1213

1214

1215

1216

1217

1219 return Typename && !HasTypeConstraint;

1220 }

1221

1223

1224

1225

1227

1228

1231 return DefaultArgument.isSet() ? *DefaultArgument.get() : NoneLoc;

1232 }

1233

1234

1236

1237

1238

1241 }

1242

1243

1246

1247

1248

1252 }

1253

1254

1256 DefaultArgument.clear();

1257 }

1258

1259

1260

1262

1263

1265

1266

1268

1269

1271

1272

1273

1274

1275

1278 return false;

1280 if (TC->hasExplicitTemplateArgs())

1281 for (const auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())

1282 if (ArgLoc.getArgument().containsUnexpandedParameterPack())

1283 return true;

1284 return false;

1285 }

1286

1287

1288

1289

1290

1291

1292

1293

1294

1295

1296

1297

1298

1299

1300

1301

1302

1303

1304

1305

1306

1307

1309

1310

1312 assert(ExpandedParameterPack && "Not an expansion parameter pack");

1313 return NumExpanded;

1314 }

1315

1316

1317

1319 return TypeConstraintInitialized ? getTrailingObjects() :

1320 nullptr;

1321 }

1322

1324 Expr *ImmediatelyDeclaredConstraint);

1325

1326

1328 return HasTypeConstraint;

1329 }

1330

1331

1332

1333

1334

1335

1337 if (HasTypeConstraint)

1338 AC.push_back(getTypeConstraint()->getImmediatelyDeclaredConstraint());

1339 }

1340

1342

1343

1346};

1347

1348

1349

1350

1351

1352

1356 private llvm::TrailingObjects<NonTypeTemplateParmDecl,

1357 std::pair<QualType, TypeSourceInfo *>,

1358 Expr *> {

1360 friend TrailingObjects;

1361

1362

1363

1367

1368

1369

1370

1371

1372 bool ParameterPack;

1373

1374

1375

1376

1377 bool ExpandedParameterPack = false;

1378

1379

1380 unsigned NumExpandedTypes = 0;

1381

1382 size_t numTrailingObjects(

1383 OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {

1384 return NumExpandedTypes;

1385 }

1386

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

1393

1394 NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,

1395 SourceLocation IdLoc, unsigned D, unsigned P,

1396 const IdentifierInfo *Id, QualType T,

1397 TypeSourceInfo *TInfo,

1398 ArrayRef ExpandedTypes,

1399 ArrayRef<TypeSourceInfo *> ExpandedTInfos);

1400

1401public:

1402 static NonTypeTemplateParmDecl *

1403 Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,

1404 SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id,

1405 QualType T, bool ParameterPack, TypeSourceInfo *TInfo);

1406

1407 static NonTypeTemplateParmDecl *

1408 Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,

1409 SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id,

1410 QualType T, TypeSourceInfo *TInfo, ArrayRef ExpandedTypes,

1411 ArrayRef<TypeSourceInfo *> ExpandedTInfos);

1412

1413 static NonTypeTemplateParmDecl *

1416 GlobalDeclID ID,

1417 unsigned NumExpandedTypes,

1418 bool HasTypeConstraint);

1419

1425

1426 SourceRange getSourceRange() const override LLVM_READONLY;

1427

1429

1430

1431

1433

1434

1437 return DefaultArgument.isSet() ? *DefaultArgument.get() : NoneLoc;

1438 }

1439

1440

1442

1443

1444

1447 }

1448

1449

1450

1451

1457 }

1458

1459

1461

1462

1463

1464

1465

1466

1467

1468

1469

1470

1472

1473

1474

1475

1476

1477

1480 }

1481

1482

1483

1484

1485

1486

1487

1488

1489

1490

1491

1492

1493

1494

1495

1496

1497

1498

1499

1500

1501

1502

1503

1504

1505

1507

1508

1509

1511 assert(ExpandedParameterPack && "Not an expansion parameter pack");

1512 return NumExpandedTypes;

1513 }

1514

1515

1516

1518 assert(I < NumExpandedTypes && "Out-of-range expansion type index");

1519 auto TypesAndInfos =

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

1521 return TypesAndInfos[I].first;

1522 }

1523

1524

1525

1527 assert(I < NumExpandedTypes && "Out-of-range expansion type index");

1528 auto TypesAndInfos =

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

1530 return TypesAndInfos[I].second;

1531 }

1532

1533

1534

1537 nullptr;

1538 }

1539

1541 *getTrailingObjects<Expr *>() = E;

1542 }

1543

1544

1545

1549 }

1550

1551

1552

1553

1554

1555

1556

1559 AC.push_back(E);

1560 }

1561

1562

1565};

1566

1567

1568

1569

1570

1571

1572

1573

1577 private llvm::TrailingObjects<TemplateTemplateParmDecl,

1578 TemplateParameterList *> {

1579

1583

1584

1585

1586

1587

1588 LLVM_PREFERRED_TYPE(bool)

1589 unsigned Typename : 1;

1590

1591

1592 LLVM_PREFERRED_TYPE(bool)

1593 unsigned ParameterPack : 1;

1594

1595

1596

1597

1598 LLVM_PREFERRED_TYPE(bool)

1599 unsigned ExpandedParameterPack : 1;

1600

1601

1602 unsigned NumExpandedParams = 0;

1603

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

1609 ParameterPack(ParameterPack), ExpandedParameterPack(false) {}

1610

1615

1616 void anchor() override;

1617

1618public:

1622

1625 unsigned P, bool ParameterPack,

1633

1638

1644

1645

1646

1648

1649

1650

1652

1653

1654

1655

1656

1657

1658

1660

1661

1662

1663

1664

1666 return ParameterPack &&

1668 }

1669

1670

1671

1672

1673

1674

1675

1676

1677

1678

1679

1680

1681

1682

1683

1684

1685

1686

1687

1689

1690

1691

1693 assert(ExpandedParameterPack && "Not an expansion parameter pack");

1694 return NumExpandedParams;

1695 }

1696

1697

1698

1700 assert(I < NumExpandedParams && "Out-of-range expansion type index");

1701 return getTrailingObjects<TemplateParameterList *>()[I];

1702 }

1703

1705

1706

1707

1709

1710

1713 return DefaultArgument.isSet() ? *DefaultArgument.get() : NoneLoc;

1714 }

1715

1716

1718

1719

1720

1723 }

1724

1725

1726

1727

1733 }

1734

1735

1737

1743 }

1744

1745

1748};

1749

1750

1751

1752

1755

1758

1759 void anchor() override;

1760

1761public:

1762

1765

1770 }

1771

1773 return {};

1774 }

1775

1777};

1778

1779

1780

1782

1784

1785

1787

1788

1790

1792};

1793

1797

1798

1799

1800

1801

1802

1803

1804

1805

1806

1807

1808

1809

1810

1812 public llvm::FoldingSetNode {

1813

1814

1815

1816 struct SpecializedPartialSpecialization {

1817

1818

1820

1821

1822

1824 };

1825

1826

1827 llvm::PointerUnion<ClassTemplateDecl *, SpecializedPartialSpecialization *>

1828 SpecializedTemplate;

1829

1830

1831

1833

1834

1836

1837

1839

1840

1842 unsigned SpecializationKind : 3;

1843

1844protected:

1851

1853

1854public:

1857

1866

1869

1870

1871

1872

1873

1874

1876 return cast(

1878 }

1879

1880

1882

1883

1884

1886 return *TemplateArgs;

1887 }

1888

1890 TemplateArgs = Args;

1891 }

1892

1893

1894

1897 }

1898

1901 }

1902

1903

1904

1905

1906

1907

1908

1909

1910

1911

1915 }

1916

1917

1918

1919

1923 }

1924

1926 SpecializedTemplate = Specialized;

1927 }

1928

1930 SpecializationKind = TSK;

1931 }

1932

1933

1935 return PointOfInstantiation;

1936 }

1937

1939 assert(Loc.isValid() && "point of instantiation must be valid!");

1940 PointOfInstantiation = Loc;

1941 }

1942

1943

1944

1945

1946

1953

1955 }

1956

1957

1958

1962 if (const auto *PartialSpec =

1963 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())

1964 return PartialSpec->PartialSpecialization;

1965

1966 return cast<ClassTemplateDecl *>(SpecializedTemplate);

1967 }

1968

1969

1970

1971

1972

1973

1974

1975

1976

1977

1978

1979

1981 if (const auto *PartialSpec =

1982 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())

1983 return *PartialSpec->TemplateArgs;

1984

1986 }

1987

1988

1989

1990

1993 assert(!isa<SpecializedPartialSpecialization *>(SpecializedTemplate) &&

1994 "Already set to a class template partial specialization!");

1995 auto *PS = new (getASTContext()) SpecializedPartialSpecialization();

1996 PS->PartialSpecialization = PartialSpec;

1997 PS->TemplateArgs = TemplateArgs;

1998 SpecializedTemplate = PS;

1999 }

2000

2001

2002

2004 assert(!isa<SpecializedPartialSpecialization *>(SpecializedTemplate) &&

2005 "Previously set to a class template partial specialization!");

2006 SpecializedTemplate = TemplDecl;

2007 }

2008

2009

2010

2012 if (auto *Info =

2013 dyn_cast_if_present<ExplicitInstantiationInfo *>(ExplicitInfo))

2014 return Info->TemplateArgsAsWritten;

2015 return cast<const ASTTemplateArgumentListInfo *>(ExplicitInfo);

2016 }

2017

2018

2019 void

2022 Info->TemplateArgsAsWritten = ArgsWritten;

2023 else

2024 ExplicitInfo = ArgsWritten;

2025 }

2026

2027

2031 }

2032

2033

2036 return Info->ExternKeywordLoc;

2038 }

2039

2040

2042

2043

2045 if (auto *Info =

2046 dyn_cast_if_present<ExplicitInstantiationInfo *>(ExplicitInfo))

2047 return Info->TemplateKeywordLoc;

2049 }

2050

2051

2053

2055

2058 }

2059

2060 static void

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

2066 }

2067

2069

2071 return K >= firstClassTemplateSpecialization &&

2072 K <= lastClassTemplateSpecialization;

2073 }

2074};

2075

2078

2080

2081

2082

2083

2084

2085

2086 llvm::PointerIntPair<ClassTemplatePartialSpecializationDecl *, 1, bool>

2087 InstantiatedFromMember;

2088

2094

2097 InstantiatedFromMember(nullptr, false) {}

2098

2099 void anchor() override;

2100

2101public:

2104

2111

2114

2116 return cast(

2119 }

2120

2121

2123 return TemplateParams;

2124 }

2125

2126

2130 }

2131

2132

2133

2134

2135

2136

2137

2140 }

2141

2144 }

2145

2146

2147

2148

2149

2150

2151

2152

2153

2154

2155

2156

2157

2158

2159

2160

2161

2162

2163

2164

2165

2167 const auto *First =

2168 cast(getFirstDecl());

2169 return First->InstantiatedFromMember.getPointer();

2170 }

2174 }

2175

2178 auto *First = cast(getFirstDecl());

2179 First->InstantiatedFromMember.setPointer(PartialSpec);

2180 }

2181

2182

2183

2184

2185

2186

2187

2188

2189

2190

2191

2192

2193

2194

2195

2196

2197

2199 const auto *First =

2200 cast(getFirstDecl());

2201 return First->InstantiatedFromMember.getInt();

2202 }

2203

2204

2206 auto *First = cast(getFirstDecl());

2207 assert(First->InstantiatedFromMember.getPointer() &&

2208 "Only member templates can be member template specializations");

2209 return First->InstantiatedFromMember.setInt(true);

2210 }

2211

2212

2213

2214

2216 assert(getTypeForDecl() && "partial specialization has no type set!");

2217 return cast(getTypeForDecl())

2218 ->getInjectedSpecializationType();

2219 }

2220

2222

2226 }

2227

2228 static void

2231

2233

2235 return K == ClassTemplatePartialSpecialization;

2236 }

2237};

2238

2239

2241protected:

2242

2243

2245

2246

2247 llvm::FoldingSetVector Specializations;

2248

2249

2250

2251 llvm::FoldingSetVector

2253

2254

2256

2258 };

2259

2260

2261 llvm::FoldingSetVector &

2263

2264

2265

2266 llvm::FoldingSetVector &

2268

2273

2275

2278 }

2279

2281

2282public:

2283

2287

2288

2290

2291

2294 }

2295

2296

2297

2300 }

2301

2302

2308

2309

2311

2312

2313

2316

2317

2318

2320

2322 return cast(

2324 }

2326 return cast(

2328 }

2329

2330

2331

2333 return cast_or_null(

2335 }

2337 return cast_or_null(

2340 }

2341

2343 return cast(

2345 }

2348 }

2349

2351 return cast_or_null(

2353 }

2354

2355

2356

2360

2361

2362

2364 void *InsertPos);

2365

2366

2369

2370

2371

2372

2373

2374

2375

2376

2377

2379

2380

2381

2382

2383

2384

2385

2386

2387

2391

2392

2393

2394

2395

2396

2397

2398

2399

2400

2401

2402

2403

2404

2405

2407

2409 using spec_range = llvm::iterator_range<spec_iterator>;

2410

2413 }

2414

2417 }

2418

2421 }

2422

2423

2426};

2427

2428

2429

2430

2431

2432

2433

2434

2435

2436

2437

2438

2439

2440

2442 virtual void anchor();

2443

2444public:

2445 using FriendUnion = llvm::PointerUnion<NamedDecl *,TypeSourceInfo *>;

2446

2447private:

2448

2449 unsigned NumParams = 0;

2450

2451

2453

2454

2456

2457

2459

2463 : Decl(Decl::FriendTemplate, DC, Loc), NumParams(NumParams),

2464 Params(Params), Friend(Friend), FriendLoc(FriendLoc) {}

2465

2467

2468public:

2470

2475

2477

2478

2479

2480

2483 }

2484

2485

2486

2487

2490 }

2491

2492

2494 return FriendLoc;

2495 }

2496

2498 assert(i <= NumParams);

2499 return Params[i];

2500 }

2501

2503 return NumParams;

2504 }

2505

2506

2509};

2510

2511

2512

2513

2514

2515

2516

2518protected:

2520

2526

2528

2531 }

2532

2533public:

2536

2537

2540 }

2541

2542

2544 return cast(

2546 }

2548 return cast(

2550 }

2551

2552

2553

2555 return cast_or_null(

2557 }

2559 return cast_or_null(

2562 }

2563

2565 return cast_or_null(

2567 }

2568

2569

2575

2576

2579

2580

2583};

2584

2585

2586

2587

2588

2589

2590

2591

2592

2593

2594

2595

2596

2597

2599 public llvm::FoldingSetNode {

2600

2601

2602

2603

2604 struct SpecializedPartialSpecialization {

2605

2606

2608

2609

2610

2612 };

2613

2614

2615 llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>

2616 SpecializedTemplate;

2617

2618

2619

2621

2622

2624

2625

2627

2628

2630 unsigned SpecializationKind : 3;

2631

2632

2633

2634

2635

2636 LLVM_PREFERRED_TYPE(bool)

2637 unsigned IsCompleteDefinition : 1;

2638

2639protected:

2646

2648

2649public:

2653

2661

2664

2667 return cast(Recent);

2668 }

2669

2670

2672

2673

2674

2676

2677

2678

2681 }

2682

2685 }

2686

2690 }

2691

2692

2693

2694

2698 }

2699

2701 SpecializationKind = TSK;

2702 }

2703

2704

2706 return PointOfInstantiation;

2707 }

2708

2710 assert(Loc.isValid() && "point of instantiation must be valid!");

2711 PointOfInstantiation = Loc;

2712 }

2713

2715

2716

2717

2718

2719

2720 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>

2725

2727 }

2728

2729

2730

2731 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>

2733 if (const auto *PartialSpec =

2734 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())

2735 return PartialSpec->PartialSpecialization;

2736

2737 return cast<VarTemplateDecl *>(SpecializedTemplate);

2738 }

2739

2740

2741

2742

2743

2744

2745

2746

2747

2748

2749

2750

2752 if (const auto *PartialSpec =

2753 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())

2754 return *PartialSpec->TemplateArgs;

2755

2757 }

2758

2759

2760

2761

2764 assert(!isa<SpecializedPartialSpecialization *>(SpecializedTemplate) &&

2765 "Already set to a variable template partial specialization!");

2766 auto *PS = new (getASTContext()) SpecializedPartialSpecialization();

2767 PS->PartialSpecialization = PartialSpec;

2768 PS->TemplateArgs = TemplateArgs;

2769 SpecializedTemplate = PS;

2770 }

2771

2772

2773

2775 assert(!isa<SpecializedPartialSpecialization *>(SpecializedTemplate) &&

2776 "Previously set to a variable template partial specialization!");

2777 SpecializedTemplate = TemplDecl;

2778 }

2779

2780

2781

2784 return Info->TemplateArgsAsWritten;

2785 return cast<const ASTTemplateArgumentListInfo *>(ExplicitInfo);

2786 }

2787

2788

2789 void

2791 if (auto *Info =

2792 dyn_cast_if_present<ExplicitInstantiationInfo *>(ExplicitInfo))

2793 Info->TemplateArgsAsWritten = ArgsWritten;

2794 else

2795 ExplicitInfo = ArgsWritten;

2796 }

2797

2798

2802 }

2803

2804

2807 return Info->ExternKeywordLoc;

2809 }

2810

2811

2813

2814

2817 return Info->TemplateKeywordLoc;

2819 }

2820

2821

2823

2825

2828 }

2829

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

2836 }

2837

2839

2841 return K >= firstVarTemplateSpecialization &&

2842 K <= lastVarTemplateSpecialization;

2843 }

2844};

2845

2848

2850

2851

2852

2853

2854

2855

2856 llvm::PointerIntPair<VarTemplatePartialSpecializationDecl *, 1, bool>

2857 InstantiatedFromMember;

2858

2864

2867 Context),

2868 InstantiatedFromMember(nullptr, false) {}

2869

2870 void anchor() override;

2871

2872public:

2875

2882

2885

2887 return cast(

2890 }

2891

2892

2894 return TemplateParams;

2895 }

2896

2897

2901 }

2902

2903

2904

2905

2906

2907

2908

2911 }

2912

2915 }

2916

2917

2918

2919

2920

2921

2922

2923

2924

2925

2926

2927

2928

2929

2930

2931

2932

2933

2934

2935

2936

2938 const auto *First =

2939 cast(getFirstDecl());

2940 return First->InstantiatedFromMember.getPointer();

2941 }

2942

2943 void

2945 auto *First = cast(getFirstDecl());

2946 First->InstantiatedFromMember.setPointer(PartialSpec);

2947 }

2948

2949

2950

2951

2952

2953

2954

2955

2956

2957

2958

2959

2960

2961

2962

2963

2964

2966 const auto *First =

2967 cast(getFirstDecl());

2968 return First->InstantiatedFromMember.getInt();

2969 }

2970

2971

2973 auto *First = cast(getFirstDecl());

2974 assert(First->InstantiatedFromMember.getPointer() &&

2975 "Only member templates can be member template specializations");

2976 return First->InstantiatedFromMember.setInt(true);

2977 }

2978

2980

2984 }

2985

2986 static void

2989

2991

2993 return K == VarTemplatePartialSpecialization;

2994 }

2995};

2996

2997

2999protected:

3000

3001

3003

3004

3006

3007

3008

3009 llvm::FoldingSetVector

3011

3013 };

3014

3015

3016 llvm::FoldingSetVector &

3018

3019

3020

3021 llvm::FoldingSetVector &

3023

3028

3030

3033 }

3034

3035public:

3038

3039

3041

3042

3045 }

3046

3047

3048

3051 }

3052

3054

3055

3060

3061

3063

3064

3065

3068

3069

3070

3072

3075 }

3078 }

3079

3080

3081

3083 return cast_or_null(

3085 }

3087 return cast_or_null(

3090 }

3091

3093 return cast(

3095 }

3098 }

3099

3101 return cast_or_null(

3103 }

3104

3105

3106

3110

3111

3112

3114 void *InsertPos);

3115

3116

3119

3120

3121

3122

3123

3124

3125

3126

3127

3128

3129

3132

3134 using spec_range = llvm::iterator_range<spec_iterator>;

3135

3138 }

3139

3142 }

3143

3146 }

3147

3148

3151};

3152

3153

3155protected:

3157

3160 : TemplateDecl(Concept, DC, L, Name, Params),

3162public:

3168

3171 }

3172

3174

3176

3181 }

3182

3185 }

3186

3189 }

3192 }

3193

3194

3197

3201};

3202

3203

3204

3205

3207 : public Decl,

3208 private llvm::TrailingObjects<ImplicitConceptSpecializationDecl,

3209 TemplateArgument> {

3210 unsigned NumTemplateArgs;

3211

3215

3216public:

3222 unsigned NumTemplateArgs);

3223

3226 NumTemplateArgs);

3227 }

3229

3230 static bool classofKind(Kind K) { return K == ImplicitConceptSpecialization; }

3232

3235};

3236

3237

3238

3239

3240

3241

3242

3243

3244

3245

3246

3247

3248

3250 public Mergeable,

3251 public llvm::FoldingSetNode {

3252private:

3253

3255

3258 T),

3260

3265

3266

3267

3271

3272public:

3273

3274 void printName(llvm::raw_ostream &OS,

3276

3277

3278 void printAsExpr(llvm::raw_ostream &OS) const;

3280

3281

3282

3283 void printAsInit(llvm::raw_ostream &OS) const;

3285

3287

3290 ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());

3291 V.Profile(ID);

3292 }

3295 }

3296

3299 }

3302 }

3303

3306};

3307

3310 return PD;

3312 return PD;

3313 return cast<TemplateTemplateParmDecl *>(P);

3314}

3315

3317 auto *TD = dyn_cast(D);

3318 return TD && (isa(TD) ||

3319 isa(TD) ||

3320 isa(TD) ||

3321 isa(TD))

3322 ? TD

3323 : nullptr;

3324}

3325

3326

3327

3328

3329

3330

3331

3332

3333

3334

3335

3336

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

3339 if (TTP->isExpandedParameterPack())

3340 return TTP->getNumExpansionParameters();

3341 }

3342

3343 if (const auto *NTTP = dyn_cast(Param)) {

3344 if (NTTP->isExpandedParameterPack())

3345 return NTTP->getNumExpansionTypes();

3346 }

3347

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

3349 if (TTP->isExpandedParameterPack())

3350 return TTP->getNumExpansionTemplateParameters();

3351 }

3352

3353 return std::nullopt;

3354}

3355

3356

3357

3359

3360}

3361

3362#endif

This file provides AST data structures related to concepts.

Defines the clang::ASTContext interface.

enum clang::sema::@1727::IndirectLocalPathEntry::EntryKind Kind

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

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

Defines the clang::SourceLocation class and associated facilities.

Defines various enumerations that describe declaration and type specifiers.

C Language Family Type Representation.

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

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

Reads an AST files chain containing the contents of a translation unit.

bool isConstrained() const

Represents the builtin template declaration which is used to implement __make_integer_seq and other b...

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

BuiltinTemplateKind getBuiltinTemplateKind() const

static BuiltinTemplateDecl * Create(const ASTContext &C, DeclContext *DC, DeclarationName Name, BuiltinTemplateKind BTK)

static bool classof(const Decl *D)

static bool classofKind(Kind K)

Represents a C++ struct/union/class.

CXXRecordDecl * getMostRecentNonInjectedDecl()

TemplateSpecializationKind getTemplateSpecializationKind() const

Determine whether this particular class is a specialization or instantiation of a class template or m...

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.

ClassTemplateDecl * getMostRecentDecl()

spec_iterator spec_begin() const

spec_iterator spec_end() const

CXXRecordDecl * getTemplatedDecl() const

Get the underlying class declarations of the template.

static bool classofKind(Kind K)

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...

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

CommonBase * newCommon(ASTContext &C) const override

llvm::iterator_range< spec_iterator > spec_range

static bool classof(const Decl *D)

const ClassTemplateDecl * getMostRecentDecl() const

ClassTemplateDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this template.

ClassTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *D)

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

const ClassTemplateDecl * getCanonicalDecl() const

bool isThisDeclarationADefinition() const

Returns whether this template declaration defines the primary class pattern.

ClassTemplateDecl * getPreviousDecl()

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

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.

const ClassTemplateDecl * getPreviousDecl() const

ClassTemplateDecl * getInstantiatedFromMemberTemplate() const

void setCommonPtr(Common *C)

spec_range specializations() const

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...

ClassTemplatePartialSpecializationDecl * getInstantiatedFromMemberTemplate() const

ClassTemplatePartialSpecializationDecl * getMostRecentDecl()

void setInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *PartialSpec)

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

All associated constraints of this partial specialization, including the requires clause and any cons...

bool hasAssociatedConstraints() const

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.

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

Get the template argument list of the template parameter list.

void setMemberSpecialization()

Note that this member template is a specialization.

static bool classofKind(Kind K)

QualType getInjectedSpecializationType() const

Retrieves the injected specialization type for this partial specialization.

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

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

static bool classof(const Decl *D)

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.

bool isClassScopeExplicitSpecialization() const

Is this an explicit specialization at class scope (within the class that owns the primary template)?...

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

ClassTemplateSpecializationDecl * getMostRecentDecl()

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

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

void setTemplateArgs(TemplateArgumentList *Args)

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 setPointOfInstantiation(SourceLocation Loc)

SourceLocation getPointOfInstantiation() const

Get the point of instantiation (if any), or null if none.

static bool classof(const Decl *D)

void setExternKeywordLoc(SourceLocation Loc)

Sets the location of the extern keyword.

void setSpecializationKind(TemplateSpecializationKind TSK)

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.

static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef< TemplateArgument > TemplateArgs, const ASTContext &Context)

void setInstantiationOf(ClassTemplateDecl *TemplDecl)

Note that this class template specialization is an instantiation of the given class template.

SourceLocation getTemplateKeywordLoc() const

Gets the location of the template keyword, if present.

void setTemplateArgsAsWritten(const TemplateArgumentListInfo &ArgsInfo)

Set the template argument list as written in the sources.

bool isExplicitSpecialization() const

void setTemplateKeywordLoc(SourceLocation Loc)

Sets the location of the template keyword.

const TemplateArgumentList & getTemplateInstantiationArgs() const

Retrieve the set of template arguments that should be used to instantiate members of the class templa...

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

If this class template specialization is an instantiation of a template (rather than an explicit spec...

void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)

Note that this class template specialization is actually an instantiation of the given class template...

bool isExplicitInstantiationOrSpecialization() const

True if this declaration is an explicit specialization, explicit instantiation declaration,...

void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)

Set the template argument list as written in the sources.

void Profile(llvm::FoldingSetNodeID &ID) const

void setSpecializedTemplate(ClassTemplateDecl *Specialized)

static bool classofKind(Kind K)

Declaration of a C++20 concept.

void setDefinition(Expr *E)

Expr * getConstraintExpr() const

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

ConceptDecl(DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, Expr *ConstraintExpr)

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

bool isTypeConcept() const

ConceptDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

bool hasDefinition() const

static bool classof(const Decl *D)

const ConceptDecl * getCanonicalDecl() const

static bool classofKind(Kind K)

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...

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

ASTContext & getASTContext() const LLVM_READONLY

bool isImplicit() const

isImplicit - Indicates whether the declaration was implicitly generated by the implementation.

Kind

Lists the kind of concrete classes of Decl.

SourceLocation getLocation() const

DeclContext * getLexicalDeclContext()

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

virtual SourceRange getSourceRange() const LLVM_READONLY

Source range that this declaration covers.

The name of a declaration.

Represents a ValueDecl that came out of a declarator.

Storage for a default argument.

void setInherited(const ASTContext &C, ParmDecl *InheritedFrom)

Set that the default argument was inherited from another parameter.

bool isSet() const

Determine whether there is a default argument for this parameter.

ArgType get() const

Get the default argument's value.

void set(ArgType Arg)

Set the default argument.

void clear()

Remove the default argument, even if it was inherited.

const ParmDecl * getInheritedFrom() const

Get the parameter from which we inherit the default argument, if any.

bool isInherited() const

Determine whether the default argument for this parameter was inherited from a previous declaration o...

Provides information about a dependent function-template specialization declaration.

ArrayRef< FunctionTemplateDecl * > getCandidates() const

Returns the candidates for the primary function template.

const ASTTemplateArgumentListInfo * TemplateArgumentsAsWritten

The template arguments as written in the sources, if provided.

This represents one expression.

Stores a list of template parameters and the associated requires-clause (if any) for a TemplateDecl a...

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

Declaration of a friend template.

static bool classof(const Decl *D)

SourceLocation getFriendLoc() const

Retrieves the location of the 'friend' keyword.

NamedDecl * getFriendDecl() const

If this friend declaration names a templated function (or a member function of a templated type),...

TemplateParameterList * getTemplateParameterList(unsigned i) const

static bool classofKind(Kind K)

unsigned getNumTemplateParameters() const

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

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

TypeSourceInfo * getFriendType() const

If this friend declaration names a templated type (or a dependent member type of a templated type),...

Represents a function declaration or definition.

bool isThisDeclarationADefinition() const

Returns whether this specific declaration of the function is also a definition that does not contain ...

Declaration of a template function.

FunctionTemplateDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this template.

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

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

spec_iterator spec_end() const

void addSpecialization(FunctionTemplateSpecializationInfo *Info, void *InsertPos)

Add a specialization of this function template.

CommonBase * newCommon(ASTContext &C) const override

FunctionDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const

Common * getCommonPtr() const

bool isThisDeclarationADefinition() const

Returns whether this template declaration defines the primary pattern.

const FunctionTemplateDecl * getPreviousDecl() const

bool isAbbreviated() const

Return whether this function template is an abbreviated function template, e.g.

FunctionTemplateDecl * getMostRecentDecl()

FunctionTemplateDecl * getPreviousDecl()

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

const FunctionTemplateDecl * getCanonicalDecl() const

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

Create an empty function template node.

spec_range specializations() const

spec_iterator spec_begin() const

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

const FunctionTemplateDecl * getMostRecentDecl() const

llvm::iterator_range< spec_iterator > spec_range

static bool classofKind(Kind K)

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.

static bool classof(const Decl *D)

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

bool isExplicitSpecialization() const

TemplateArgumentList * TemplateArguments

The template arguments used to produce the function template specialization from the function templat...

void setTemplateSpecializationKind(TemplateSpecializationKind TSK)

Set the template specialization kind.

static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef< TemplateArgument > TemplateArgs, const ASTContext &Context)

FunctionTemplateDecl * getTemplate() const

Retrieve the template from which this function was specialized.

MemberSpecializationInfo * getMemberSpecializationInfo() const

Get the specialization info if this function template specialization is also a member specialization:

const ASTTemplateArgumentListInfo * TemplateArgumentsAsWritten

The template arguments as written in the sources, if provided.

SourceLocation getPointOfInstantiation() const

Retrieve the first point of instantiation of this function template specialization.

void Profile(llvm::FoldingSetNodeID &ID)

SourceLocation PointOfInstantiation

The point at which this function template specialization was first instantiated.

FunctionDecl * getFunction() const

Retrieve the declaration of the function template specialization.

TemplateSpecializationKind getTemplateSpecializationKind() const

Determine what kind of template specialization this is.

void setPointOfInstantiation(SourceLocation POI)

Set the (first) point of instantiation of this function template specialization.

bool isExplicitInstantiationOrSpecialization() const

True if this declaration is an explicit specialization, explicit instantiation declaration,...

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

void setTemplateArguments(ArrayRef< TemplateArgument > Converted)

static bool classofKind(Kind K)

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

ArrayRef< TemplateArgument > getTemplateArguments() const

static bool classof(const Decl *D)

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

void setTemplateSpecializationKind(TemplateSpecializationKind TSK)

Set the template specialization kind.

TemplateSpecializationKind getTemplateSpecializationKind() const

Determine what kind of template specialization this is.

bool isExplicitSpecialization() const

SourceLocation getPointOfInstantiation() const

Retrieve the first point of instantiation of this member.

MemberSpecializationInfo(NamedDecl *IF, TemplateSpecializationKind TSK, SourceLocation POI=SourceLocation())

void setPointOfInstantiation(SourceLocation POI)

Set the first point of instantiation.

NamedDecl * getInstantiatedFrom() const

Retrieve the member declaration from which this member was instantiated.

Provides common interface for the Decls that cannot be redeclared, but can be merged if the same decl...

TemplateParamObjectDecl * getFirstDecl()

Return the first declaration of this declaration or itself if this is the only declaration.

This represents a decl that may have a name.

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 isPackExpansion() const

Whether this parameter pack is a pack expansion.

const DefArgStorage & getDefaultArgStorage() const

QualType getExpansionType(unsigned I) const

Retrieve a particular expansion type within an expanded parameter pack.

static bool classofKind(Kind K)

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.

TypeSourceInfo * getExpansionTypeSourceInfo(unsigned I) const

Retrieve a particular expansion type source info within an expanded parameter pack.

static bool classof(const Decl *D)

unsigned getNumExpansionTypes() const

Retrieves the number of expansion types in an expanded parameter pack.

const TemplateArgumentLoc & getDefaultArgument() const

Retrieve the default argument, if any.

bool isExpandedParameterPack() const

Whether this parameter is a non-type template parameter pack that has a known list of different types...

bool isParameterPack() const

Whether this parameter is a non-type template parameter pack.

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

Get the associated-constraints of this template parameter.

bool hasPlaceholderTypeConstraint() const

Determine whether this non-type template parameter's type has a placeholder with a type-constraint.

Expr * getPlaceholderTypeConstraint() const

Return the constraint introduced by the placeholder type of this non-type template parameter (if any)...

void setPlaceholderTypeConstraint(Expr *E)

void removeDefaultArgument()

Removes the default argument of this template parameter.

void setInheritedDefaultArgument(const ASTContext &C, NonTypeTemplateParmDecl *Parm)

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

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

Represents a pack expansion of types.

A (possibly-)qualified type.

Declaration of a redeclarable template.

static SpecIterator< EntryType > makeSpecIterator(llvm::FoldingSetVector< EntryType > &Specs, bool isEnd)

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

RedeclarableTemplateDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)

redeclarable_base::redecl_iterator redecl_iterator

void loadLazySpecializationsImpl(bool OnlyPartial=false) const

bool isMemberSpecialization() const

Determines whether this template was a specialization of a member template.

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)

const RedeclarableTemplateDecl * getCanonicalDecl() const

redeclarable_base::redecl_range redecl_range

CommonBase * Common

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

static bool classof(const Decl *D)

RedeclarableTemplateDecl * getInstantiatedFromMemberTemplate() const

Retrieve the member template from which this template was instantiated, or nullptr if this template w...

static bool classofKind(Kind K)

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)

friend class RedeclarableTemplate

void setMemberSpecialization()

Note that this member template is a specialization.

void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)

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

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

Provides common interface for the Decls that can be redeclared.

RedeclarableTemplateDecl * getFirstDecl()

Return the first declaration of this declaration or itself if this is the only declaration.

RedeclarableTemplateDecl * getNextRedeclaration() const

RedeclarableTemplateDecl * getPreviousDecl()

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

redecl_iterator redecls_end() const

llvm::iterator_range< redecl_iterator > redecl_range

RedeclarableTemplateDecl * getMostRecentDecl()

Returns the most recent (re)declaration of this declaration.

bool isFirstDecl() const

True if this is the first declaration in its redeclaration chain.

redecl_iterator redecls_begin() const

redecl_range redecls() const

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

Sema - This implements semantic analysis and AST building for C.

Encodes a location in the source.

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getEndLoc() const LLVM_READONLY

bool isThisDeclarationADefinition() const

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

A convenient class for passing around template argument information.

A template argument list.

TemplateArgumentList(const TemplateArgumentList &)=delete

const TemplateArgument * data() const

Retrieve a pointer to the template argument list.

const TemplateArgument & operator[](unsigned Idx) const

Retrieve the template argument at a given index.

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

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

unsigned size() const

Retrieve the number of template arguments in this template argument list.

const TemplateArgument & get(unsigned Idx) const

Retrieve the template argument at a given index.

TemplateArgumentList & operator=(const TemplateArgumentList &)=delete

ArrayRef< TemplateArgument > asArray() const

Produce this as an array ref.

Location wrapper for a TemplateArgument.

SourceRange getSourceRange() const LLVM_READONLY

Represents a template argument.

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

NamedDecl * TemplatedDecl

TemplateParameterList * TemplateParams

bool hasAssociatedConstraints() const

void init(NamedDecl *NewTemplatedDecl)

Initialize the underlying templated declaration.

NamedDecl * getTemplatedDecl() const

Get the underlying, templated declaration.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

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

void setTemplateParameters(TemplateParameterList *TParams)

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

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

static bool classof(const Decl *D)

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

static bool classofKind(Kind K)

A template parameter object.

TemplateParamObjectDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

void printAsExpr(llvm::raw_ostream &OS) const

Print this object as an equivalent expression.

const TemplateParamObjectDecl * getCanonicalDecl() const

void Profile(llvm::FoldingSetNodeID &ID)

const APValue & getValue() const

static bool classof(const Decl *D)

static void Profile(llvm::FoldingSetNodeID &ID, QualType T, const APValue &V)

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.

static bool classofKind(Kind K)

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

const_iterator end() const

NamedDecl * getParam(unsigned Idx)

SourceRange getSourceRange() const LLVM_READONLY

const_iterator begin() const

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.

const Expr * getRequiresClause() const

The constraint-expression of the associated requires-clause.

bool hasAssociatedConstraints() const

unsigned getMinRequiredArguments() const

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

size_t numTrailingObjects(OverloadToken< Expr * >) const

bool hasParameterPack() const

Determine whether this template parameter list contains a parameter pack.

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

NamedDecl *const * const_iterator

Iterates through the template parameters in this list.

Expr * getRequiresClause()

The constraint-expression of the associated requires-clause.

void print(raw_ostream &Out, const ASTContext &Context, const PrintingPolicy &Policy, bool OmitTemplateKW=false) const

SourceLocation getRAngleLoc() const

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

const NamedDecl * getParam(unsigned Idx) const

bool containsUnexpandedParameterPack() const

Determine whether this template parameter list contains an unexpanded parameter pack.

SourceLocation getLAngleLoc() const

size_t numTrailingObjects(OverloadToken< NamedDecl * >) const

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

void print(raw_ostream &Out, const ASTContext &Context, bool OmitTemplateKW=false) 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

ArrayRef< const NamedDecl * > asArray() const

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

static constexpr unsigned MaxPosition

static constexpr unsigned MaxDepth

unsigned getPosition() const

Get the position of the template parameter within its parameter list.

void setPosition(unsigned P)

unsigned getIndex() const

Get the index of the template parameter within its parameter list.

TemplateParmPosition(unsigned D, unsigned P)

void setDepth(unsigned D)

unsigned getDepth() const

Get the nesting depth of the template parameter.

TemplateParmPosition()=delete

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

bool wasDeclaredWithTypename() const

Whether this template template parameter was declared with the 'typename' keyword.

TemplateParameterList * getExpansionTemplateParameters(unsigned I) const

Retrieve a particular expansion type within an expanded parameter pack.

bool isPackExpansion() const

Whether this parameter pack is a pack expansion.

unsigned getNumExpansionTemplateParameters() const

Retrieves the number of expansion template parameters in an expanded parameter pack.

const DefArgStorage & getDefaultArgStorage() const

static bool classof(const Decl *D)

const TemplateArgumentLoc & getDefaultArgument() const

Retrieve the default argument, if any.

void setInheritedDefaultArgument(const ASTContext &C, TemplateTemplateParmDecl *Prev)

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

SourceLocation getDefaultArgumentLoc() const

Retrieve the location of the default argument, if any.

bool isParameterPack() const

Whether this template template parameter is a template parameter pack.

static bool classofKind(Kind K)

bool defaultArgumentWasInherited() const

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

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

void setDeclaredWithTypename(bool withTypename)

Set whether this template template parameter was declared with the 'typename' or 'class' keyword.

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

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

bool isExpandedParameterPack() const

Whether this parameter is a template template parameter pack that has a known list of different templ...

void removeDefaultArgument()

Removes the default argument of this template parameter.

bool hasDefaultArgument() const

Determine whether this template parameter has a default argument.

Declaration of a template type parameter.

bool wasDeclaredWithTypename() const

Whether this template type parameter was declared with the 'typename' keyword.

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.

void setInheritedDefaultArgument(const ASTContext &C, TemplateTypeParmDecl *Prev)

Set that this default argument was inherited from another parameter.

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

bool hasTypeConstraint() const

Determine whether this template parameter has a type-constraint.

const TypeConstraint * getTypeConstraint() const

Returns the type constraint associated with this template parameter (if any).

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 isExpandedParameterPack() const

Whether this parameter is a template type parameter pack that has a known list of different type-cons...

void removeDefaultArgument()

Removes the default argument of this template parameter.

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.

const DefArgStorage & getDefaultArgStorage() const

void setTypeConstraint(ConceptReference *CR, Expr *ImmediatelyDeclaredConstraint)

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

Set the default argument for this template parameter.

unsigned getNumExpansionParameters() const

Retrieves the number of parameters in an expanded parameter pack.

static bool classofKind(Kind K)

static bool classof(const Decl *D)

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

Get the associated-constraints of this template parameter.

void setDeclaredWithTypename(bool withTypename)

Set whether this template type parameter was declared with the 'typename' or 'class' keyword.

bool isPackExpansion() const

Whether this parameter pack is a pack expansion.

Represents the declaration of a typedef-name via a C++11 alias-declaration.

Declaration of an alias template.

static bool classof(const Decl *D)

CommonBase * newCommon(ASTContext &C) const override

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

Create an empty alias template node.

TypeAliasTemplateDecl * getPreviousDecl()

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

const TypeAliasTemplateDecl * getPreviousDecl() const

TypeAliasTemplateDecl * getInstantiatedFromMemberTemplate() const

const TypeAliasTemplateDecl * getCanonicalDecl() const

static bool classofKind(Kind K)

TypeAliasTemplateDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this template.

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

TypeAliasDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

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

Represents a declaration of a type.

const Type * getTypeForDecl() const

A container of type source information.

AutoType * getContainedAutoType() const

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

const T * getAs() const

Member-template getAs'.

A set of unresolved declarations.

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

DefinitionKind isThisDeclarationADefinition(ASTContext &) const

Check whether this declaration is a definition.

TemplateSpecializationKind getTemplateSpecializationKind() const

If this variable is an instantiation of a variable template or a static data member of a class templa...

Declaration of a variable template.

VarTemplateDecl * getDefinition()

VarDecl * getTemplatedDecl() const

Get the underlying variable declarations of the template.

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.

spec_iterator spec_begin() const

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...

static bool classof(const Decl *D)

const VarTemplateDecl * getPreviousDecl() const

void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)

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

VarTemplateDecl * getInstantiatedFromMemberTemplate() const

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.

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

const VarTemplateDecl * getCanonicalDecl() const

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

Create an empty variable template node.

llvm::iterator_range< spec_iterator > spec_range

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.

static bool classofKind(Kind K)

const VarTemplateDecl * getMostRecentDecl() const

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 ...

spec_iterator spec_end() const

VarTemplateDecl * getMostRecentDecl()

spec_range specializations() const

void setMemberSpecialization()

Note that this member template is a specialization.

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 bool classof(const Decl *D)

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

Get the template argument list of the template parameter list.

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

All associated constraints of this partial specialization, including the requires clause and any cons...

void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)

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

VarTemplatePartialSpecializationDecl * getMostRecentDecl()

static bool classofKind(Kind K)

bool hasAssociatedConstraints() const

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

SourceLocation getPointOfInstantiation() const

Get the point of instantiation (if any), or null if none.

void setTemplateArgsAsWritten(const ASTTemplateArgumentListInfo *ArgsWritten)

Set the template argument list as written in the sources.

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.

void setSpecializationKind(TemplateSpecializationKind TSK)

static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef< TemplateArgument > TemplateArgs, const ASTContext &Context)

const TemplateArgumentList & getTemplateArgs() const

Retrieve the template arguments of the variable template specialization.

const TemplateArgumentList & getTemplateInstantiationArgs() const

Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...

static bool classof(const Decl *D)

bool isClassScopeExplicitSpecialization() const

SourceLocation getTemplateKeywordLoc() const

Gets the location of the template keyword, if present.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)

Note that this variable template specialization is actually an instantiation of the given variable te...

void Profile(llvm::FoldingSetNodeID &ID) const

void setPointOfInstantiation(SourceLocation Loc)

void setTemplateArgsAsWritten(const TemplateArgumentListInfo &ArgsInfo)

Set the template argument list as written in the sources.

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.

void setInstantiationOf(VarTemplateDecl *TemplDecl)

Note that this variable template specialization is an instantiation of the given variable template.

VarTemplateDecl * getSpecializedTemplate() const

Retrieve the template that this specialization specializes.

bool isExplicitInstantiationOrSpecialization() const

True if this declaration is an explicit specialization, explicit instantiation declaration,...

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

If this variable template specialization is an instantiation of a template (rather than an explicit s...

bool isExplicitSpecialization() const

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 setCompleteDefinition()

VarTemplateSpecializationDecl * getMostRecentDecl()

static bool classofKind(Kind K)

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

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

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

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

bool isTemplateInstantiation(TemplateSpecializationKind Kind)

Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...

Decl * getPrimaryMergedDecl(Decl *D)

Get the primary declaration for a declaration from an AST file.

NamedDecl * getAsNamedDecl(TemplateParameter P)

@ Create

'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...

StorageClass

Storage classes.

void * allocateDefaultArgStorageChain(const ASTContext &C)

TemplateDecl * getAsTypeTemplateDecl(Decl *D)

llvm::PointerUnion< const ASTTemplateArgumentListInfo *, ExplicitInstantiationInfo * > SpecializationOrInstantiationInfo

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.

llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter

Stores a template parameter of any kind.

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

TemplateSpecializationKind

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

@ TSK_ExplicitSpecialization

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

@ TSK_Undeclared

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

@ Typename

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

bool isTemplateExplicitInstantiationOrSpecialization(TemplateSpecializationKind Kind)

True if this template specialization kind is an explicit specialization, explicit instantiation decla...

Diagnostic wrappers for TextAPI types for error reporting.

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.

ExplicitInstantiationInfo()=default

SourceLocation ExternKeywordLoc

The location of the extern keyword.

const ASTTemplateArgumentListInfo * TemplateArgsAsWritten

The template arguments as written..

SourceLocation TemplateKeywordLoc

The location of the template keyword.

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.

llvm::PointerIntPair< RedeclarableTemplateDecl *, 1, bool > InstantiatedFromMember

The template from which this was most directly instantiated (or null).

static ArrayRef< TemplateArgument > getTemplateArgs(FunctionTemplateSpecializationInfo *I)

static DeclType * getDecl(FunctionTemplateSpecializationInfo *I)

static ArrayRef< TemplateArgument > getTemplateArgs(EntryType *D)

static DeclType * getDecl(EntryType *D)

SpecIterator(typename llvm::FoldingSetVector< EntryType >::iterator SetIter)

DeclType * operator->() const

DeclType * operator*() const

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 ...