Decl.cpp

//===--- Decl.cpp - Swift Language Decl ASTs ------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file implements the Decl class and subclasses.
//
//===----------------------------------------------------------------------===//

#include"swift/AST/Decl.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/ASTMangler.h"
#include"swift/AST/ASTPrinter.h"
#include"swift/AST/ASTWalker.h"
#include"swift/AST/AccessRequests.h"
#include"swift/AST/AccessScope.h"
#include"swift/AST/Attr.h"
#include"swift/AST/AvailabilityContext.h"
#include"swift/AST/AvailabilityInference.h"
#include"swift/AST/CaptureInfo.h"
#include"swift/AST/ConformanceLookup.h"
#include"swift/AST/DeclExportabilityVisitor.h"
#include"swift/AST/DiagnosticEngine.h"
#include"swift/AST/DiagnosticsSema.h"
#include"swift/AST/ExistentialLayout.h"
#include"swift/AST/Expr.h"
#include"swift/AST/GenericEnvironment.h"
#include"swift/AST/GenericSignature.h"
#include"swift/AST/ImportCache.h"
#include"swift/AST/Initializer.h"
#include"swift/AST/LazyResolver.h"
#include"swift/AST/LookupKinds.h"
#include"swift/AST/MacroDefinition.h"
#include"swift/AST/MacroDiscriminatorContext.h"
#include"swift/AST/Module.h"
#include"swift/AST/NameLookup.h"
#include"swift/AST/NameLookupRequests.h"
#include"swift/AST/ParameterList.h"
#include"swift/AST/ParseRequests.h"
#include"swift/AST/Pattern.h"
#include"swift/AST/PropertyWrappers.h"
#include"swift/AST/ProtocolConformance.h"
#include"swift/AST/ResilienceExpansion.h"
#include"swift/AST/SourceFile.h"
#include"swift/AST/Stmt.h"
#include"swift/AST/SwiftNameTranslation.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/AST/TypeLoc.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/Defer.h"
#include"swift/Basic/Range.h"
#include"swift/Basic/Statistic.h"
#include"swift/Basic/StringExtras.h"
#include"swift/Basic/TypeID.h"
#include"swift/ClangImporter/ClangImporterRequests.h"
#include"swift/ClangImporter/ClangModule.h"
#include"swift/Demangling/ManglingMacros.h"
#include"swift/Parse/Lexer.h"// FIXME: Bad dependency
#include"swift/Strings.h"
#include"clang/Lex/MacroInfo.h"
#include"llvm/ADT/DenseMap.h"
#include"llvm/ADT/SmallPtrSet.h"
#include"llvm/ADT/SmallSet.h"
#include"llvm/ADT/SmallString.h"
#include"llvm/ADT/Statistic.h"
#include"llvm/Support/Compiler.h"
#include"llvm/Support/raw_ostream.h"

#include"clang/Basic/CharInfo.h"
#include"clang/Basic/Module.h"
#include"clang/AST/Attr.h"
#include"clang/AST/DeclObjC.h"

#include"InlinableText.h"
#include<algorithm>

usingnamespaceswift;

#defineDEBUG_TYPE"Serialization"

STATISTIC(NumLazyRequirementSignatures,
"# of lazily-deserialized requirement signatures known");

#undef DEBUG_TYPE

#defineDECL(Id, _) \
static_assert((DeclKind::Id == DeclKind::Module) ^ \
 IsTriviallyDestructible<Id##Decl>::value, \
"Decls are BumpPtrAllocated; the destructor is never called");
#include"swift/AST/DeclNodes.def"
static_assert(IsTriviallyDestructible<ParameterList>::value,
"ParameterLists are BumpPtrAllocated; the d'tor is never called");
static_assert(IsTriviallyDestructible<GenericParamList>::value,
"GenericParamLists are BumpPtrAllocated; the d'tor isn't called");

const clang::MacroInfo *ClangNode::getAsMacro() const {
if (auto MM = getAsModuleMacro())
return MM->getMacroInfo();
returngetAsMacroInfo();
}

clang::SourceLocation ClangNode::getLocation() const {
if (auto D = getAsDecl())
return D->getLocation();
if (auto M = getAsMacro())
return M->getDefinitionLoc();

returnclang::SourceLocation();
}

clang::SourceRange ClangNode::getSourceRange() const {
if (auto D = getAsDecl())
return D->getSourceRange();
if (auto M = getAsMacro())
returnclang::SourceRange(M->getDefinitionLoc(), M->getDefinitionEndLoc());

returnclang::SourceLocation();
}

const clang::Module *ClangNode::getClangModule() const {
if (auto *M = getAsModule())
return M;
if (auto *ID = dyn_cast_or_null<clang::ImportDecl>(getAsDecl()))
return ID->getImportedModule();
returnnullptr;
}

const clang::Module *ClangNode::getOwningClangModule() const {
if (auto *M = getAsModule())
return M;
if (auto D = getAsDecl())
return D->getOwningModule();
if (auto MI = getAsModuleMacro())
return MI->getOwningModule();
returnnullptr;
}

voidClangNode::dump() const {
if (auto D = getAsDecl())
 D->dump();
elseif (auto M = getAsMacro())
 M->dump();
elseif (auto M = getAsModule())
 M->dump();
else
llvm::errs() << "ClangNode contains nullptr\n";
}

StringRef Decl::getKindName(DeclKind K) {
switch (K) {
#defineDECL(Id, Parent) case DeclKind::Id: return #Id;
#include"swift/AST/DeclNodes.def"
 }
llvm_unreachable("bad DeclKind");
}

DescriptiveDeclKind Decl::getDescriptiveKind() const {
#defineTRIVIAL_KIND(Kind) \
case DeclKind::Kind: \
return DescriptiveDeclKind::Kind

switch (getKind()) {
TRIVIAL_KIND(Import);
TRIVIAL_KIND(Extension);
TRIVIAL_KIND(EnumCase);
TRIVIAL_KIND(TopLevelCode);
TRIVIAL_KIND(PatternBinding);
TRIVIAL_KIND(PrecedenceGroup);
TRIVIAL_KIND(InfixOperator);
TRIVIAL_KIND(PrefixOperator);
TRIVIAL_KIND(PostfixOperator);
TRIVIAL_KIND(GenericTypeParam);
TRIVIAL_KIND(AssociatedType);
TRIVIAL_KIND(Protocol);
TRIVIAL_KIND(Constructor);
TRIVIAL_KIND(Destructor);
TRIVIAL_KIND(EnumElement);
TRIVIAL_KIND(Param);
TRIVIAL_KIND(Module);
TRIVIAL_KIND(Missing);
TRIVIAL_KIND(MissingMember);
TRIVIAL_KIND(Macro);
TRIVIAL_KIND(MacroExpansion);

case DeclKind::TypeAlias:
return cast<TypeAliasDecl>(this)->getGenericParams()
 ? DescriptiveDeclKind::GenericTypeAlias
 : DescriptiveDeclKind::TypeAlias;

case DeclKind::Enum:
return cast<EnumDecl>(this)->getGenericParams()
 ? DescriptiveDeclKind::GenericEnum
 : DescriptiveDeclKind::Enum;

case DeclKind::Struct:
return cast<StructDecl>(this)->getGenericParams()
 ? DescriptiveDeclKind::GenericStruct
 : DescriptiveDeclKind::Struct;

case DeclKind::Class: {
auto clazz = cast<ClassDecl>(this);
bool isAnyActor = clazz->isAnyActor();
bool isGeneric = clazz->getGenericParams();

auto kind = isGeneric ? DescriptiveDeclKind::GenericClass
 : DescriptiveDeclKind::Class;

if (isAnyActor) {
if (clazz->isDistributedActor()) {
 kind = isGeneric ? DescriptiveDeclKind::GenericDistributedActor
 : DescriptiveDeclKind::DistributedActor;
 } else {
 kind = isGeneric ? DescriptiveDeclKind::GenericActor
 : DescriptiveDeclKind::Actor;
 }
 }
return kind;
 }

case DeclKind::Var: {
auto var = cast<VarDecl>(this);
switch (var->getCorrectStaticSpelling()) {
case StaticSpellingKind::None:
if (var->getDeclContext()->isTypeContext()) {
if (var->isDistributed() && !var->isLet()) {
return DescriptiveDeclKind::DistributedProperty;
 }

return DescriptiveDeclKind::Property;
 }
return var->isLet() ? DescriptiveDeclKind::Let
 : DescriptiveDeclKind::Var;
case StaticSpellingKind::KeywordStatic:
return DescriptiveDeclKind::StaticProperty;
case StaticSpellingKind::KeywordClass:
return DescriptiveDeclKind::ClassProperty;
 }
 }

case DeclKind::Subscript: {
auto subscript = cast<SubscriptDecl>(this);
switch (subscript->getCorrectStaticSpelling()) {
case StaticSpellingKind::None:
return DescriptiveDeclKind::Subscript;
case StaticSpellingKind::KeywordStatic:
return DescriptiveDeclKind::StaticSubscript;
case StaticSpellingKind::KeywordClass:
return DescriptiveDeclKind::ClassSubscript;
 }
 }

case DeclKind::Accessor: {
auto accessor = cast<AccessorDecl>(this);

switch (accessor->getAccessorKind()) {
case AccessorKind::Get:
case AccessorKind::DistributedGet:
return DescriptiveDeclKind::Getter;

case AccessorKind::Set:
return DescriptiveDeclKind::Setter;

case AccessorKind::WillSet:
return DescriptiveDeclKind::WillSet;

case AccessorKind::DidSet:
return DescriptiveDeclKind::DidSet;

case AccessorKind::Address:
return DescriptiveDeclKind::Addressor;

case AccessorKind::MutableAddress:
return DescriptiveDeclKind::MutableAddressor;

case AccessorKind::Read:
case AccessorKind::Read2:
return DescriptiveDeclKind::ReadAccessor;

case AccessorKind::Modify:
case AccessorKind::Modify2:
return DescriptiveDeclKind::ModifyAccessor;

case AccessorKind::Init:
return DescriptiveDeclKind::InitAccessor;
 }
llvm_unreachable("bad accessor kind");
 }

case DeclKind::Func: {
auto func = cast<FuncDecl>(this);

if (func->isOperator())
return DescriptiveDeclKind::OperatorFunction;

if (func->getDeclContext()->isLocalContext())
return DescriptiveDeclKind::LocalFunction;

if (func->getDeclContext()->isModuleScopeContext())
return DescriptiveDeclKind::GlobalFunction;

// We have a method.
switch (func->getCorrectStaticSpelling()) {
case StaticSpellingKind::None:
if (func->isDistributed()) {
return DescriptiveDeclKind::DistributedMethod;
 } else {
return DescriptiveDeclKind::Method;
 }
case StaticSpellingKind::KeywordStatic:
return DescriptiveDeclKind::StaticMethod;
case StaticSpellingKind::KeywordClass:
return DescriptiveDeclKind::ClassMethod;
 }
 }

case DeclKind::OpaqueType: {
auto *opaqueTypeDecl = cast<OpaqueTypeDecl>(this);
if (dyn_cast_or_null<VarDecl>(opaqueTypeDecl->getNamingDecl()))
return DescriptiveDeclKind::OpaqueVarType;
return DescriptiveDeclKind::OpaqueResultType;
 }

case DeclKind::BuiltinTuple:
llvm_unreachable("BuiltinTupleDecl should not end up here");
 }
#undef TRIVIAL_KIND
llvm_unreachable("bad DescriptiveDeclKind");
}

StringRef Decl::getDescriptiveKindName(DescriptiveDeclKind K) {
#defineENTRY(Kind, String) case DescriptiveDeclKind::Kind: return String
switch (K) {
ENTRY(Import, "import");
ENTRY(Extension, "extension");
ENTRY(EnumCase, "case");
ENTRY(TopLevelCode, "top-level code");
ENTRY(PatternBinding, "pattern binding");
ENTRY(Var, "var");
ENTRY(Param, "parameter");
ENTRY(Let, "let");
ENTRY(Property, "property");
ENTRY(StaticProperty, "static property");
ENTRY(ClassProperty, "class property");
ENTRY(DistributedProperty, "distributed property");
ENTRY(PrecedenceGroup, "precedence group");
ENTRY(InfixOperator, "infix operator");
ENTRY(PrefixOperator, "prefix operator");
ENTRY(PostfixOperator, "postfix operator");
ENTRY(TypeAlias, "type alias");
ENTRY(GenericTypeAlias, "generic type alias");
ENTRY(GenericTypeParam, "generic parameter");
ENTRY(AssociatedType, "associated type");
ENTRY(Type, "type");
ENTRY(Enum, "enum");
ENTRY(Struct, "struct");
ENTRY(Class, "class");
ENTRY(Actor, "actor");
ENTRY(DistributedActor, "distributed actor");
ENTRY(Protocol, "protocol");
ENTRY(GenericEnum, "generic enum");
ENTRY(GenericStruct, "generic struct");
ENTRY(GenericClass, "generic class");
ENTRY(GenericActor, "generic actor");
ENTRY(GenericDistributedActor, "generic distributed actor");
ENTRY(Subscript, "subscript");
ENTRY(StaticSubscript, "static subscript");
ENTRY(ClassSubscript, "class subscript");
ENTRY(Constructor, "initializer");
ENTRY(Destructor, "deinitializer");
ENTRY(LocalFunction, "local function");
ENTRY(GlobalFunction, "global function");
ENTRY(OperatorFunction, "operator function");
ENTRY(Method, "instance method");
ENTRY(StaticMethod, "static method");
ENTRY(ClassMethod, "class method");
ENTRY(DistributedMethod, "distributed instance method");
ENTRY(Getter, "getter");
ENTRY(Setter, "setter");
ENTRY(WillSet, "willSet observer");
ENTRY(DidSet, "didSet observer");
ENTRY(Addressor, "address accessor");
ENTRY(MutableAddressor, "mutableAddress accessor");
ENTRY(ReadAccessor, "_read accessor");
ENTRY(ModifyAccessor, "_modify accessor");
ENTRY(InitAccessor, "init accessor");
ENTRY(EnumElement, "enum case");
ENTRY(Module, "module");
ENTRY(Missing, "missing decl");
ENTRY(MissingMember, "missing member placeholder");
ENTRY(Requirement, "requirement");
ENTRY(OpaqueResultType, "result");
ENTRY(OpaqueVarType, "type");
ENTRY(Macro, "macro");
ENTRY(MacroExpansion, "pound literal");
 }
#undef ENTRY
llvm_unreachable("bad DescriptiveDeclKind");
}

ParsedDeclAttributes Decl::getParsedAttrs() const {
returnParsedDeclAttributes(getAttrs(), this);
}

DeclAttributes Decl::getExpandedAttrs() const {
auto mutableThis = const_cast<Decl *>(this);
 (void)evaluateOrDefault(getASTContext().evaluator,
 ExpandMemberAttributeMacros{mutableThis}, {});

returngetAttrs();
}

DeclAttributes Decl::getSemanticAttrs() const {
 (void)evaluateOrDefault(getASTContext().evaluator,
 SemanticDeclAttrsRequest{this}, {});
returngetAttrs();
}

voidDecl::attachParsedAttrs(DeclAttributes attrs) {
ASSERT(getAttrs().isEmpty() && "attaching when there are already attrs?");

for (auto *attr : attrs.getAttributes<DifferentiableAttr>())
 attr->setOriginalDeclaration(this);
for (auto *attr : attrs.getAttributes<DerivativeAttr>())
 attr->setOriginalDeclaration(this);
for (auto attr : attrs.getAttributes<ABIAttr, /*AllowInvalid=*/true>())
recordABIAttr(attr);

// @implementation requires an explicit @objc attribute, but
// @_objcImplementation didn't. Insert one if necessary.
auto implAttr = attrs.getAttribute<ObjCImplementationAttr>();
if (implAttr && isa<ExtensionDecl>(this) && implAttr->isEarlyAdopter() &&
 !attrs.hasAttribute<ObjCAttr>()) {
 ObjCAttr *objcAttr =
 implAttr->CategoryName.empty()
 ? ObjCAttr::createUnnamedImplicit(getASTContext())
 : ObjCAttr::createNullary(getASTContext(), implAttr->CategoryName,
/*isNameImplicit=*/false);
 attrs.add(objcAttr);
 }

getAttrs() = attrs;
}

voidDecl::visitAuxiliaryDecls(
 AuxiliaryDeclCallback callback,
bool visitFreestandingExpanded
) const {
auto &ctx = getASTContext();
auto *mutableThis = const_cast<Decl *>(this);
 SourceManager &sourceMgr = ctx.SourceMgr;
auto *moduleDecl = getModuleContext();

auto peerBuffers =
evaluateOrDefault(ctx.evaluator,
 ExpandPeerMacroRequest{mutableThis},
 {});

for (auto bufferID : peerBuffers) {
auto startLoc = sourceMgr.getLocForBufferStart(bufferID);
auto *sourceFile = moduleDecl->getSourceFileContainingLocation(startLoc);
for (auto *peer : sourceFile->getTopLevelDecls()) {
callback(peer);
 }
 }

if (visitFreestandingExpanded) {
 Decl *thisDecl = mutableThis;

// If this is a top-level code decl consisting of a macro expansion
// expression that substituted with a macro expansion declaration, use
// that instead.
if (auto *tlcd = dyn_cast<TopLevelCodeDecl>(thisDecl)) {
if (auto body = tlcd->getBody()) {
if (body->getNumElements() == 1) {
if (auto expr = body->getFirstElement().dyn_cast<Expr *>()) {
if (auto expansion = dyn_cast<MacroExpansionExpr>(expr)) {
if (auto substitute = expansion->getSubstituteDecl())
 thisDecl = substitute;
 }
 }
 }
 }
 }

if (auto *med = dyn_cast<MacroExpansionDecl>(thisDecl)) {
if (auto bufferID = evaluateOrDefault(
 ctx.evaluator, ExpandMacroExpansionDeclRequest{med}, {})) {
auto startLoc = sourceMgr.getLocForBufferStart(*bufferID);
auto *sourceFile = moduleDecl->getSourceFileContainingLocation(startLoc);
for (auto *decl : sourceFile->getTopLevelDecls())
callback(decl);
 }
 }
 }

// FIXME: fold VarDecl::visitAuxiliaryDecls into this.
}

voidDecl::forEachAttachedMacro(MacroRole role,
 MacroCallback macroCallback) const {
for (auto customAttrConst : getExpandedAttrs().getAttributes<CustomAttr>()) {
auto customAttr = const_cast<CustomAttr *>(customAttrConst);
auto *macroDecl = getResolvedMacro(customAttr);

if (!macroDecl)
continue;

if (!macroDecl->getMacroRoles().contains(role))
continue;

macroCallback(customAttr, macroDecl);
 }
}

MacroDecl *Decl::getResolvedMacro(CustomAttr *customAttr) const {
auto declRef = evaluateOrDefault(
getASTContext().evaluator,
 ResolveMacroRequest{customAttr, getDeclContext()}, ConcreteDeclRef());

return dyn_cast_or_null<MacroDecl>(declRef.getDecl());
}

unsignedDecl::getAttachedMacroDiscriminator(DeclBaseName macroName,
 MacroRole role,
const CustomAttr *attr) const {
assert(isAttachedMacro(role) && "Not an attached macro role");

if (role != MacroRole::MemberAttribute) {
 llvm::SmallDenseMap<Identifier, unsigned> nextDiscriminator;
 std::optional<unsigned> foundDiscriminator;

forEachAttachedMacro(
 role, [&](CustomAttr *foundAttr, MacroDecl *foundMacro) {
unsigned discriminator =
 nextDiscriminator[foundMacro->getBaseIdentifier()]++;
if (attr == foundAttr)
 foundDiscriminator = discriminator;
 });

if (foundDiscriminator)
return *foundDiscriminator;
 }

// If that failed, conjure up a discriminator.
// FIXME: Better discriminator for member attributes - add the member name?
 ASTContext &ctx = getASTContext();
assert(role == MacroRole::MemberAttribute || ctx.Diags.hadAnyError());
return ctx.getNextMacroDiscriminator(
MacroDiscriminatorContext::getParentOf(getLoc(), getDeclContext()),
 macroName);
}

Type Decl::getResolvedCustomAttrType(CustomAttr *attr) const {
if (auto ty = attr->getType())
return ty;

auto dc = getDeclContext();
auto *nominal = evaluateOrDefault(
getASTContext().evaluator, CustomAttrNominalRequest{attr, dc}, nullptr);
if (!nominal)
returnType();

 CustomAttrTypeKind kind;
if (nominal->isGlobalActor()) {
 kind = CustomAttrTypeKind::GlobalActor;
 } elseif (nominal->getAttrs().hasAttribute<PropertyWrapperAttr>()) {
 kind = CustomAttrTypeKind::PropertyWrapper;
 } else {
 kind = CustomAttrTypeKind::NonGeneric;
 }

returnevaluateOrDefault(getASTContext().evaluator,
 CustomAttrTypeRequest{attr, dc, kind}, Type());
}

boolDecl::isExposedToClients() const {
returnDeclExportabilityVisitor().visit(this);
}

const Decl *Decl::getInnermostDeclWithAvailability() const {
if (getAttrs().hasAttribute<AvailableAttr>())
returnthis;

if (auto parent =
AvailabilityInference::parentDeclForInferredAvailability(this))
return parent->getInnermostDeclWithAvailability();

returnnullptr;
}

std::optional<llvm::VersionTuple>
Decl::getIntroducedOSVersion(PlatformKind Kind) const {
for (auto attr : getSemanticAvailableAttrs()) {
if (attr.getPlatform() == Kind && attr.getIntroduced().has_value())
return attr.getIntroduced();
 }
return std::nullopt;
}

std::optional<llvm::VersionTuple>
Decl::getBackDeployedBeforeOSVersion(ASTContext &Ctx,
bool forTargetVariant) const {
if (auto *attr = getAttrs().getBackDeployed(Ctx, forTargetVariant)) {
auto version = attr->Version;
 AvailabilityDomain ignoredDomain;
AvailabilityInference::updateBeforeAvailabilityDomainForFallback(
 attr, getASTContext(), ignoredDomain, version);

// If the remap for fallback resulted in 1.0, then the
// backdeployment prior to that is not meaningful.
if (version == clang::VersionTuple(1, 0, 0, 0))
return std::nullopt;

return version;
 }

// Accessors may inherit `@backDeployed`.
if (auto *AD = dyn_cast<AccessorDecl>(this))
return AD->getStorage()->getBackDeployedBeforeOSVersion(Ctx,
 forTargetVariant);

return std::nullopt;
}

boolDecl::isBackDeployed(ASTContext &Ctx) const {
if (getBackDeployedBeforeOSVersion(Ctx))
returntrue;

if (Ctx.LangOpts.TargetVariant) {
if (getBackDeployedBeforeOSVersion(Ctx, /*forTargetVariant=*/true))
returntrue;
 }

returnfalse;
}

boolDecl::hasBackDeployedAttr() const {
if (getAttrs().hasAttribute<BackDeployedAttr>())
returntrue;

// Accessors may inherit `@backDeployed`.
if (auto *AD = dyn_cast<AccessorDecl>(this))
return AD->getStorage()->hasBackDeployedAttr();

returnfalse;
}

const Decl *Decl::getConcreteSyntaxDeclForAttributes() const {
// This function needs to be kept in sync with its counterpart,
// getAbstractSyntaxDeclForAttributes().

// The source range for VarDecls does not include 'var ' (and, in any
// event, multiple variables can be introduced with a single 'var'),
// so suggest adding an attribute to the PatterningBindingDecl instead.
if (auto *vd = dyn_cast<VarDecl>(this)) {
if (auto *pbd = vd->getParentPatternBinding())
return pbd;
 }

// Similarly suggest applying the Fix-It to the parent enum case rather than
// the enum element.
if (auto *ee = dyn_cast<EnumElementDecl>(this)) {
return ee->getParentCase();
 }

returnthis;
}

const Decl *Decl::getAbstractSyntaxDeclForAttributes() const {
// This function needs to be kept in sync with its counterpart,
// getConcreteSyntaxDeclForAttributes().

if (auto *pbd = dyn_cast<PatternBindingDecl>(this)) {
// @available attributes in the AST are attached to VarDecls
// rather than PatternBindingDecls, so we return the first VarDecl for
// the pattern binding declaration.
// This is safe, even though there may be multiple VarDecls, because
// all parsed attribute that appear in the concrete syntax upon on the
// PatternBindingDecl are added to all of the VarDecls for the pattern
// binding.
for (autoindex : range(pbd->getNumPatternEntries())) {
if (auto vd = pbd->getAnchoringVarDecl(index))
return vd;
 }
 } elseif (auto *ecd = dyn_cast<EnumCaseDecl>(this)) {
// Similar to the PatternBindingDecl case above, we return the
// first EnumElementDecl.
if (auto *element = ecd->getFirstElement()) {
return element;
 }
 }

returnthis;
}

voidDecl::forEachDeclToHoist(llvm::function_ref<void(Decl *)> callback) const {
switch (getKind()) {
case DeclKind::TopLevelCode: {
auto *TLCD = cast<TopLevelCodeDecl>(this);
if (TLCD->getBody()) {
for (auto node : TLCD->getBody()->getElements())
if (auto *d = node.dyn_cast<Decl *>())
 d->forEachDeclToHoist(callback);
 }
break;
 }
case DeclKind::PatternBinding: {
auto *PBD = cast<PatternBindingDecl>(this);
// Variable declarations are part of the list on par with pattern binding
// declarations.
for (auto i : range(PBD->getNumPatternEntries())) {
 PBD->getPattern(i)->forEachVariable([&](VarDecl *VD) { callback(VD); });
 }
break;
 }
case DeclKind::EnumCase: {
auto *ECD = cast<EnumCaseDecl>(this);
// Each enum case element is part of the members list.
for (auto *EED : ECD->getElements()) {
callback(EED);
 }
break;
 }
default:
break;
 }
}

llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &OS,
 StaticSpellingKind SSK) {
switch (SSK) {
case StaticSpellingKind::None:
return OS << "<none>";
case StaticSpellingKind::KeywordStatic:
return OS << "'static'";
case StaticSpellingKind::KeywordClass:
return OS << "'class'";
 }
llvm_unreachable("bad StaticSpellingKind");
}

llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &OS,
 ReferenceOwnership RO) {
if (RO == ReferenceOwnership::Strong)
return OS << "'strong'";
return OS << "'" << keywordOf(RO) << "'";
}

llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &OS,
 SelfAccessKind SAK) {
switch (SAK) {
case SelfAccessKind::NonMutating: return OS << "'nonmutating'";
case SelfAccessKind::Mutating: return OS << "'mutating'";
case SelfAccessKind::LegacyConsuming: return OS << "'__consuming'";
case SelfAccessKind::Consuming: return OS << "'consuming'";
case SelfAccessKind::Borrowing:
return OS << "'borrowing'";
 }
llvm_unreachable("Unknown SelfAccessKind");
}

DeclContext *Decl::getInnermostDeclContext() const {
if (auto func = dyn_cast<AbstractFunctionDecl>(this))
returnconst_cast<AbstractFunctionDecl*>(func);
if (auto subscript = dyn_cast<SubscriptDecl>(this))
returnconst_cast<SubscriptDecl*>(subscript);
if (auto type = dyn_cast<GenericTypeDecl>(this))
returnconst_cast<GenericTypeDecl*>(type);
if (auto ext = dyn_cast<ExtensionDecl>(this))
returnconst_cast<ExtensionDecl*>(ext);
if (auto topLevel = dyn_cast<TopLevelCodeDecl>(this))
returnconst_cast<TopLevelCodeDecl*>(topLevel);
if (auto macro = dyn_cast<MacroDecl>(this))
returnconst_cast<MacroDecl*>(macro);

returngetDeclContext();
}

boolDecl::isInvalid() const {
switch (getKind()) {
#defineVALUE_DECL(ID, PARENT)
#defineDECL(ID, PARENT) \
case DeclKind::ID:
#include"swift/AST/DeclNodes.def"
return Bits.Decl.Invalid;
case DeclKind::Param: {
// Parameters are special because closure parameters may not have type
// annotations. In which case, the interface type request returns
// ErrorType. Therefore, consider parameters with implicit types to always
// be valid.
auto *PD = cast<ParamDecl>(this);
if (!PD->getTypeRepr() && !PD->hasInterfaceType())
returnfalse;
 }
 LLVM_FALLTHROUGH;
case DeclKind::Enum:
case DeclKind::Struct:
case DeclKind::Class:
case DeclKind::Protocol:
case DeclKind::OpaqueType:
case DeclKind::TypeAlias:
case DeclKind::GenericTypeParam:
case DeclKind::AssociatedType:
case DeclKind::Module:
case DeclKind::Var:
case DeclKind::Subscript:
case DeclKind::Constructor:
case DeclKind::Destructor:
case DeclKind::Func:
case DeclKind::EnumElement:
case DeclKind::Macro:
return cast<ValueDecl>(this)->getInterfaceType()->hasError();

case DeclKind::Accessor: {
auto *AD = cast<AccessorDecl>(this);
if (AD->hasInterfaceType() && AD->getInterfaceType()->hasError())
returntrue;
return AD->getStorage()->isInvalid();
 }

case DeclKind::BuiltinTuple:
returnfalse;
 }

llvm_unreachable("Unknown decl kind");
}

voidDecl::setInvalidBit() { Bits.Decl.Invalid = true; }

voidDecl::setInvalid() {
switch (getKind()) {
#defineVALUE_DECL(ID, PARENT)
#defineDECL(ID, PARENT) \
case DeclKind::ID:
#include"swift/AST/DeclNodes.def"
 Bits.Decl.Invalid = true;
return;
case DeclKind::Enum:
case DeclKind::Struct:
case DeclKind::Class:
case DeclKind::Protocol:
case DeclKind::OpaqueType:
case DeclKind::TypeAlias:
case DeclKind::GenericTypeParam:
case DeclKind::AssociatedType:
case DeclKind::Module:
case DeclKind::Var:
case DeclKind::Param:
case DeclKind::Subscript:
case DeclKind::Constructor:
case DeclKind::Destructor:
case DeclKind::Func:
case DeclKind::Accessor:
case DeclKind::EnumElement:
case DeclKind::Macro:
 cast<ValueDecl>(this)->setInterfaceType(ErrorType::get(getASTContext()));
return;

case DeclKind::BuiltinTuple:
llvm_unreachable("BuiltinTupleDecl should not end up here");
 }

llvm_unreachable("Unknown decl kind");
}

voidDecl::setDeclContext(DeclContext *DC) { 
 Context = DC;
// If this Decl is also a DeclContext, we need to update its parent too.
if (auto *thisDC = dyn_cast<DeclContext>(this))
 thisDC->setParent(DC);
}

boolDecl::isUserAccessible() const {
if (auto VD = dyn_cast<ValueDecl>(this)) {
return VD->isUserAccessible();
 }
returntrue;
}

boolDecl::canHaveComment() const {
return !this->hasClangNode() &&
 (isa<ValueDecl>(this) || isa<ExtensionDecl>(this)) &&
 !isa<ParamDecl>(this) &&
 !isa<GenericTypeParamDecl>(this);
}

ModuleDecl *Decl::getModuleContext() const {
returngetDeclContext()->getParentModule();
}

/// If `decl` is an imported Cxx decl, returns the actual module that the decl
/// was imported from. This is necessary to compensate for the way that
/// Cxx `namespace` declarations are imported. Since namespaces can span
/// multiple Clang modules, the corresponding decls and all of their members get
/// associated with the Clang imported header module (named `__ObjC`). This
/// utility reaches through the Clang AST to find the actual module that members
/// of namespaces originated from.
static ModuleDecl *getModuleContextForNameLookupForCxxDecl(const Decl *decl) {
auto &ctx = decl->getASTContext();
if (!ctx.LangOpts.EnableCXXInterop)
returnnullptr;

if (!decl->hasClangNode())
returnnullptr;

auto parentModule = decl->getModuleContext();

// We only need to look for the real parent module when the existing parent
// is the imported header module.
if (!parentModule->isClangHeaderImportModule())
returnnullptr;

auto clangModule = decl->getClangDecl()->getOwningModule();
if (!clangModule)
returnnullptr;

// Swift groups all submodules of a Clang module together, and imports them as
// a single top-level module.
 clangModule = clangModule->getTopLevelModule();

return ctx.getClangModuleLoader()->getWrapperForModule(clangModule);
}

ModuleDecl *Decl::getModuleContextForNameLookup() const {
if (auto parentModule = getModuleContextForNameLookupForCxxDecl(this))
return parentModule;

returngetModuleContext();
}

/// Retrieve the diagnostic engine for diagnostics emission.
DiagnosticEngine &Decl::getDiags() const {
returngetASTContext().Diags;
}

// Helper functions to verify statically whether source-location
// functions have been overridden.
typedefconstchar (&TwoChars)[2];
template<typename Class> 
inlinecharcheckSourceLocType(SourceLoc (Class::*)() const);
inline TwoChars checkSourceLocType(SourceLoc (Decl::*)() const);

template<typename Class>
inlinecharcheckSourceLocType(SourceLoc (Class::*)(bool) const);
inline TwoChars checkSourceLocType(SourceLoc (Decl::*)(bool) const);

template<typename Class> 
inlinecharcheckSourceRangeType(SourceRange (Class::*)() const);
inline TwoChars checkSourceRangeType(SourceRange (Decl::*)() const);

SourceRange Decl::getSourceRange() const {
switch (getKind()) {
#defineDECL(ID, PARENT) \
static_assert(sizeof(checkSourceRangeType(&ID##Decl::getSourceRange)) == 1, \
 #ID "Decl is missing getSourceRange()"); \
case DeclKind::ID: return cast<ID##Decl>(this)->getSourceRange();
#include"swift/AST/DeclNodes.def"
 }

llvm_unreachable("Unknown decl kind");
}

SourceRange Decl::getSourceRangeIncludingAttrs() const {
auto Range = getSourceRange();

// Attributes on VarDecl syntactically belong to PatternBindingDecl.
if (isa<VarDecl>(this) && !isa<ParamDecl>(this))
return Range;

// Attributes on PatternBindingDecls are attached to VarDecls in AST.
if (auto *PBD = dyn_cast<PatternBindingDecl>(this)) {
for (auto i : range(PBD->getNumPatternEntries()))
 PBD->getPattern(i)->forEachVariable([&](VarDecl *VD) {
for (auto *Attr : VD->getParsedAttrs())
if (Attr->getRange().isValid())
 Range.widen(Attr->getRangeWithAt());
 });
 }

for (auto *Attr : getParsedAttrs()) {
if (Attr->getRange().isValid())
 Range.widen(Attr->getRangeWithAt());
 }
return Range;
}

boolDecl::isInMacroExpansionInContext() const {
auto *mod = getModuleContext();
auto *file = mod->getSourceFileContainingLocation(getStartLoc());

auto parentFile = [&]() {
// For accessors, the storage decl is the more accurate thing to check
// since the entire property/subscript could be macro-generated, in which