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

2013 return Info->TemplateArgsAsWritten;

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

2015 }

2016

2017

2018 void

2021 Info->TemplateArgsAsWritten = ArgsWritten;

2022 else

2023 ExplicitInfo = ArgsWritten;

2024 }

2025

2026

2030 }

2031

2032

2035 return Info->ExternKeywordLoc;

2037 }

2038

2039

2041

2042

2045 return Info->TemplateKeywordLoc;

2047 }

2048

2049

2051

2053

2056 }

2057

2058 static void

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

2064 }

2065

2067

2069 return K >= firstClassTemplateSpecialization &&

2070 K <= lastClassTemplateSpecialization;

2071 }

2072};

2073

2076

2078

2079

2080

2081

2082

2083

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

2085 InstantiatedFromMember;

2086

2092

2095 InstantiatedFromMember(nullptr, false) {}

2096

2097 void anchor() override;

2098

2099public:

2102

2109

2112

2114 return cast(

2117 }

2118

2119

2121 return TemplateParams;

2122 }

2123

2124

2128 }

2129

2130

2131

2132

2133

2134

2135

2138 }

2139

2142 }

2143

2144

2145

2146

2147

2148

2149

2150

2151

2152

2153

2154

2155

2156

2157

2158

2159

2160

2161

2162

2163

2165 const auto *First =

2166 cast(getFirstDecl());

2167 return First->InstantiatedFromMember.getPointer();

2168 }

2172 }

2173

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

2177 First->InstantiatedFromMember.setPointer(PartialSpec);

2178 }

2179

2180

2181

2182

2183

2184

2185

2186

2187

2188

2189

2190

2191

2192

2193

2194

2195

2197 const auto *First =

2198 cast(getFirstDecl());

2199 return First->InstantiatedFromMember.getInt();

2200 }

2201

2202

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

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

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

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

2208 }

2209

2210

2211

2212

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

2215 return cast(getTypeForDecl())

2216 ->getInjectedSpecializationType();

2217 }

2218

2220

2224 }

2225

2226 static void

2229

2231

2233 return K == ClassTemplatePartialSpecialization;

2234 }

2235};

2236

2237

2239protected:

2240

2241

2243

2244

2245 llvm::FoldingSetVector Specializations;

2246

2247

2248

2249 llvm::FoldingSetVector

2251

2252

2254

2256 };

2257

2258

2259 llvm::FoldingSetVector &

2261

2262

2263

2264 llvm::FoldingSetVector &

2266

2271

2273

2276 }

2277

2279

2280public:

2281

2285

2286

2288

2289

2292 }

2293

2294

2295

2298 }

2299

2300

2306

2307

2309

2310

2311

2314

2315

2316

2318

2320 return cast(

2322 }

2324 return cast(

2326 }

2327

2328

2329

2331 return cast_or_null(

2333 }

2335 return cast_or_null(

2338 }

2339

2341 return cast(

2343 }

2346 }

2347

2349 return cast_or_null(

2351 }

2352

2353

2354

2358

2359

2360

2362 void *InsertPos);

2363

2364

2367

2368

2369

2370

2371

2372

2373

2374

2375

2377

2378

2379

2380

2381

2382

2383

2384

2385

2389

2390

2391

2392

2393

2394

2395

2396

2397

2398

2399

2400

2401

2402

2403

2405

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

2408

2411 }

2412

2415 }

2416

2419 }

2420

2421

2424};

2425

2426

2427

2428

2429

2430

2431

2432

2433

2434

2435

2436

2437

2438

2440 virtual void anchor();

2441

2442public:

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

2444

2445private:

2446

2447 unsigned NumParams = 0;

2448

2449

2451

2452

2454

2455

2457

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

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

2463

2465

2466public:

2468

2473

2475

2476

2477

2478

2481 }

2482

2483

2484

2485

2488 }

2489

2490

2492 return FriendLoc;

2493 }

2494

2496 assert(i <= NumParams);

2497 return Params[i];

2498 }

2499

2501 return NumParams;

2502 }

2503

2504

2507};

2508

2509

2510

2511

2512

2513

2514

2516protected:

2518

2524

2526

2529 }

2530

2531public:

2534

2535

2538 }

2539

2540

2542 return cast(

2544 }

2546 return cast(

2548 }

2549

2550

2551

2553 return cast_or_null(

2555 }

2557 return cast_or_null(

2560 }

2561

2563 return cast_or_null(

2565 }

2566

2567

2573

2574

2577

2578

2581};

2582

2583

2584

2585

2586

2587

2588

2589

2590

2591

2592

2593

2594

2595

2597 public llvm::FoldingSetNode {

2598

2599

2600

2601

2602 struct SpecializedPartialSpecialization {

2603

2604

2606

2607

2608

2610 };

2611

2612

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

2614 SpecializedTemplate;

2615

2616

2617

2619

2620

2622

2623

2625

2626

2628 unsigned SpecializationKind : 3;

2629

2630

2631

2632

2633

2634 LLVM_PREFERRED_TYPE(bool)

2635 unsigned IsCompleteDefinition : 1;

2636

2637protected:

2644

2646

2647public:

2651

2659

2662

2665 return cast(Recent);

2666 }

2667

2668

2670

2671

2672

2674

2675

2676

2679 }

2680

2683 }

2684

2688 }

2689

2690

2691

2692

2696 }

2697

2699 SpecializationKind = TSK;

2700 }

2701

2702

2704 return PointOfInstantiation;

2705 }

2706

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

2709 PointOfInstantiation = Loc;

2710 }

2711

2713

2714

2715

2716

2717

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

2723

2725 }

2726

2727

2728

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

2731 if (const auto *PartialSpec =

2732 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())

2733 return PartialSpec->PartialSpecialization;

2734

2735 return cast<VarTemplateDecl *>(SpecializedTemplate);

2736 }

2737

2738

2739

2740

2741

2742

2743

2744

2745

2746

2747

2748

2750 if (const auto *PartialSpec =

2751 SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())

2752 return *PartialSpec->TemplateArgs;

2753

2755 }

2756

2757

2758

2759

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

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

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

2765 PS->PartialSpecialization = PartialSpec;

2766 PS->TemplateArgs = TemplateArgs;

2767 SpecializedTemplate = PS;

2768 }

2769

2770

2771

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

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

2775 SpecializedTemplate = TemplDecl;

2776 }

2777

2778

2779

2782 return Info->TemplateArgsAsWritten;

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

2784 }

2785

2786

2787 void

2790 Info->TemplateArgsAsWritten = ArgsWritten;

2791 else

2792 ExplicitInfo = ArgsWritten;

2793 }

2794

2795

2799 }

2800

2801

2804 return Info->ExternKeywordLoc;

2806 }

2807

2808

2810

2811

2814 return Info->TemplateKeywordLoc;

2816 }

2817

2818

2820

2822

2825 }

2826

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

2833 }

2834

2836

2838 return K >= firstVarTemplateSpecialization &&

2839 K <= lastVarTemplateSpecialization;

2840 }

2841};

2842

2845

2847

2848

2849

2850

2851

2852

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

2854 InstantiatedFromMember;

2855

2861

2864 Context),

2865 InstantiatedFromMember(nullptr, false) {}

2866

2867 void anchor() override;

2868

2869public:

2872

2879

2882

2884 return cast(

2887 }

2888

2889

2891 return TemplateParams;

2892 }

2893

2894

2898 }

2899

2900

2901

2902

2903

2904

2905

2908 }

2909

2912 }

2913

2914

2915

2916

2917

2918

2919

2920

2921

2922

2923

2924

2925

2926

2927

2928

2929

2930

2931

2932

2933

2935 const auto *First =

2936 cast(getFirstDecl());

2937 return First->InstantiatedFromMember.getPointer();

2938 }

2939

2940 void

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

2943 First->InstantiatedFromMember.setPointer(PartialSpec);

2944 }

2945

2946

2947

2948

2949

2950

2951

2952

2953

2954

2955

2956

2957

2958

2959

2960

2961

2963 const auto *First =

2964 cast(getFirstDecl());

2965 return First->InstantiatedFromMember.getInt();

2966 }

2967

2968

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

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

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

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

2974 }

2975

2977

2981 }

2982

2983 static void

2986

2988

2990 return K == VarTemplatePartialSpecialization;

2991 }

2992};

2993

2994

2996protected:

2997

2998

3000

3001

3003

3004

3005

3006 llvm::FoldingSetVector

3008

3010 };

3011

3012

3013 llvm::FoldingSetVector &

3015

3016

3017

3018 llvm::FoldingSetVector &

3020

3025

3027

3030 }

3031

3032public:

3035

3036

3038

3039

3042 }

3043

3044

3045

3048 }

3049

3051

3052

3057

3058

3060

3061

3062

3065

3066

3067

3069

3072 }

3075 }

3076

3077

3078

3080 return cast_or_null(

3082 }

3084 return cast_or_null(

3087 }

3088

3090 return cast(

3092 }

3095 }

3096

3098 return cast_or_null(

3100 }

3101

3102

3103

3107

3108

3109

3111 void *InsertPos);

3112

3113

3116

3117

3118

3119

3120

3121

3122

3123

3124

3125

3126

3129

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

3132

3135 }

3136

3139 }

3140

3143 }

3144

3145

3148};

3149

3150

3152protected:

3154

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

3159public:

3165

3168 }

3169

3171

3173

3178 }

3179

3182 }

3183

3186 }

3189 }

3190

3191

3194

3198};

3199

3200

3201

3202

3204 : public Decl,

3205 private llvm::TrailingObjects<ImplicitConceptSpecializationDecl,

3206 TemplateArgument> {

3207 unsigned NumTemplateArgs;

3208

3212

3213public:

3219 unsigned NumTemplateArgs);

3220

3223 NumTemplateArgs);

3224 }

3226

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

3229

3232};

3233

3234

3235

3236

3237

3238

3239

3240

3241

3242

3243

3244

3245

3247 public Mergeable,

3248 public llvm::FoldingSetNode {

3249private:

3250

3252

3255 T),

3257

3262

3263

3264

3268

3269public:

3270

3271 void printName(llvm::raw_ostream &OS,

3273

3274

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

3277

3278

3279

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

3282

3284

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

3288 V.Profile(ID);

3289 }

3292 }

3293

3296 }

3299 }

3300

3303};

3304

3307 return PD;

3309 return PD;

3310 return cast<TemplateTemplateParmDecl *>(P);

3311}

3312

3314 auto *TD = dyn_cast(D);

3315 return TD && (isa(TD) ||

3316 isa(TD) ||

3317 isa(TD) ||

3318 isa(TD))

3319 ? TD

3320 : nullptr;

3321}

3322

3323

3324

3325

3326

3327

3328

3329

3330

3331

3332

3333

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

3336 if (TTP->isExpandedParameterPack())

3337 return TTP->getNumExpansionParameters();

3338 }

3339

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

3341 if (NTTP->isExpandedParameterPack())

3342 return NTTP->getNumExpansionTypes();

3343 }

3344

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

3346 if (TTP->isExpandedParameterPack())

3347 return TTP->getNumExpansionTemplateParameters();

3348 }

3349

3350 return std::nullopt;

3351}

3352

3353

3354

3356

3357}

3358

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