llvm/clang/lib/AST/DeclCXX.cpp

//===- DeclCXX.cpp - C++ Declaration AST Node Implementation --------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the C++ related Decl classes.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/DeclCXX.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/ASTLambda.h"
#include "clang/AST/ASTMutationListener.h"
#include "clang/AST/ASTUnresolvedSet.h"
#include "clang/AST/Attr.h"
#include "clang/AST/CXXInheritance.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DeclarationName.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/LambdaCapture.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/ODRHash.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/AST/UnresolvedSet.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/OperatorKinds.h"
#include "clang/Basic/PartialDiagnostic.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/Specifiers.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>

usingnamespaceclang;

//===----------------------------------------------------------------------===//
// Decl Allocation/Deallocation Method Implementations
//===----------------------------------------------------------------------===//

void AccessSpecDecl::anchor() { … }

AccessSpecDecl *AccessSpecDecl::CreateDeserialized(ASTContext &C,
                                                   GlobalDeclID ID) { … }

void LazyASTUnresolvedSet::getFromExternalSource(ASTContext &C) const { … }

CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
    : … { … }

CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const { … }

CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const { … }

CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C,
                             DeclContext *DC, SourceLocation StartLoc,
                             SourceLocation IdLoc, IdentifierInfo *Id,
                             CXXRecordDecl *PrevDecl)
    : … { … }

CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,
                                     DeclContext *DC, SourceLocation StartLoc,
                                     SourceLocation IdLoc, IdentifierInfo *Id,
                                     CXXRecordDecl *PrevDecl,
                                     bool DelayTypeCreation) { … }

CXXRecordDecl *
CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC,
                            TypeSourceInfo *Info, SourceLocation Loc,
                            unsigned DependencyKind, bool IsGeneric,
                            LambdaCaptureDefault CaptureDefault) { … }

CXXRecordDecl *CXXRecordDecl::CreateDeserialized(const ASTContext &C,
                                                 GlobalDeclID ID) { … }

/// Determine whether a class has a repeated base class. This is intended for
/// use when determining if a class is standard-layout, so makes no attempt to
/// handle virtual bases.
static bool hasRepeatedBaseClass(const CXXRecordDecl *StartRD) { … }

void
CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
                        unsigned NumBases) { … }

unsigned CXXRecordDecl::getODRHash() const { … }

void CXXRecordDecl::addedClassSubobject(CXXRecordDecl *Subobj) { … }

const CXXRecordDecl *CXXRecordDecl::getStandardLayoutBaseWithFields() const { … }

bool CXXRecordDecl::hasConstexprDestructor() const { … }

bool CXXRecordDecl::hasAnyDependentBases() const { … }

bool CXXRecordDecl::isTriviallyCopyable() const { … }

bool CXXRecordDecl::isTriviallyCopyConstructible() const { … }

void CXXRecordDecl::markedVirtualFunctionPure() { … }

bool CXXRecordDecl::hasSubobjectAtOffsetZeroOfEmptyBaseType(
    ASTContext &Ctx, const CXXRecordDecl *XFirst) { … }

bool CXXRecordDecl::lambdaIsDefaultConstructibleAndAssignable() const { … }

void CXXRecordDecl::addedMember(Decl *D) { … }

bool CXXRecordDecl::isLiteral() const { … }

void CXXRecordDecl::addedSelectedDestructor(CXXDestructorDecl *DD) { … }

void CXXRecordDecl::addedEligibleSpecialMemberFunction(const CXXMethodDecl *MD,
                                                       unsigned SMKind) { … }

void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) { … }

void CXXRecordDecl::LambdaDefinitionData::AddCaptureList(ASTContext &Ctx,
                                                         Capture *CaptureList) { … }

void CXXRecordDecl::setCaptures(ASTContext &Context,
                                ArrayRef<LambdaCapture> Captures) { … }

void CXXRecordDecl::setTrivialForCallFlags(CXXMethodDecl *D) { … }

bool CXXRecordDecl::isCLike() const { … }

bool CXXRecordDecl::isGenericLambda() const { … }

#ifndef NDEBUG
static bool allLookupResultsAreTheSame(const DeclContext::lookup_result &R) {
  return llvm::all_of(R, [&](NamedDecl *D) {
    return D->isInvalidDecl() || declaresSameEntity(D, R.front());
  });
}
#endif

static NamedDecl* getLambdaCallOperatorHelper(const CXXRecordDecl &RD) { … }

FunctionTemplateDecl* CXXRecordDecl::getDependentLambdaCallOperator() const { … }

CXXMethodDecl *CXXRecordDecl::getLambdaCallOperator() const { … }

CXXMethodDecl* CXXRecordDecl::getLambdaStaticInvoker() const { … }

static DeclContext::lookup_result
getLambdaStaticInvokers(const CXXRecordDecl &RD) { … }

static CXXMethodDecl *getInvokerAsMethod(NamedDecl *ND) { … }

CXXMethodDecl *CXXRecordDecl::getLambdaStaticInvoker(CallingConv CC) const { … }

void CXXRecordDecl::getCaptureFields(
    llvm::DenseMap<const ValueDecl *, FieldDecl *> &Captures,
    FieldDecl *&ThisCapture) const { … }

TemplateParameterList *
CXXRecordDecl::getGenericLambdaTemplateParameterList() const { … }

ArrayRef<NamedDecl *>
CXXRecordDecl::getLambdaExplicitTemplateParameters() const { … }

Decl *CXXRecordDecl::getLambdaContextDecl() const { … }

void CXXRecordDecl::setLambdaNumbering(LambdaNumbering Numbering) { … }

unsigned CXXRecordDecl::getDeviceLambdaManglingNumber() const { … }

static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) { … }

/// Collect the visible conversions of a base class.
///
/// \param Record a base class of the class we're considering
/// \param InVirtual whether this base class is a virtual base (or a base
///   of a virtual base)
/// \param Access the access along the inheritance path to this base
/// \param ParentHiddenTypes the conversions provided by the inheritors
///   of this base
/// \param Output the set to which to add conversions from non-virtual bases
/// \param VOutput the set to which to add conversions from virtual bases
/// \param HiddenVBaseCs the set of conversions which were hidden in a
///   virtual base along some inheritance path
static void CollectVisibleConversions(
    ASTContext &Context, const CXXRecordDecl *Record, bool InVirtual,
    AccessSpecifier Access,
    const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
    ASTUnresolvedSet &Output, UnresolvedSetImpl &VOutput,
    llvm::SmallPtrSet<NamedDecl *, 8> &HiddenVBaseCs) { … }

/// Collect the visible conversions of a class.
///
/// This would be extremely straightforward if it weren't for virtual
/// bases.  It might be worth special-casing that, really.
static void CollectVisibleConversions(ASTContext &Context,
                                      const CXXRecordDecl *Record,
                                      ASTUnresolvedSet &Output) { … }

/// getVisibleConversionFunctions - get all conversion functions visible
/// in current class; including conversion function templates.
llvm::iterator_range<CXXRecordDecl::conversion_iterator>
CXXRecordDecl::getVisibleConversionFunctions() const { … }

void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) { … }

CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const { … }

MemberSpecializationInfo *CXXRecordDecl::getMemberSpecializationInfo() const { … }

void
CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
                                             TemplateSpecializationKind TSK) { … }

ClassTemplateDecl *CXXRecordDecl::getDescribedClassTemplate() const { … }

void CXXRecordDecl::setDescribedClassTemplate(ClassTemplateDecl *Template) { … }

TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{ … }

void
CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) { … }

const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const { … }

CXXDestructorDecl *CXXRecordDecl::getDestructor() const { … }

static bool isDeclContextInNamespace(const DeclContext *DC) { … }

bool CXXRecordDecl::isInterfaceLike() const { … }

void CXXRecordDecl::completeDefinition() { … }

static bool hasPureVirtualFinalOverrider(
    const CXXRecordDecl &RD, const CXXFinalOverriderMap *FinalOverriders) { … }

void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) { … }

bool CXXRecordDecl::mayBeAbstract() const { … }

bool CXXRecordDecl::isEffectivelyFinal() const { … }

void CXXDeductionGuideDecl::anchor() { … }

bool ExplicitSpecifier::isEquivalent(const ExplicitSpecifier Other) const { … }

ExplicitSpecifier ExplicitSpecifier::getFromDecl(FunctionDecl *Function) { … }

CXXDeductionGuideDecl *CXXDeductionGuideDecl::Create(
    ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
    ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T,
    TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor,
    DeductionCandidate Kind, Expr *TrailingRequiresClause) { … }

CXXDeductionGuideDecl *
CXXDeductionGuideDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

RequiresExprBodyDecl *RequiresExprBodyDecl::Create(
    ASTContext &C, DeclContext *DC, SourceLocation StartLoc) { … }

RequiresExprBodyDecl *
RequiresExprBodyDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

void CXXMethodDecl::anchor() { … }

bool CXXMethodDecl::isStatic() const { … }

static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
                                 const CXXMethodDecl *BaseMD) { … }

CXXMethodDecl *
CXXMethodDecl::getCorrespondingMethodDeclaredInClass(const CXXRecordDecl *RD,
                                                     bool MayBeBase) { … }

CXXMethodDecl *
CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
                                             bool MayBeBase) { … }

CXXMethodDecl *
CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                      const DeclarationNameInfo &NameInfo, QualType T,
                      TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin,
                      bool isInline, ConstexprSpecKind ConstexprKind,
                      SourceLocation EndLocation,
                      Expr *TrailingRequiresClause) { … }

CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C,
                                                 GlobalDeclID ID) { … }

CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base,
                                                     bool IsAppleKext) { … }

bool CXXMethodDecl::isUsualDeallocationFunction(
    SmallVectorImpl<const FunctionDecl *> &PreventedBy) const { … }

bool CXXMethodDecl::isExplicitObjectMemberFunction() const { … }

bool CXXMethodDecl::isImplicitObjectMemberFunction() const { … }

bool CXXMethodDecl::isCopyAssignmentOperator() const { … }

bool CXXMethodDecl::isMoveAssignmentOperator() const { … }

void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) { … }

CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const { … }

CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const { … }

unsigned CXXMethodDecl::size_overridden_methods() const { … }

CXXMethodDecl::overridden_method_range
CXXMethodDecl::overridden_methods() const { … }

static QualType getThisObjectType(ASTContext &C, const FunctionProtoType *FPT,
                                  const CXXRecordDecl *Decl) { … }

QualType CXXMethodDecl::getThisType(const FunctionProtoType *FPT,
                                    const CXXRecordDecl *Decl) { … }

QualType CXXMethodDecl::getThisType() const { … }

QualType CXXMethodDecl::getFunctionObjectParameterReferenceType() const { … }

bool CXXMethodDecl::hasInlineBody() const { … }

bool CXXMethodDecl::isLambdaStaticInvoker() const { … }

CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
                                       TypeSourceInfo *TInfo, bool IsVirtual,
                                       SourceLocation L, Expr *Init,
                                       SourceLocation R,
                                       SourceLocation EllipsisLoc)
    : … { … }

CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, FieldDecl *Member,
                                       SourceLocation MemberLoc,
                                       SourceLocation L, Expr *Init,
                                       SourceLocation R)
    : … { … }

CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
                                       IndirectFieldDecl *Member,
                                       SourceLocation MemberLoc,
                                       SourceLocation L, Expr *Init,
                                       SourceLocation R)
    : … { … }

CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
                                       TypeSourceInfo *TInfo,
                                       SourceLocation L, Expr *Init,
                                       SourceLocation R)
    : … { … }

int64_t CXXCtorInitializer::getID(const ASTContext &Context) const { … }

TypeLoc CXXCtorInitializer::getBaseClassLoc() const { … }

const Type *CXXCtorInitializer::getBaseClass() const { … }

SourceLocation CXXCtorInitializer::getSourceLocation() const { … }

SourceRange CXXCtorInitializer::getSourceRange() const { … }

CXXConstructorDecl::CXXConstructorDecl(
    ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
    ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline,
    bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
    InheritedConstructor Inherited, Expr *TrailingRequiresClause)
    : … { … }

void CXXConstructorDecl::anchor() { … }

CXXConstructorDecl *CXXConstructorDecl::CreateDeserialized(ASTContext &C,
                                                           GlobalDeclID ID,
                                                           uint64_t AllocKind) { … }

CXXConstructorDecl *CXXConstructorDecl::Create(
    ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
    ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline,
    bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
    InheritedConstructor Inherited, Expr *TrailingRequiresClause) { … }

CXXConstructorDecl::init_const_iterator CXXConstructorDecl::init_begin() const { … }

CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const { … }

bool CXXConstructorDecl::isDefaultConstructor() const { … }

bool
CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const { … }

bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const { … }

/// Determine whether this is a copy or move constructor.
bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const { … }

bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const { … }

bool CXXConstructorDecl::isSpecializationCopyingObject() const { … }

void CXXDestructorDecl::anchor() { … }

CXXDestructorDecl *CXXDestructorDecl::CreateDeserialized(ASTContext &C,
                                                         GlobalDeclID ID) { … }

CXXDestructorDecl *CXXDestructorDecl::Create(
    ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
    bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared,
    ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause) { … }

void CXXDestructorDecl::setOperatorDelete(FunctionDecl *OD, Expr *ThisArg) { … }

void CXXConversionDecl::anchor() { … }

CXXConversionDecl *CXXConversionDecl::CreateDeserialized(ASTContext &C,
                                                         GlobalDeclID ID) { … }

CXXConversionDecl *CXXConversionDecl::Create(
    ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
    bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES,
    ConstexprSpecKind ConstexprKind, SourceLocation EndLocation,
    Expr *TrailingRequiresClause) { … }

bool CXXConversionDecl::isLambdaToBlockPointerConversion() const { … }

LinkageSpecDecl::LinkageSpecDecl(DeclContext *DC, SourceLocation ExternLoc,
                                 SourceLocation LangLoc,
                                 LinkageSpecLanguageIDs lang, bool HasBraces)
    : … { … }

void LinkageSpecDecl::anchor() { … }

LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C, DeclContext *DC,
                                         SourceLocation ExternLoc,
                                         SourceLocation LangLoc,
                                         LinkageSpecLanguageIDs Lang,
                                         bool HasBraces) { … }

LinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C,
                                                     GlobalDeclID ID) { … }

void UsingDirectiveDecl::anchor() { … }

UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
                                               SourceLocation L,
                                               SourceLocation NamespaceLoc,
                                           NestedNameSpecifierLoc QualifierLoc,
                                               SourceLocation IdentLoc,
                                               NamedDecl *Used,
                                               DeclContext *CommonAncestor) { … }

UsingDirectiveDecl *UsingDirectiveDecl::CreateDeserialized(ASTContext &C,
                                                           GlobalDeclID ID) { … }

NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() { … }

NamespaceDecl::NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
                             SourceLocation StartLoc, SourceLocation IdLoc,
                             IdentifierInfo *Id, NamespaceDecl *PrevDecl,
                             bool Nested)
    : … { … }

NamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC,
                                     bool Inline, SourceLocation StartLoc,
                                     SourceLocation IdLoc, IdentifierInfo *Id,
                                     NamespaceDecl *PrevDecl, bool Nested) { … }

NamespaceDecl *NamespaceDecl::CreateDeserialized(ASTContext &C,
                                                 GlobalDeclID ID) { … }

NamespaceDecl *NamespaceDecl::getNextRedeclarationImpl() { … }

NamespaceDecl *NamespaceDecl::getPreviousDeclImpl() { … }

NamespaceDecl *NamespaceDecl::getMostRecentDeclImpl() { … }

void NamespaceAliasDecl::anchor() { … }

NamespaceAliasDecl *NamespaceAliasDecl::getNextRedeclarationImpl() { … }

NamespaceAliasDecl *NamespaceAliasDecl::getPreviousDeclImpl() { … }

NamespaceAliasDecl *NamespaceAliasDecl::getMostRecentDeclImpl() { … }

NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
                                               SourceLocation UsingLoc,
                                               SourceLocation AliasLoc,
                                               IdentifierInfo *Alias,
                                           NestedNameSpecifierLoc QualifierLoc,
                                               SourceLocation IdentLoc,
                                               NamedDecl *Namespace) { … }

NamespaceAliasDecl *NamespaceAliasDecl::CreateDeserialized(ASTContext &C,
                                                           GlobalDeclID ID) { … }

void LifetimeExtendedTemporaryDecl::anchor() { … }

/// Retrieve the storage duration for the materialized temporary.
StorageDuration LifetimeExtendedTemporaryDecl::getStorageDuration() const { … }

APValue *LifetimeExtendedTemporaryDecl::getOrCreateValue(bool MayCreate) const { … }

void UsingShadowDecl::anchor() { … }

UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, DeclContext *DC,
                                 SourceLocation Loc, DeclarationName Name,
                                 BaseUsingDecl *Introducer, NamedDecl *Target)
    : … { … }

UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, EmptyShell Empty)
    : … { … }

UsingShadowDecl *UsingShadowDecl::CreateDeserialized(ASTContext &C,
                                                     GlobalDeclID ID) { … }

BaseUsingDecl *UsingShadowDecl::getIntroducer() const { … }

void ConstructorUsingShadowDecl::anchor() { … }

ConstructorUsingShadowDecl *
ConstructorUsingShadowDecl::Create(ASTContext &C, DeclContext *DC,
                                   SourceLocation Loc, UsingDecl *Using,
                                   NamedDecl *Target, bool IsVirtual) { … }

ConstructorUsingShadowDecl *
ConstructorUsingShadowDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

CXXRecordDecl *ConstructorUsingShadowDecl::getNominatedBaseClass() const { … }

void BaseUsingDecl::anchor() { … }

void BaseUsingDecl::addShadowDecl(UsingShadowDecl *S) { … }

void BaseUsingDecl::removeShadowDecl(UsingShadowDecl *S) { … }

void UsingDecl::anchor() { … }

UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
                             NestedNameSpecifierLoc QualifierLoc,
                             const DeclarationNameInfo &NameInfo,
                             bool HasTypename) { … }

UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

SourceRange UsingDecl::getSourceRange() const { … }

void UsingEnumDecl::anchor() { … }

UsingEnumDecl *UsingEnumDecl::Create(ASTContext &C, DeclContext *DC,
                                     SourceLocation UL,
                                     SourceLocation EL,
                                     SourceLocation NL,
                                     TypeSourceInfo *EnumType) { … }

UsingEnumDecl *UsingEnumDecl::CreateDeserialized(ASTContext &C,
                                                 GlobalDeclID ID) { … }

SourceRange UsingEnumDecl::getSourceRange() const { … }

void UsingPackDecl::anchor() { … }

UsingPackDecl *UsingPackDecl::Create(ASTContext &C, DeclContext *DC,
                                     NamedDecl *InstantiatedFrom,
                                     ArrayRef<NamedDecl *> UsingDecls) { … }

UsingPackDecl *UsingPackDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID,
                                                 unsigned NumExpansions) { … }

void UnresolvedUsingValueDecl::anchor() { … }

UnresolvedUsingValueDecl *
UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
                                 SourceLocation UsingLoc,
                                 NestedNameSpecifierLoc QualifierLoc,
                                 const DeclarationNameInfo &NameInfo,
                                 SourceLocation EllipsisLoc) { … }

UnresolvedUsingValueDecl *
UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

SourceRange UnresolvedUsingValueDecl::getSourceRange() const { … }

void UnresolvedUsingTypenameDecl::anchor() { … }

UnresolvedUsingTypenameDecl *
UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
                                    SourceLocation UsingLoc,
                                    SourceLocation TypenameLoc,
                                    NestedNameSpecifierLoc QualifierLoc,
                                    SourceLocation TargetNameLoc,
                                    DeclarationName TargetName,
                                    SourceLocation EllipsisLoc) { … }

UnresolvedUsingTypenameDecl *
UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C,
                                                GlobalDeclID ID) { … }

UnresolvedUsingIfExistsDecl *
UnresolvedUsingIfExistsDecl::Create(ASTContext &Ctx, DeclContext *DC,
                                    SourceLocation Loc, DeclarationName Name) { … }

UnresolvedUsingIfExistsDecl *
UnresolvedUsingIfExistsDecl::CreateDeserialized(ASTContext &Ctx,
                                                GlobalDeclID ID) { … }

UnresolvedUsingIfExistsDecl::UnresolvedUsingIfExistsDecl(DeclContext *DC,
                                                         SourceLocation Loc,
                                                         DeclarationName Name)
    : … { … }

void UnresolvedUsingIfExistsDecl::anchor() { … }

void StaticAssertDecl::anchor() { … }

StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
                                           SourceLocation StaticAssertLoc,
                                           Expr *AssertExpr, Expr *Message,
                                           SourceLocation RParenLoc,
                                           bool Failed) { … }

StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
                                                       GlobalDeclID ID) { … }

VarDecl *ValueDecl::getPotentiallyDecomposedVarDecl() { … }

void BindingDecl::anchor() { … }

BindingDecl *BindingDecl::Create(ASTContext &C, DeclContext *DC,
                                 SourceLocation IdLoc, IdentifierInfo *Id) { … }

BindingDecl *BindingDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

VarDecl *BindingDecl::getHoldingVar() const { … }

void DecompositionDecl::anchor() { … }

DecompositionDecl *DecompositionDecl::Create(ASTContext &C, DeclContext *DC,
                                             SourceLocation StartLoc,
                                             SourceLocation LSquareLoc,
                                             QualType T, TypeSourceInfo *TInfo,
                                             StorageClass SC,
                                             ArrayRef<BindingDecl *> Bindings) { … }

DecompositionDecl *DecompositionDecl::CreateDeserialized(ASTContext &C,
                                                         GlobalDeclID ID,
                                                         unsigned NumBindings) { … }

void DecompositionDecl::printName(llvm::raw_ostream &OS,
                                  const PrintingPolicy &Policy) const { … }

void MSPropertyDecl::anchor() { … }

MSPropertyDecl *MSPropertyDecl::Create(ASTContext &C, DeclContext *DC,
                                       SourceLocation L, DeclarationName N,
                                       QualType T, TypeSourceInfo *TInfo,
                                       SourceLocation StartL,
                                       IdentifierInfo *Getter,
                                       IdentifierInfo *Setter) { … }

MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C,
                                                   GlobalDeclID ID) { … }

void MSGuidDecl::anchor() { … }

MSGuidDecl::MSGuidDecl(DeclContext *DC, QualType T, Parts P)
    : … { … }

MSGuidDecl *MSGuidDecl::Create(const ASTContext &C, QualType T, Parts P) { … }

MSGuidDecl *MSGuidDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

void MSGuidDecl::printName(llvm::raw_ostream &OS,
                           const PrintingPolicy &) const { … }

/// Determine if T is a valid 'struct _GUID' of the shape that we expect.
static bool isValidStructGUID(ASTContext &Ctx, QualType T) { … }

APValue &MSGuidDecl::getAsAPValue() const { … }

void UnnamedGlobalConstantDecl::anchor() { … }

UnnamedGlobalConstantDecl::UnnamedGlobalConstantDecl(const ASTContext &C,
                                                     DeclContext *DC,
                                                     QualType Ty,
                                                     const APValue &Val)
    : … { … }

UnnamedGlobalConstantDecl *
UnnamedGlobalConstantDecl::Create(const ASTContext &C, QualType T,
                                  const APValue &Value) { … }

UnnamedGlobalConstantDecl *
UnnamedGlobalConstantDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) { … }

void UnnamedGlobalConstantDecl::printName(llvm::raw_ostream &OS,
                                          const PrintingPolicy &) const { … }

static const char *getAccessName(AccessSpecifier AS) { … }

const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
                                             AccessSpecifier AS) { … }