DeclContext.cpp

//===--- DeclContext.cpp - DeclContext implementation ---------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 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
//
//===----------------------------------------------------------------------===//

#include"swift/AST/DeclContext.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/ASTWalker.h"
#include"swift/AST/AccessScope.h"
#include"swift/AST/AvailabilityInference.h"
#include"swift/AST/ClangModuleLoader.h"
#include"swift/AST/DiagnosticsSema.h"
#include"swift/AST/Expr.h"
#include"swift/AST/FileUnit.h"
#include"swift/AST/GenericEnvironment.h"
#include"swift/AST/Initializer.h"
#include"swift/AST/LazyResolver.h"
#include"swift/AST/Module.h"
#include"swift/AST/ParseRequests.h"
#include"swift/AST/SourceFile.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/AST/TypeRepr.h"
#include"swift/AST/Types.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/SourceManager.h"
#include"swift/Basic/Statistic.h"
#include"swift/ClangImporter/ClangImporter.h"
#include"clang/AST/ASTContext.h"
#include"llvm/ADT/DenseMap.h"
#include"llvm/ADT/Statistic.h"
#include"llvm/Support/SaveAndRestore.h"
#include"llvm/Support/raw_ostream.h"
usingnamespaceswift;

#defineDEBUG_TYPE"Name lookup"

STATISTIC(NumLazyIterableDeclContexts,
"# of serialized iterable declaration contexts");
STATISTIC(NumUnloadedLazyIterableDeclContexts,
"# of serialized iterable declaration contexts never loaded");

ASTContext &DeclContext::getASTContext() const {
returngetParentModule()->getASTContext();
}

GenericTypeDecl *DeclContext::getSelfTypeDecl() const {
auto decl = const_cast<Decl*>(getAsDecl());
if (!decl) returnnullptr;

auto ext = dyn_cast<ExtensionDecl>(decl);
if (!ext) return dyn_cast<GenericTypeDecl>(decl);

return ext->getExtendedNominal();
}

/// If this DeclContext is a NominalType declaration or an
/// extension thereof, return the NominalTypeDecl.
NominalTypeDecl *DeclContext::getSelfNominalTypeDecl() const {
return dyn_cast_or_null<NominalTypeDecl>(getSelfTypeDecl());
}


ClassDecl *DeclContext::getSelfClassDecl() const {
return dyn_cast_or_null<ClassDecl>(getSelfTypeDecl());
}

EnumDecl *DeclContext::getSelfEnumDecl() const {
return dyn_cast_or_null<EnumDecl>(getSelfTypeDecl());
}

StructDecl *DeclContext::getSelfStructDecl() const {
return dyn_cast_or_null<StructDecl>(getSelfTypeDecl());
}

ProtocolDecl *DeclContext::getSelfProtocolDecl() const {
return dyn_cast_or_null<ProtocolDecl>(getSelfTypeDecl());
}

ProtocolDecl *DeclContext::getExtendedProtocolDecl() const {
if (auto decl = const_cast<Decl*>(getAsDecl()))
if (auto ED = dyn_cast<ExtensionDecl>(decl))
return dyn_cast_or_null<ProtocolDecl>(ED->getExtendedNominal());
returnnullptr;
}

VarDecl *DeclContext::getNonLocalVarDecl() const {
if (auto *init = dyn_cast<PatternBindingInitializer>(this)) {
if (auto binding = init->getBinding()) {
if (auto *var = binding->getAnchoringVarDecl(init->getBindingIndex())) {
return var;
 }
 }
 }
returnnullptr;
}

Type DeclContext::getDeclaredTypeInContext() const {
if (auto declaredType = getDeclaredInterfaceType())
returnmapTypeIntoContext(declaredType);
returnType();
}

Type DeclContext::getDeclaredInterfaceType() const {
if (auto *ED = dyn_cast<ExtensionDecl>(this)) {
auto *NTD = ED->getExtendedNominal();
if (NTD == nullptr)
returnErrorType::get(ED->getASTContext());
return NTD->getDeclaredInterfaceType();
 }
if (auto *NTD = dyn_cast<NominalTypeDecl>(this))
return NTD->getDeclaredInterfaceType();
returnType();
}

voidDeclContext::forEachGenericContext(
 llvm::function_ref<void (GenericParamList *)> fn) const {
auto dc = this;
do {
if (auto decl = dc->getAsDecl()) {
// Extensions do not capture outer generic parameters.
if (auto *ext = dyn_cast<ExtensionDecl>(decl)) {
for (auto *gpList = ext->getGenericParams();
 gpList != nullptr;
 gpList = gpList->getOuterParameters()) {
fn(gpList);
 }

return;
 }

if (auto genericCtx = decl->getAsGenericContext())
if (auto *gpList = genericCtx->getGenericParams())
fn(gpList);

// Protocols do not capture outer generic parameters.
if (isa<ProtocolDecl>(decl))
return;
 }
 } while ((dc = dc->getParentForLookup()));
}

unsignedDeclContext::getGenericContextDepth() const {
unsigned depth = -1;
forEachGenericContext([&](GenericParamList *) { ++depth; });
return depth;
}

GenericSignature DeclContext::getGenericSignatureOfContext() const {
auto dc = this;
do {
if (auto decl = dc->getAsDecl())
if (auto GC = decl->getAsGenericContext())
return GC->getGenericSignature();
 } while ((dc = dc->getParent()));

returnnullptr;
}

GenericEnvironment *DeclContext::getGenericEnvironmentOfContext() const {
auto dc = this;
do {
if (auto decl = dc->getAsDecl())
if (auto GC = decl->getAsGenericContext())
return GC->getGenericEnvironment();
 } while ((dc = dc->getParent()));

returnnullptr;
}

Type DeclContext::mapTypeIntoContext(Type type) const {
returnGenericEnvironment::mapTypeIntoContext(
getGenericEnvironmentOfContext(), type);
}

DeclContext *DeclContext::getLocalContext() {
if (isLocalContext())
returnthis;
if (isModuleContext())
returnnullptr;
returngetParent()->getLocalContext();
}

AbstractFunctionDecl *DeclContext::getInnermostMethodContext() {
auto dc = this;
do {
if (auto decl = dc->getAsDecl()) {
auto func = dyn_cast<AbstractFunctionDecl>(decl);
// If we found a non-func decl, we're done.
if (func == nullptr)
returnnullptr;
if (func->getDeclContext()->isTypeContext())
return func;
 }
 } while ((dc = dc->getParent()));

returnnullptr;
}

AccessorDecl *DeclContext::getInnermostPropertyAccessorContext() {
auto dc = this;
do {
if (auto decl = dc->getAsDecl()) {
auto accessor = dyn_cast<AccessorDecl>(decl);
// If we found a non-accessor decl, we're done.
if (accessor == nullptr)
returnnullptr;

auto *storage = accessor->getStorage();
if (isa<VarDecl>(storage) && storage->getDeclContext()->isTypeContext())
return accessor;
 }
 } while ((dc = dc->getParent()));

returnnullptr;
}

boolDeclContext::isTypeContext() const {
if (auto decl = getAsDecl())
return isa<NominalTypeDecl>(decl) || isa<ExtensionDecl>(decl);
returnfalse;
}

DeclContext *DeclContext::getInnermostTypeContext() {
auto dc = this;
do {
if (dc->isTypeContext())
return dc;
 } while ((dc = dc->getParent()));

returnnullptr;
}

Decl *DeclContext::getInnermostDeclarationDeclContext() {
auto DC = this;
do {
if (auto decl = DC->getAsDecl())
return isa<ModuleDecl>(decl) ? nullptr : decl;
 } while ((DC = DC->getParent()));

returnnullptr;
}

Decl *DeclContext::getTopmostDeclarationDeclContext() {
auto *dc = this;
 Decl *topmost = nullptr;
while (auto *decl = dc->getInnermostDeclarationDeclContext()) {
 topmost = decl;
 dc = decl->getDeclContext();
 }
return topmost;
}

DeclContext *DeclContext::getOutermostFunctionContext() {
 AbstractFunctionDecl *result = nullptr;
auto dc = this;
do {
if (auto afd = dyn_cast<AbstractFunctionDecl>(dc))
 result = afd;

// If we've found a non-local context, we don't have to keep walking up
// the hierarchy.
if (!dc->isLocalContext())
break;
 } while ((dc = dc->getParent()));

return result;
}

DeclContext *DeclContext::getInnermostSkippedFunctionContext() {
auto dc = this;
do {
if (auto afd = dyn_cast<AbstractFunctionDecl>(dc))
if (afd->isBodySkipped())
return afd;
 } while ((dc = dc->getParent()));

returnnullptr;
}

ClosureExpr *DeclContext::getInnermostClosureForCaptures() {
auto *DC = this;
do {
if (auto *CE = dyn_cast<ClosureExpr>(DC))
return CE;

// Autoclosures and AbstractFunctionDecls can propagate captures.
switch (DC->getContextKind()) {
case DeclContextKind::AbstractClosureExpr:
case DeclContextKind::AbstractFunctionDecl:
continue;
default:
returnnullptr;
 }
 } while ((DC = DC->getParent()));

returnnullptr;
}

DeclContext *DeclContext::getParentForLookup() const {
if (isa<ExtensionDecl>(this)) {
// If we are inside an extension, skip directly
// to the module scope context, without looking at any (invalid)
// outer types.
returngetModuleScopeContext();
 }
if (isUnsupportedNestedProtocol()) {
// Protocols in generic contexts must not look in to their parents,
// as the parents may contain types with inferred implicit
// generic parameters not present in the protocol's generic signature.
returngetModuleScopeContext();
 }
if (isa<NominalTypeDecl>(this)) {
// If we are inside a nominal type that is inside a protocol,
// skip the protocol.
if (isa<ProtocolDecl>(getParent()))
returngetModuleScopeContext();
 }
returngetParent();
}

PackageUnit *DeclContext::getPackageContext(bool lookupIfNotCurrent) const {
// Current decl context might be PackageUnit, which is not in the
// DeclContext hierarchy, so check for it first
if (isPackageContext())
returnconst_cast<PackageUnit *>(cast<PackageUnit>(this));

// If the current context is not PackageUnit, look it up via
// the parent module if needed
if (lookupIfNotCurrent) {
auto mdecl = getParentModule();
return mdecl->getPackage();
 }
returnnullptr;
}

ModuleDecl *DeclContext::getParentModule() const {
// If the current context is PackageUnit, return the module
// decl context pointing to the current context. This check
// needs to be done first as PackageUnit is not in the DeclContext
// hierarchy.
if (auto pkg = getPackageContext()) {
auto &mdecl = pkg->getSourceModule();
return &mdecl;
 }

const DeclContext *DC = this;
while (!DC->isModuleContext())
 DC = DC->getParent();
returnconst_cast<ModuleDecl *>(cast<ModuleDecl>(DC));
}

SourceFile *DeclContext::getParentSourceFile() const {
const DeclContext *DC = this;
 SourceLoc loc;
while (DC && !DC->isModuleScopeContext()) {
// If we don't have a source location yet, try to grab one from this
// context.
if (loc.isInvalid()) {
switch (DC->getContextKind()) {
case DeclContextKind::AbstractClosureExpr:
 loc = cast<AbstractClosureExpr>(DC)->getLoc();
break;

case DeclContextKind::AbstractFunctionDecl:
case DeclContextKind::EnumElementDecl:
case DeclContextKind::ExtensionDecl:
case DeclContextKind::GenericTypeDecl:
case DeclContextKind::MacroDecl:
case DeclContextKind::SubscriptDecl:
case DeclContextKind::TopLevelCodeDecl:
 loc = DC->getAsDecl()->getLoc(/*SerializedOK=*/false);
break;

case DeclContextKind::Initializer:
case DeclContextKind::FileUnit:
case DeclContextKind::Module:
case DeclContextKind::Package:
case DeclContextKind::SerializedAbstractClosure:
case DeclContextKind::SerializedTopLevelCodeDecl:
break;
 }
 }

 DC = DC->getParent();
 }

if (!DC)
returnnullptr;

auto fallbackSF = const_cast<SourceFile *>(dyn_cast<SourceFile>(DC));
if (auto module = DC->getParentModule()) {
if (auto sf = module->getSourceFileContainingLocation(loc))
return sf;
 }

return fallbackSF;
}

SourceFile *DeclContext::getOutermostParentSourceFile() const {
auto sf = getParentSourceFile();
if (!sf)
returnnullptr;

// Find the originating source file.
while (auto enclosingSF = sf->getEnclosingSourceFile())
 sf = enclosingSF;

return sf;
}

boolDeclContext::isInSwiftinterface() const {
auto sf = getParentSourceFile();
return sf && sf->Kind == SourceFileKind::Interface;
}

DeclContext *DeclContext::getModuleScopeContext() const {
// If the current context is PackageUnit, return the module
// decl context pointing to the current context. This check
// needs to be done first as PackageUnit is not in the DeclContext
// hierarchy.
if (auto pkg = getPackageContext()) {
auto &mdecl = pkg->getSourceModule();
return &mdecl;
 }

auto DC = const_cast<DeclContext *>(this);
while (true) {
if (DC->ParentAndKind.getInt() == ASTHierarchy::FileUnit)
return DC;
if (auto NextDC = DC->getParent()) {
 DC = NextDC;
 } else {
assert(DC && isa<ModuleDecl>(DC->getAsDecl()) &&
"no module decl context found!");
return DC;
 }
 }
}

voidDeclContext::getSeparatelyImportedOverlays(
 ModuleDecl *declaring, SmallVectorImpl<ModuleDecl *> &overlays) const {
if (auto SF = getOutermostParentSourceFile())
 SF->getSeparatelyImportedOverlays(declaring, overlays);
}

/// Determine whether the given context is generic at any level.
boolDeclContext::isGenericContext() const {
auto dc = this;
do {
if (auto decl = dc->getAsDecl()) {
if (auto GC = decl->getAsGenericContext()) {
if (GC->getGenericParams())
returntrue;
 }
 }
 } while ((dc = dc->getParentForLookup()));

returnfalse;
}

ResilienceExpansion DeclContext::getResilienceExpansion() const {
auto fragileKind = getFragileFunctionKind();
switch (fragileKind.kind) {
case FragileFunctionKind::Transparent:
case FragileFunctionKind::Inlinable:
case FragileFunctionKind::AlwaysEmitIntoClient:
case FragileFunctionKind::DefaultArgument:
case FragileFunctionKind::PropertyInitializer:
case FragileFunctionKind::BackDeploy:
return ResilienceExpansion::Minimal;
case FragileFunctionKind::None:
return ResilienceExpansion::Maximal;
 }

llvm_unreachable("Bad fragile function kind");
}

FragileFunctionKind DeclContext::getFragileFunctionKind() const {
auto &context = getASTContext();
returnevaluateOrDefault(
 context.evaluator,
 FragileFunctionKindRequest{const_cast<DeclContext *>(this)},
 {FragileFunctionKind::None});
}

FragileFunctionKind
swift::FragileFunctionKindRequest::evaluate(Evaluator &evaluator,
 DeclContext *context) const {
for (constauto *dc = context->getLocalContext(); dc && dc->isLocalContext();
 dc = dc->getParent()) {
// Default argument initializer contexts have their resilience expansion
// set when they're type checked.
if (isa<DefaultArgumentInitializer>(dc)) {
 dc = dc->getParent();

auto *VD = cast<ValueDecl>(dc->getAsDecl());
ASSERT(VD->hasParameterList());

if (VD->getDeclContext()->isLocalContext()) {
auto kind = VD->getDeclContext()->getFragileFunctionKind();
if (kind.kind != FragileFunctionKind::None)
return {FragileFunctionKind::DefaultArgument};
 }

auto effectiveAccess =
 VD->getFormalAccessScope(/*useDC=*/nullptr,
/*treatUsableFromInlineAsPublic=*/true);
if (effectiveAccess.isPublic()) {
return {FragileFunctionKind::DefaultArgument};
 }

return {FragileFunctionKind::None};
 }

// Stored property initializer contexts use minimal resilience expansion
// if the type is formally fixed layout.
if (auto *init = dyn_cast <PatternBindingInitializer>(dc)) {
auto bindingIndex = init->getBindingIndex();
if (auto *varDecl = init->getBinding()->getAnchoringVarDecl(bindingIndex)) {
if (varDecl->isInitExposedToClients()) {
return {FragileFunctionKind::PropertyInitializer};
 }
 }

return {FragileFunctionKind::None};
 }

if (auto *AFD = dyn_cast<AbstractFunctionDecl>(dc)) {
// If the function is a nested function, we will serialize its body if
// we serialize the parent's body.
if (AFD->getDeclContext()->isLocalContext())
continue;

auto funcAccess =
 AFD->getFormalAccessScope(/*useDC=*/nullptr,
/*treatUsableFromInlineAsPublic=*/true);

// If the function is not externally visible, we will not be serializing
// its body.
if (!funcAccess.isPublic()) {
return {FragileFunctionKind::None};
 }

// If the function is public, @_transparent implies @inlinable.
if (AFD->isTransparent()) {
return {FragileFunctionKind::Transparent};
 }

if (AFD->getAttrs().hasAttribute<InlinableAttr>()) {
return {FragileFunctionKind::Inlinable};
 }

if (AFD->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>()) {
return {FragileFunctionKind::AlwaysEmitIntoClient};
 }

if (AFD->isBackDeployed(context->getASTContext())) {
return {FragileFunctionKind::BackDeploy};
 }

// Property and subscript accessors inherit @_alwaysEmitIntoClient,
// @backDeployed, and @inlinable from their storage declarations.
if (auto accessor = dyn_cast<AccessorDecl>(AFD)) {
auto *storage = accessor->getStorage();
if (storage->getAttrs().getAttribute<InlinableAttr>()) {
return {FragileFunctionKind::Inlinable};
 }
if (storage->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>()) {
return {FragileFunctionKind::AlwaysEmitIntoClient};
 }
if (storage->isBackDeployed(context->getASTContext())) {
return {FragileFunctionKind::BackDeploy};
 }
 }
 }
 }

return {FragileFunctionKind::None};
}

/// Determine whether the innermost context is generic.
boolDeclContext::isInnermostContextGeneric() const {
if (auto Decl = getAsDecl())
if (auto GC = Decl->getAsGenericContext())
return GC->isGeneric();
returnfalse;
}

unsignedDeclContext::getSyntacticDepth() const {
// Module scope == depth 0.
if (isModuleScopeContext())
return0;

return1 + getParent()->getSyntacticDepth();
}

unsignedDeclContext::getSemanticDepth() const {
// For extensions, count the depth of the nominal type being extended.
if (isa<ExtensionDecl>(this)) {
if (auto nominal = getSelfNominalTypeDecl())
return nominal->getSemanticDepth();

return1;
 }

// Module scope == depth 0.
if (isModuleScopeContext())
return0;

return1 + getParent()->getSemanticDepth();
}

boolDeclContext::mayContainMembersAccessedByDynamicLookup() const {
// Members of non-generic classes and class extensions can be found by
/// dynamic lookup.
if (auto *CD = getSelfClassDecl())
return !CD->isGenericContext();

// Members of @objc protocols (but not protocol extensions) can be
// found by dynamic lookup.
if (auto *PD = dyn_cast<ProtocolDecl>(this))
return PD->getAttrs().hasAttribute<ObjCAttr>();

returnfalse;
}

boolDeclContext::canBeParentOfExtension() const {
return isa<SourceFile>(this);
}

boolDeclContext::walkContext(ASTWalker &Walker) {
switch (getContextKind()) {
case DeclContextKind::Package:
returnfalse;
case DeclContextKind::Module:
return cast<ModuleDecl>(this)->walk(Walker);
case DeclContextKind::FileUnit:
return cast<FileUnit>(this)->walk(Walker);
case DeclContextKind::AbstractClosureExpr:
return cast<AbstractClosureExpr>(this)->walk(Walker);
case DeclContextKind::GenericTypeDecl:
return cast<GenericTypeDecl>(this)->walk(Walker);
case DeclContextKind::ExtensionDecl:
return cast<ExtensionDecl>(this)->walk(Walker);
case DeclContextKind::TopLevelCodeDecl:
return cast<TopLevelCodeDecl>(this)->walk(Walker);
case DeclContextKind::AbstractFunctionDecl:
return cast<AbstractFunctionDecl>(this)->walk(Walker);
case DeclContextKind::SubscriptDecl:
return cast<SubscriptDecl>(this)->walk(Walker);
case DeclContextKind::EnumElementDecl:
return cast<EnumElementDecl>(this)->walk(Walker);
case DeclContextKind::MacroDecl:
return cast<MacroDecl>(this)->walk(Walker);
case DeclContextKind::SerializedAbstractClosure:
case DeclContextKind::SerializedTopLevelCodeDecl:
llvm_unreachable("walk is unimplemented for deserialized contexts");
case DeclContextKind::Initializer:
// Is there any point in trying to walk the expression?
returnfalse;
 }
llvm_unreachable("bad DeclContextKind");
}

voidDeclContext::dumpContext() const {
printContext(llvm::errs());
}

voidAccessScope::dump() const {
llvm::errs() << getAccessLevelSpelling(accessLevelForDiagnostics()) << ": ";

if (isPublic() || isPackage()) {
llvm::errs() << "(null)\n";
return;
 }

if (auto *file = dyn_cast<SourceFile>(getDeclContext())) {
llvm::errs() << "file '" << file->getFilename() << "'\n";
return;
 }

if (auto *decl = getDeclContext()->getAsDecl()) {
llvm::errs() << Decl::getKindName(decl->getKind()) << "";
if (auto *ext = dyn_cast<ExtensionDecl>(decl)) {
auto *extended = ext->getExtendedNominal();
if (extended)
llvm::errs() << extended->getName();
else
llvm::errs() << "(null)";
 } elseif (auto *named = dyn_cast<ValueDecl>(decl)) {
llvm::errs() << named->getName();
 } else {
llvm::errs() << (constvoid *)decl;
 }

 SourceLoc loc = decl->getLoc();
if (loc.isValid()) {
llvm::errs() << " at ";
 loc.print(llvm::errs(), decl->getASTContext().SourceMgr);
 }
llvm::errs() << "\n";

return;
 }

// If all else fails, dump the DeclContext tree.
getDeclContext()->printContext(llvm::errs());
}

template <typename DCType>
staticunsignedgetLineNumber(DCType *DC) {
 SourceLoc loc = DC->getLoc();
if (loc.isInvalid())
return0;

const ASTContext &ctx = static_cast<const DeclContext *>(DC)->getASTContext();
return ctx.SourceMgr.getPresumedLineAndColumnForLoc(loc).first;
}

unsignedDeclContext::printContext(raw_ostream &OS, constunsigned indent,
constbool onlyAPartialLine) const {
unsigned Depth = 0;
if (!onlyAPartialLine)
if (auto *P = getParent())
 Depth = P->printContext(OS, indent);

constchar *Kind;
switch (getContextKind()) {
case DeclContextKind::Package: Kind = "Package"; break;
case DeclContextKind::Module: Kind = "Module"; break;
case DeclContextKind::FileUnit: Kind = "FileUnit"; break;
case DeclContextKind::AbstractClosureExpr:
 Kind = "AbstractClosureExpr";
break;
case DeclContextKind::SerializedAbstractClosure:
 Kind = "SerializedAbstractClosure";
break;
case DeclContextKind::GenericTypeDecl:
switch (cast<GenericTypeDecl>(this)->getKind()) {
#defineDECL(ID, PARENT) \
case DeclKind::ID: Kind = #ID "Decl"; break;
#include"swift/AST/DeclNodes.def"
 }
break;
case DeclContextKind::ExtensionDecl: Kind = "ExtensionDecl"; break;
case DeclContextKind::TopLevelCodeDecl: Kind = "TopLevelCodeDecl"; break;
case DeclContextKind::SerializedTopLevelCodeDecl:
 Kind = "SerializedTopLevelCodeDecl"; 
break;
case DeclContextKind::Initializer: Kind = "Initializer"; break;
case DeclContextKind::AbstractFunctionDecl:
 Kind = "AbstractFunctionDecl";
break;
case DeclContextKind::SubscriptDecl: Kind = "SubscriptDecl"; break;
case DeclContextKind::EnumElementDecl: Kind = "EnumElementDecl"; break;
case DeclContextKind::MacroDecl: Kind = "MacroDecl"; break;
 }
 OS.indent(Depth * 2 + indent)
 << static_cast<constvoid *>(this) << "" << Kind;

switch (getContextKind()) {
case DeclContextKind::Package:
 OS << " name=" << cast<PackageUnit>(this)->getName();
break;
case DeclContextKind::Module:
 OS << " name=" << cast<ModuleDecl>(this)->getName();
break;
case DeclContextKind::FileUnit:
switch (cast<FileUnit>(this)->getKind()) {
case FileUnitKind::Builtin:
 OS << " Builtin";
break;
case FileUnitKind::Source:
 OS << " file=\"" << cast<SourceFile>(this)->getFilename() << "\"";
break;
case FileUnitKind::Synthesized:
 OS << " synthesized file";
break;
case FileUnitKind::SerializedAST:
case FileUnitKind::ClangModule:
case FileUnitKind::DWARFModule:
 OS << " file=\"" << cast<LoadedFile>(this)->getFilename() << "\"";
break;
 }
break;
case DeclContextKind::AbstractClosureExpr:
 OS << " line=" << getLineNumber(cast<AbstractClosureExpr>(this));
 OS << " : " << cast<AbstractClosureExpr>(this)->getType();
break;

case DeclContextKind::SerializedAbstractClosure: {
 OS << " : " << cast<SerializedAbstractClosureExpr>(this)->getType();
break;
 }

case DeclContextKind::GenericTypeDecl:
 OS << " name=" << cast<GenericTypeDecl>(this)->getName();
break;

case DeclContextKind::ExtensionDecl: {
auto *ED = cast<ExtensionDecl>(this);
 OS << " line=" << getLineNumber(ED);
 OS << " base=";
if (ED->hasBeenBound()) {
 OS << ED->getExtendedType();
 } else {
 ED->getExtendedTypeRepr()->print(OS);
 }
break;
 }

case DeclContextKind::TopLevelCodeDecl:
 OS << " line=" << getLineNumber(cast<TopLevelCodeDecl>(this));
break;

case DeclContextKind::SerializedTopLevelCodeDecl:
// Already printed the kind, nothing else to do.
break;

case DeclContextKind::AbstractFunctionDecl: {
auto *AFD = cast<AbstractFunctionDecl>(this);
 OS << " name=";
if (auto *AD = dyn_cast<AccessorDecl>(AFD)) {
 OS << accessorKindName(AD->getAccessorKind());
 } else {
 OS << AFD->getName();
 }
if (AFD->hasInterfaceType())
 OS << " : " << AFD->getInterfaceType();
else
 OS << " : (no type set)";
break;
 }
case DeclContextKind::SubscriptDecl: {
auto *SD = cast<SubscriptDecl>(this);
 OS << " name=" << SD->getBaseName();
if (SD->hasInterfaceType())
 OS << " : " << SD->getInterfaceType();
else
 OS << " : (no type set)";
break;
 }
case DeclContextKind::EnumElementDecl: {
auto *EED = cast<EnumElementDecl>(this);
 OS << " name=" << EED->getBaseName();
if (EED->hasInterfaceType())
 OS << " : " << EED->getInterfaceType();
else
 OS << " : (no type set)";
break;
 }
case DeclContextKind::MacroDecl: {
auto *MD = cast<MacroDecl>(this);
 OS << " name=" << MD->getBaseName();
if (MD->hasInterfaceType())
 OS << " : " << MD->getInterfaceType();
else
 OS << " : (no type set)";
break;
 }
case DeclContextKind::Initializer:
switch (cast<Initializer>(this)->getInitializerKind()) {
case InitializerKind::PatternBinding: {
auto init = cast<PatternBindingInitializer>(this);
 OS << " PatternBinding 0x" << (void*) init->getBinding()
 << " #" << init->getBindingIndex();
break;
 }
case InitializerKind::DefaultArgument: {
auto init = cast<DefaultArgumentInitializer>(this);
 OS << " DefaultArgument index=" << init->getIndex();
break;
 }
case InitializerKind::PropertyWrapper: {
auto init = cast<PropertyWrapperInitializer>(this);
 OS << "PropertyWrapper 0x" << (void*)init->getWrappedVar() << ", kind=";
switch (init->getKind()) {
case PropertyWrapperInitializer::Kind::WrappedValue:
 OS << "wrappedValue";
break;
case PropertyWrapperInitializer::Kind::ProjectedValue:
 OS << "projectedValue";
break;
 }
break;
 }
case InitializerKind::CustomAttribute:
 OS << " CustomAttribute";
break;
 }
break;
 }

if (auto decl = getAsDecl())
if (decl->getClangNode().getLocation().isValid()) {
auto &clangSM = getASTContext().getClangModuleLoader()
 ->getClangASTContext().getSourceManager();
 OS << " clang_loc=";
 decl->getClangNode().getLocation().print(OS, clangSM);
 }

if (!onlyAPartialLine)
 OS << "\n";
return Depth + 1;
}

const Decl *
IterableDeclContext::getDecl() const {
switch (getIterableContextKind()) {
case IterableDeclContextKind::NominalTypeDecl:
return cast<NominalTypeDecl>(this);
break;

case IterableDeclContextKind::ExtensionDecl:
return cast<ExtensionDecl>(this);
break;
 }
llvm_unreachable("Unhandled IterableDeclContextKind in switch.");
}

GenericContext *IterableDeclContext::getAsGenericContext() {
switch (getIterableContextKind()) {
case IterableDeclContextKind::NominalTypeDecl:
return cast<NominalTypeDecl>(this);
case IterableDeclContextKind::ExtensionDecl:
return cast<ExtensionDecl>(this);
 }
llvm_unreachable("Unhandled IterableDeclContextKind in switch.");
}

ASTContext &IterableDeclContext::getASTContext() const {
returngetDecl()->getASTContext();
}

SourceRange IterableDeclContext::getBraces() const {
switch (getIterableContextKind()) {
case IterableDeclContextKind::NominalTypeDecl:
return cast<NominalTypeDecl>(this)->getBraces();
break;

case IterableDeclContextKind::ExtensionDecl:
return cast<ExtensionDecl>(this)->getBraces();
break;
 }
}

DeclRange IterableDeclContext::getCurrentMembersWithoutLoading() const {
returnDeclRange(FirstDeclAndLazyMembers.getPointer(), nullptr);
}

DeclRange IterableDeclContext::getMembers() const {
returngetCurrentMembers();
}

DeclRange IterableDeclContext::getCurrentMembers() const {
loadAllMembers();

returngetCurrentMembersWithoutLoading();
}

ArrayRef<Decl *> IterableDeclContext::getParsedMembers() const {
 ASTContext &ctx = getASTContext();
auto mutableThis = const_cast<IterableDeclContext *>(this);
returnevaluateOrDefault(
 ctx.evaluator, ParseMembersRequest{mutableThis},
FingerprintAndMembers())
 .members;
}

ArrayRef<Decl *> IterableDeclContext::getABIMembers() const {
 ASTContext &ctx = getASTContext();
returnevaluateOrDefault(
 ctx.evaluator,
 ABIMembersRequest{const_cast<IterableDeclContext *>(this)},
 ArrayRef<Decl *>());
}

ArrayRef<Decl *> IterableDeclContext::getAllMembers() const {
 ASTContext &ctx = getASTContext();
returnevaluateOrDefault(
 ctx.evaluator,
 AllMembersRequest{const_cast<IterableDeclContext *>(this)},
 ArrayRef<Decl *>());
}

voidIterableDeclContext::addMemberPreservingSourceOrder(Decl *member) {
auto &SM = getASTContext().SourceMgr;

 SourceLoc start = member->getStartLoc();
 Decl *hint = nullptr;

for (auto *existingMember : getMembers()) {
if (existingMember->isImplicit())