DeclarationName.h Source File (original) (raw)

13#ifndef LLVM_CLANG_AST_DECLARATIONNAME_H

14#define LLVM_CLANG_AST_DECLARATIONNAME_H

22#include "llvm/ADT/DenseMapInfo.h"

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

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

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

26#include "llvm/Support/type_traits.h"

27#include

28#include

29#include

30#include

34class ASTContext;

35template <typename> class CanQual;

36class DeclarationName;

37class DeclarationNameTable;

38struct PrintingPolicy;

39class TemplateDecl;

40class TypeSourceInfo;

44namespace detail {

53 : public llvm::FoldingSetNode {

63 void *FETokenInfo;

67public:

68 void Profile(llvm::FoldingSetNodeID &ID) {

69 ID.AddPointer(Type.getAsOpaquePtr());

70 }

71};

76 public llvm::FoldingSetNode {

86 void *FETokenInfo;

90 FETokenInfo(nullptr) {}

92public:

93 void Profile(llvm::FoldingSetNodeID &ID) { ID.AddPointer(Template); }

94};

103

104

106

107

108

109

110 void *FETokenInfo = nullptr;

111};

112

113

114

117 public llvm::FoldingSetNode {

120

122

123

124

125

126 void *FETokenInfo;

127

130 FETokenInfo(nullptr) {}

131

132public:

133 void Profile(llvm::FoldingSetNodeID &FSID) { FSID.AddPointer(ID); }

134};

135

136}

137

138

139

140

141

142

143

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174 enum StoredNameKind {

175 StoredIdentifier = 0,

176 StoredObjCZeroArgSelector = Selector::ZeroArg,

177 StoredObjCOneArgSelector = Selector::OneArg,

178 StoredCXXConstructorName = 3,

179 StoredCXXDestructorName = 4,

180 StoredCXXConversionFunctionName = 5,

181 StoredCXXOperatorName = 6,

182 StoredDeclarationNameExtra = Selector::MultiArg,

183 PtrMask = 7,

184 UncommonNameKindOffset = 8

185 };

186

193 "The various classes that DeclarationName::Ptr can point to"

194 " must be at least aligned to 8 bytes!");

195

196 static_assert(

197 std::is_same<std::underlying_type_t,

198 std::underlying_type_t<

200 "The various enums used to compute values for NameKind should "

201 "all have the same underlying type");

202

203public:

204

205

206

207

210 ObjCZeroArgSelector = StoredObjCZeroArgSelector,

211 ObjCOneArgSelector = StoredObjCOneArgSelector,

212 CXXConstructorName = StoredCXXConstructorName,

213 CXXDestructorName = StoredCXXDestructorName,

214 CXXConversionFunctionName = StoredCXXConversionFunctionName,

215 CXXOperatorName = StoredCXXOperatorName,

216 CXXDeductionGuideName = llvm::addEnumValues(

217 UncommonNameKindOffset,

218 detail::DeclarationNameExtra::CXXDeductionGuideName),

219 CXXLiteralOperatorName = llvm::addEnumValues(

220 UncommonNameKindOffset,

221 detail::DeclarationNameExtra::CXXLiteralOperatorName),

222 CXXUsingDirective =

223 llvm::addEnumValues(UncommonNameKindOffset,

224 detail::DeclarationNameExtra::CXXUsingDirective),

225 ObjCMultiArgSelector =

226 llvm::addEnumValues(UncommonNameKindOffset,

227 detail::DeclarationNameExtra::ObjCMultiArgSelector),

228 };

229

230private:

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

264

265 StoredNameKind getStoredNameKind() const {

266 return static_cast<StoredNameKind>(Ptr & PtrMask);

267 }

268

269 void *getPtr() const { return reinterpret_cast<void *>(Ptr & ~PtrMask); }

270

271 void setPtrAndKind(const void *P, StoredNameKind Kind) {

273 assert((Kind & ~PtrMask) == 0 &&

274 "Invalid StoredNameKind in setPtrAndKind!");

275 assert((PAsInteger & PtrMask) == 0 &&

276 "Improperly aligned pointer in setPtrAndKind!");

277 Ptr = PAsInteger | Kind;

278 }

279

280

281 DeclarationName(detail::DeclarationNameExtra *Name) {

282 setPtrAndKind(Name, StoredDeclarationNameExtra);

283 }

284

285

286 DeclarationName(detail::CXXSpecialNameExtra *Name,

287 StoredNameKind StoredKind) {

288 assert((StoredKind == StoredCXXConstructorName ||

289 StoredKind == StoredCXXDestructorName ||

290 StoredKind == StoredCXXConversionFunctionName) &&

291 "Invalid StoredNameKind when constructing a DeclarationName"

292 " from a CXXSpecialNameExtra!");

293 setPtrAndKind(Name, StoredKind);

294 }

295

296

297 DeclarationName(detail::CXXOperatorIdName *Name) {

298 setPtrAndKind(Name, StoredCXXOperatorName);

299 }

300

301

302 IdentifierInfo *castAsIdentifierInfo() const {

303 assert((getStoredNameKind() == StoredIdentifier) &&

304 "DeclarationName does not store an IdentifierInfo!");

305 return static_cast<IdentifierInfo *>(getPtr());

306 }

307

308

309

310 detail::DeclarationNameExtra *castAsExtra() const {

311 assert((getStoredNameKind() == StoredDeclarationNameExtra) &&

312 "DeclarationName does not store an Extra structure!");

313 return static_cast<detail::DeclarationNameExtra *>(getPtr());

314 }

315

316

317

318 detail::CXXSpecialNameExtra *castAsCXXSpecialNameExtra() const {

319 assert((getStoredNameKind() == StoredCXXConstructorName ||

320 getStoredNameKind() == StoredCXXDestructorName ||

321 getStoredNameKind() == StoredCXXConversionFunctionName) &&

322 "DeclarationName does not store a CXXSpecialNameExtra!");

323 return static_cast<detail::CXXSpecialNameExtra *>(getPtr());

324 }

325

326

327

328 detail::CXXOperatorIdName *castAsCXXOperatorIdName() const {

329 assert((getStoredNameKind() == StoredCXXOperatorName) &&

330 "DeclarationName does not store a CXXOperatorIdName!");

331 return static_cast<detail::CXXOperatorIdName *>(getPtr());

332 }

333

334

335

336 detail::CXXDeductionGuideNameExtra *castAsCXXDeductionGuideNameExtra() const {

337 assert(getNameKind() == CXXDeductionGuideName &&

338 "DeclarationName does not store a CXXDeductionGuideNameExtra!");

339 return static_cast<detail::CXXDeductionGuideNameExtra *>(getPtr());

340 }

341

342

343

344 detail::CXXLiteralOperatorIdName *castAsCXXLiteralOperatorIdName() const {

345 assert(getNameKind() == CXXLiteralOperatorName &&

346 "DeclarationName does not store a CXXLiteralOperatorIdName!");

347 return static_cast<detail::CXXLiteralOperatorIdName *>(getPtr());

348 }

349

350

351

352 void *getFETokenInfoSlow() const;

353 void setFETokenInfoSlow(void *T);

354

355public:

356

358

359

361 setPtrAndKind(II, StoredIdentifier);

362 }

363

364

366 : Ptr(reinterpret_cast<uintptr_t>(Sel.InfoPtr.getOpaqueValue())) {}

367

368

370

372 detail::DeclarationNameExtra::CXXUsingDirective);

374 }

375

376

377 explicit operator bool() const {

378 return getPtr() || (getStoredNameKind() != StoredIdentifier);

379 }

380

381

382 bool isEmpty() const { return !*this; }

383

384

385 bool isIdentifier() const { return getStoredNameKind() == StoredIdentifier; }

387 return getStoredNameKind() == StoredObjCZeroArgSelector;

388 }

390 return getStoredNameKind() == StoredObjCOneArgSelector;

391 }

392

393

395

396

397 StoredNameKind StoredKind = getStoredNameKind();

398 if (StoredKind != StoredDeclarationNameExtra)

399 return static_cast<NameKind>(StoredKind);

400

401

402

403 unsigned ExtraKind = castAsExtra()->getKind();

404 return static_cast<NameKind>(UncommonNameKindOffset + ExtraKind);

405 }

406

407

408

409

410

411

412

413 bool isDependentName() const;

414

415

417

418

419

421 if (isIdentifier())

422 return castAsIdentifierInfo();

423 return nullptr;

424 }

425

426

428

429

430 void *getAsOpaquePtr() const { return reinterpret_cast<void *>(Ptr); }

431

432

435 N.Ptr = reinterpret_cast<uintptr_t>(P);

436 return N;

437 }

438

439

440

443 N.Ptr = P;

444 return N;

445 }

446

447

448

450 if (getStoredNameKind() == StoredCXXConstructorName ||

451 getStoredNameKind() == StoredCXXDestructorName ||

452 getStoredNameKind() == StoredCXXConversionFunctionName) {

453 assert(getPtr() && "getCXXNameType on a null DeclarationName!");

454 return castAsCXXSpecialNameExtra()->Type;

455 }

457 }

458

459

460

462 if (getNameKind() == CXXDeductionGuideName) {

463 assert(getPtr() &&

464 "getCXXDeductionGuideTemplate on a null DeclarationName!");

465 return castAsCXXDeductionGuideNameExtra()->Template;

466 }

467 return nullptr;

468 }

469

470

471

473 if (getStoredNameKind() == StoredCXXOperatorName) {

474 assert(getPtr() && "getCXXOverloadedOperator on a null DeclarationName!");

475 return castAsCXXOperatorIdName()->Kind;

476 }

478 }

479

480

481

483 if (getNameKind() == CXXLiteralOperatorName) {

484 assert(getPtr() && "getCXXLiteralIdentifier on a null DeclarationName!");

485 return castAsCXXLiteralOperatorIdName()->ID;

486 }

487 return nullptr;

488 }

489

490

492 assert((getNameKind() == ObjCZeroArgSelector ||

493 getNameKind() == ObjCOneArgSelector ||

494 getNameKind() == ObjCMultiArgSelector || !getPtr()) &&

495 "Not a selector!");

497 }

498

499

500

501

503 assert(getPtr() && "getFETokenInfo on an empty DeclarationName!");

504 if (getStoredNameKind() == StoredIdentifier)

505 return castAsIdentifierInfo()->getFETokenInfo();

506 return getFETokenInfoSlow();

507 }

508

510 assert(getPtr() && "setFETokenInfo on an empty DeclarationName!");

511 if (getStoredNameKind() == StoredIdentifier)

512 castAsIdentifierInfo()->setFETokenInfo(T);

513 else

514 setFETokenInfoSlow(T);

515 }

516

517

519 return LHS.Ptr == RHS.Ptr;

520 }

521

522

524 return LHS.Ptr != RHS.Ptr;

525 }

526

530 return Name;

531 }

532

536 return Name;

537 }

538

540

542

543 void dump() const;

544};

545

546raw_ostream &operator<<(raw_ostream &OS, DeclarationName N);

547

548

549

551 return DeclarationName::compare(LHS, RHS) < 0;

552}

553

554

555

557 return DeclarationName::compare(LHS, RHS) > 0;

558}

559

560

561

563 return DeclarationName::compare(LHS, RHS) <= 0;

564}

565

566

567

569 return DeclarationName::compare(LHS, RHS) >= 0;

570}

571

572

573

574

575

576

578

580

581

582

583

584 llvm::FoldingSetdetail::CXXSpecialNameExtra CXXConstructorNames;

585

586

587

588

589 llvm::FoldingSetdetail::CXXSpecialNameExtra CXXDestructorNames;

590

591

592

593

594

595 llvm::FoldingSetdetail::CXXSpecialNameExtra CXXConversionFunctionNames;

596

597

598

599

601

602

603

604

605

606 llvm::FoldingSetdetail::CXXLiteralOperatorIdName CXXLiteralOperatorNames;

607

608

609

610

611

612 llvm::FoldingSetdetail::CXXDeductionGuideNameExtra CXXDeductionGuideNames;

613

614public:

621

622

625 }

626

627

629

630

632

633

635

636

638

639

640

641

642

643

644

647

648

651 }

652

653

655};

656

657

658

659

661

662

663

664

665

666

667 struct NT {

669 };

670

671

672 struct CXXOpName {

675 };

676

677

678 struct CXXLitOpName {

680 };

681

682

683

684

685

686 union {

687 struct NT NamedType;

688 struct CXXOpName CXXOperatorName;

689 struct CXXLitOpName CXXLiteralOperatorName;

690 };

691

692 void setNamedTypeLoc(TypeSourceInfo *TInfo) { NamedType.TInfo = TInfo; }

693

694 void setCXXOperatorNameRange(SourceRange Range) {

695 CXXOperatorName.BeginOpNameLoc = Range.getBegin().getRawEncoding();

696 CXXOperatorName.EndOpNameLoc = Range.getEnd().getRawEncoding();

697 }

698

699 void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {

700 CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();

701 }

702

703public:

704 DeclarationNameLoc(DeclarationName Name);

705

707

708

709

711

712

714 return SourceLocation::getFromRawEncoding(CXXOperatorName.BeginOpNameLoc);

715 }

716

717

719 return SourceLocation::getFromRawEncoding(CXXOperatorName.EndOpNameLoc);

720 }

721

722

723

724

726 return SourceRange(getCXXOperatorNameBeginLoc(),

727 getCXXOperatorNameEndLoc());

728 }

729

730

731

732

734 return SourceLocation::getFromRawEncoding(CXXLiteralOperatorName.OpNameLoc);

735 }

736

737

738

741 DNL.setNamedTypeLoc(TInfo);

742 return DNL;

743 }

744

745

748 return makeCXXOperatorNameLoc(SourceRange(BeginLoc, EndLoc));

749 }

750

751

754 DNL.setCXXOperatorNameRange(Range);

755 return DNL;

756 }

757

758

761 DNL.setCXXLiteralOperatorNameLoc(Loc);

762 return DNL;

763 }

764};

765

766

767

769private:

770

772

773

775

776

778

779public:

780

782

784 : Name(Name), NameLoc(NameLoc), LocInfo(Name) {}

785

788 : Name(Name), NameLoc(NameLoc), LocInfo(LocInfo) {}

789

790

792

793

795

796

798

799

801

804

805

806

808 if (Name.getNameKind() != DeclarationName::CXXConstructorName &&

809 Name.getNameKind() != DeclarationName::CXXDestructorName &&

810 Name.getNameKind() != DeclarationName::CXXConversionFunctionName)

811 return nullptr;

813 }

814

815

816

818 assert(Name.getNameKind() == DeclarationName::CXXConstructorName ||

819 Name.getNameKind() == DeclarationName::CXXDestructorName ||

820 Name.getNameKind() == DeclarationName::CXXConversionFunctionName);

821 LocInfo = DeclarationNameLoc::makeNamedTypeLoc(TInfo);

822 }

823

824

825

827 if (Name.getNameKind() != DeclarationName::CXXOperatorName)

830 }

831

832

833

835 assert(Name.getNameKind() == DeclarationName::CXXOperatorName);

836 LocInfo = DeclarationNameLoc::makeCXXOperatorNameLoc(R);

837 }

838

839

840

841

843 if (Name.getNameKind() != DeclarationName::CXXLiteralOperatorName)

846 }

847

848

849

850

852 assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);

853 LocInfo = DeclarationNameLoc::makeCXXLiteralOperatorNameLoc(Loc);

854 }

855

856

857 bool isInstantiationDependent() const;

858

859

860

861 bool containsUnexpandedParameterPack() const;

862

863

865

866

867 void printName(raw_ostream &OS, PrintingPolicy Policy) const;

868

869

871

872

874 return SourceRange(getBeginLoc(), getEndLoc());

875 }

876

879 return EndLoc.isValid() ? EndLoc : getBeginLoc();

880 }

881

882private:

884};

885

886

887

891 DiagnosticsEngine::ak_declarationname);

892 return PD;

893}

894

895raw_ostream &operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo);

896

897}

898

899namespace llvm {

900

901

902

903template<>

904struct DenseMapInfo<clang::DeclarationName> {

907 }

908

911 }

912

914 return DenseMapInfo<void*>::getHashValue(Name.getAsOpaquePtr());

915 }

916

917 static inline bool

919 return LHS == RHS;

920 }

921};

922

925 return P.getAsOpaquePtr();

926 }

929 }

930 static constexpr int NumLowBitsAvailable = 0;

931};

932

933}

934

935

936

938

939

940

943

947

948public:

949

951};

952

953}

954

955#endif

Defines the Diagnostic-related interfaces.

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

static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)

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

static void print(llvm::raw_ostream &OS, const T &V, ASTContext &ASTCtx, QualType Ty)

Defines an enumeration for C++ overloaded operators.

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

static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)

Defines the clang::SourceLocation class and associated facilities.

C Language Family Type Representation.

__DEVICE__ void * memset(void *__a, int __b, size_t __c)

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

A structure for storing the information associated with a name that has been assumed to be a template...

DeclarationName getDeclName() const

Get the name of the template.

DeclarationNameLoc - Additional source/type location info for a declaration name.

static DeclarationNameLoc makeNamedTypeLoc(TypeSourceInfo *TInfo)

Construct location information for a constructor, destructor or conversion operator.

static DeclarationNameLoc makeCXXLiteralOperatorNameLoc(SourceLocation Loc)

Construct location information for a literal C++ operator.

SourceLocation getCXXLiteralOperatorNameLoc() const

Return the location of the literal operator name (without the operator keyword).

SourceLocation getCXXOperatorNameBeginLoc() const

Return the beginning location of the getCXXOperatorNameRange() range.

TypeSourceInfo * getNamedTypeInfo() const

Returns the source type info.

static DeclarationNameLoc makeCXXOperatorNameLoc(SourceLocation BeginLoc, SourceLocation EndLoc)

Construct location information for a non-literal C++ operator.

SourceLocation getCXXOperatorNameEndLoc() const

Return the end location of the getCXXOperatorNameRange() range.

SourceRange getCXXOperatorNameRange() const

Return the range of the operator name (without the operator keyword).

static DeclarationNameLoc makeCXXOperatorNameLoc(SourceRange Range)

Construct location information for a non-literal C++ operator.

The name of a declaration.

static DeclarationName getFromOpaqueInteger(uintptr_t P)

Get a declaration name from an opaque integer returned by getAsOpaqueInteger.

uintptr_t getAsOpaqueInteger() const

Get the representation of this declaration name as an opaque integer.

IdentifierInfo * getAsIdentifierInfo() const

Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...

static DeclarationName getEmptyMarker()

static DeclarationName getFromOpaquePtr(void *P)

Get a declaration name from an opaque pointer returned by getAsOpaquePtr.

static DeclarationName getTombstoneMarker()

TemplateDecl * getCXXDeductionGuideTemplate() const

If this name is the name of a C++ deduction guide, return the template associated with that name.

DeclarationName(Selector Sel)

Construct a declaration name from an Objective-C selector.

void * getAsOpaquePtr() const

Get the representation of this declaration name as an opaque pointer.

const IdentifierInfo * getCXXLiteralIdentifier() const

If this name is the name of a literal operator, retrieve the identifier associated with it.

friend bool operator==(DeclarationName LHS, DeclarationName RHS)

Determine whether the specified names are identical.

static DeclarationName getUsingDirectiveName()

Returns the name for all C++ using-directives.

friend bool operator!=(DeclarationName LHS, DeclarationName RHS)

Determine whether the specified names are different.

OverloadedOperatorKind getCXXOverloadedOperator() const

If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...

bool isObjCZeroArgSelector() const

NameKind

The kind of the name stored in this DeclarationName.

void * getFETokenInfo() const

Get and set FETokenInfo.

QualType getCXXNameType() const

If this name is one of the C++ names (of a constructor, destructor, or conversion function),...

Selector getObjCSelector() const

Get the Objective-C selector stored in this declaration name.

bool isObjCOneArgSelector() const

DeclarationName()

Construct an empty declaration name.

NameKind getNameKind() const

Determine what kind of name this is.

bool isEmpty() const

Evaluates true when this declaration name is empty.

DeclarationName(const IdentifierInfo *II)

Construct a declaration name from an IdentifierInfo *.

void setFETokenInfo(void *T)

bool isIdentifier() const

Predicate functions for querying what type of name this is.

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

This represents a decl that may have a name.

A (possibly-)qualified type.

Smart pointer class that efficiently represents Objective-C method names.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

A trivial tuple used to represent a source range.

The streaming interface shared between DiagnosticBuilder and PartialDiagnostic.

void AddTaggedVal(uint64_t V, DiagnosticsEngine::ArgumentKind Kind) const

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

A container of type source information.

The base class of the type hierarchy.

Implementation class used to describe either a set of overloaded template names or an already-substit...

Contains the actual identifier that makes up the name of a C++ literal operator.

void Profile(llvm::FoldingSetNodeID &FSID)

Contains extra information for the name of an overloaded operator in C++, such as "operator+.

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

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

@ OO_None

Not an overloaded operator.

@ NUM_OVERLOADED_OPERATORS

bool operator<(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

CanQual< Type > CanQualType

Represents a canonical, potentially-qualified type.

bool operator<=(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

bool operator>(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

const FunctionProtoType * T

bool operator>=(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

llvm::StringRef getAsString(SyncScope S)

Diagnostic wrappers for TextAPI types for error reporting.

__UINTPTR_TYPE__ uintptr_t

An unsigned integer type with the property that any valid pointer to void can be converted to this ty...

DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...

SourceLocation getLoc() const

getLoc - Returns the main location of the declaration name.

DeclarationName getName() const

getName - Returns the embedded declaration name.

void setLoc(SourceLocation L)

setLoc - Sets the main location of the declaration name.

void setCXXLiteralOperatorNameLoc(SourceLocation Loc)

setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...

void setNamedTypeInfo(TypeSourceInfo *TInfo)

setNamedTypeInfo - Sets the source type info associated to the name.

void setInfo(const DeclarationNameLoc &Info)

void setCXXOperatorNameRange(SourceRange R)

setCXXOperatorNameRange - Sets the range of the operator name (without the operator keyword).

SourceRange getCXXOperatorNameRange() const

getCXXOperatorNameRange - Gets the range of the operator name (without the operator keyword).

DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc)

void setName(DeclarationName N)

setName - Sets the embedded declaration name.

const DeclarationNameLoc & getInfo() const

SourceLocation getBeginLoc() const

getBeginLoc - Retrieve the location of the first token.

TypeSourceInfo * getNamedTypeInfo() const

getNamedTypeInfo - Returns the source type info associated to the name.

SourceRange getSourceRange() const LLVM_READONLY

getSourceRange - The range of the declaration name.

DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc, DeclarationNameLoc LocInfo)

SourceLocation getCXXLiteralOperatorNameLoc() const

getCXXLiteralOperatorNameLoc - Returns the location of the literal operator name (not the operator ke...

SourceLocation getEndLoc() const LLVM_READONLY

DeclarationNameInfo()=default

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

static clang::DeclarationName getEmptyKey()

static clang::DeclarationName getTombstoneKey()

static bool isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS)

static unsigned getHashValue(clang::DeclarationName Name)

static void * getAsVoidPointer(clang::DeclarationName P)

static clang::DeclarationName getFromVoidPointer(void *P)