//===--- 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/AvailabilityConstraint.h"
#include "swift/AST/AvailabilityContext.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"
using namespace swift;

#define DEBUG_TYPE "Name lookup"

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

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

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

  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());
  return nullptr;
}

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;
      }
    }
  }
  return nullptr;
}

Type DeclContext::getDeclaredTypeInContext() const {
  if (auto declaredType = getDeclaredInterfaceType())
    return mapTypeIntoContext(declaredType);
  return Type();
}

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

void DeclContext::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()));
}

unsigned DeclContext::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()));

  return nullptr;
}

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()));

  return nullptr;
}

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

DeclContext *DeclContext::getLocalContext() {
  if (isLocalContext())
    return this;
  if (isModuleContext())
    return nullptr;
  return getParent()->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)
        return nullptr;
      if (func->getDeclContext()->isTypeContext())
        return func;
    }
  } while ((dc = dc->getParent()));

  return nullptr;
}

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)
        return nullptr;

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

  return nullptr;
}

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

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

  return nullptr;
}

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

  return nullptr;
}

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()));

  return nullptr;
}

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:
      return nullptr;
    }
  } while ((DC = DC->getParent()));

  return nullptr;
}

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.
    return getModuleScopeContext();
  }
  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.
    return getModuleScopeContext();
  }
  if (isa<NominalTypeDecl>(this)) {
    // If we are inside a nominal type that is inside a protocol,
    // skip the protocol.
    if (isa<ProtocolDecl>(getParent()))
      return getModuleScopeContext();
  }
  return getParent();
}

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())
    return const_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();
  }
  return nullptr;
}

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();
  return const_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)
    return nullptr;

  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)
    return nullptr;

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

  return sf;
}

bool DeclContext::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;
    }
  }
}

void DeclContext::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.
bool DeclContext::isGenericContext() const {
  auto dc = this;
  do {
    if (auto decl = dc->getAsDecl()) {
      if (auto GC = decl->getAsGenericContext()) {
        if (GC->getGenericParams())
          return true;
      }
    }
  } while ((dc = dc->getParentForLookup()));

  return false;
}

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();
  return evaluateOrDefault(
      context.evaluator,
      FragileFunctionKindRequest{const_cast<DeclContext *>(this)},
      {FragileFunctionKind::None});
}

FragileFunctionKind
swift::FragileFunctionKindRequest::evaluate(Evaluator &evaluator,
                                            DeclContext *context) const {
  for (const auto *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()) {
        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()) {
          return {FragileFunctionKind::BackDeploy};
        }
      }
    }
  }

  return {FragileFunctionKind::None};
}

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

unsigned DeclContext::getSyntacticDepth() const {
  // Module scope == depth 0.
  if (isModuleScopeContext())
    return 0;

  return 1 + getParent()->getSyntacticDepth();
}

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

    return 1;
  }

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

  return 1 + getParent()->getSemanticDepth();
}

bool DeclContext::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>();

  return false;
}

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

bool DeclContext::walkContext(ASTWalker &Walker) {
  switch (getContextKind()) {
  case DeclContextKind::Package:
    return false;
  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?
    return false;
  }
  llvm_unreachable("bad DeclContextKind");
}

void DeclContext::dumpContext() const {
  printContext(llvm::errs());
}

void AccessScope::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)";
    } else if (auto *named = dyn_cast<ValueDecl>(decl)) {
      llvm::errs() << named->getName();
    } else {
      llvm::errs() << (const void *)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>
static unsigned getLineNumber(DCType *DC) {
  SourceLoc loc = DC->getLoc();
  if (loc.isInvalid())
    return 0;

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

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

  const char *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()) {
#define DECL(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<const void *>(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 {
  return getDecl()->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 {
  return DeclRange(FirstDeclAndLazyMembers.getPointer(), nullptr);
}

DeclRange IterableDeclContext::getMembers() const {
  return getCurrentMembers();
}

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

  return getCurrentMembersWithoutLoading();
}

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

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

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

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

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

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

    // An EnumCaseDecl contains one or more EnumElementDecls,
    // but the EnumElementDecls are also added as members of
    // the parent enum. We ignore the EnumCaseDecl since its
    // source range overlaps with that of the EnumElementDecls.
    if (isa<EnumCaseDecl>(existingMember))
      continue;

    if (!SM.isBeforeInBuffer(existingMember->getEndLoc(), start))
      break;

    hint = existingMember;
  }

  addMember(member, hint, /*insertAtHead=*/hint == nullptr);
}

/// Add a member to this context.
void IterableDeclContext::addMember(Decl *member, Decl *hint, bool insertAtHead) {
  // Add the member to the list of declarations without notification.
  addMemberSilently(member, hint, insertAtHead);

  // Notify our parent declaration that we have added the member, which can
  // be used to update the lookup tables.
  switch (getIterableContextKind()) {
  case IterableDeclContextKind::NominalTypeDecl: {
    auto nominal = cast<NominalTypeDecl>(this);
    nominal->addedMember(member);
    assert(member->getDeclContext() == nominal &&
           "Added member to the wrong context");
    break;
  }

  case IterableDeclContextKind::ExtensionDecl: {
    auto ext = cast<ExtensionDecl>(this);
    ext->addedMember(member);
    assert(member->getDeclContext() == ext &&
           "Added member to the wrong context");
    break;
  }
  }
}

void IterableDeclContext::addMemberSilently(Decl *member, Decl *hint,
                                            bool insertAtHead) const {
  assert(!isa<AccessorDecl>(member) && "Accessors should not be added here");
  assert(!member->NextDecl && "Already added to a container");

#ifndef NDEBUG
  // Assert that new declarations are always added in source order.
  auto checkSourceRange = [&](Decl *prev, Decl *next) {
    // SKip these checks for imported and deserialized decls.
    if (!member->getDeclContext()->getParentSourceFile())
      return;

    auto shouldSkip = [](Decl *d) {
      // PatternBindingDecl source ranges overlap with VarDecls and
      // EnumCaseDecl source ranges overlap with EnumElementDecls.
      // Skip them all here to avoid spurious assertions.
      if (isa<PatternBindingDecl>(d) ||
          isa<EnumCaseDecl>(d))
        return true;

      // Ignore source location information of implicit declarations.
      if (d->isImplicit())
        return true;

      // Imported decls won't have complete location info.
      if (d->hasClangNode())
        return true;

      return false;
    };

    if (shouldSkip(prev) || shouldSkip(next))
      return;

    SourceLoc prevEnd = prev->getEndLoc();
    SourceLoc nextStart = next->getStartLoc();

    assert(prevEnd.isValid() &&
           "Only implicit decls can have invalid source location");
    assert(nextStart.isValid() &&
           "Only implicit decls can have invalid source location");

    if (getASTContext().SourceMgr.isAtOrBefore(prevEnd, nextStart))
      return;

    llvm::errs() << "Source ranges out of order in addMember():\n";
    prev->dump(llvm::errs());
    next->dump(llvm::errs());
    abort();
  };
#endif

  // Empty list.
  if (!FirstDeclAndLazyMembers.getPointer()) {
    assert(hint == nullptr);

    FirstDeclAndLazyMembers.setPointer(member);
    LastDeclAndKind.setPointer(member);

  // Insertion at the head.
  } else if (insertAtHead) {
    assert(hint == nullptr);

    member->NextDecl = FirstDeclAndLazyMembers.getPointer();
    FirstDeclAndLazyMembers.setPointer(member);

  // Insertion at the tail.
  } else if (hint == nullptr) {
    auto *last = LastDeclAndKind.getPointer();

#ifndef NDEBUG
    checkSourceRange(last, member);
#endif

    last->NextDecl = member;
    LastDeclAndKind.setPointer(member);

  // Insertion after 'hint' (which may be the tail).
  } else {
#ifndef NDEBUG
    checkSourceRange(hint, member);
#endif

    member->NextDecl = hint->NextDecl;
    hint->NextDecl = member;

    // Handle case where the 'hint' is the tail.
    if (LastDeclAndKind.getPointer() == hint)
      LastDeclAndKind.setPointer(member);
  }
}

void IterableDeclContext::setMemberLoader(LazyMemberLoader *loader,
                                          uint64_t contextData) {
  assert(!hasLazyMembers() && "already have lazy members");

  ASTContext &ctx = getASTContext();
  auto contextInfo = ctx.getOrCreateLazyIterableContextData(this, loader);
  FirstDeclAndLazyMembers.setInt(true);
  contextInfo->memberData = contextData;

  ++NumLazyIterableDeclContexts;
  ++NumUnloadedLazyIterableDeclContexts;
  // FIXME: (transitional) increment the redundant "always-on" counter.
  if (auto s = ctx.Stats) {
    ++s->getFrontendCounters().NumLazyIterableDeclContexts;
    ++s->getFrontendCounters().NumUnloadedLazyIterableDeclContexts;
  }
}
bool IterableDeclContext::hasUnparsedMembers() const {
  if (AddedParsedMembers)
    return false;

  if (!getAsGenericContext()->getParentSourceFile()) {
    // There will never be any parsed members to add, so set the flag to say
    // we are done so we can short-circuit next time.
    const_cast<IterableDeclContext *>(this)->AddedParsedMembers = 1;
    return false;
  }

  return true;
}

void IterableDeclContext::setHasLazyMembers(bool hasLazyMembers) const {
  FirstDeclAndLazyMembers.setInt(hasLazyMembers);
}

void IterableDeclContext::loadAllMembers() const {
  ASTContext &ctx = getASTContext();

  // For contexts within a source file, get the list of parsed members.
  if (getAsGenericContext()->getParentSourceFile()) {
    // Retrieve the parsed members. Even if we've already added the parsed
    // members to this context, this call is important for recording the
    // dependency edge.
    auto mutableThis = const_cast<IterableDeclContext *>(this);
    auto members = getParsedMembers();

    // If we haven't already done so, add these members to this context.
    if (!AddedParsedMembers) {
      mutableThis->AddedParsedMembers = 1;
      for (auto member : members) {
        mutableThis->addMember(member);
      }
    }
  }

  if (!hasLazyMembers())
    return;

  // Don't try to load all members re-entrant-ly.
  setHasLazyMembers(false);

  const Decl *container = getDecl();
  auto contextInfo = ctx.getOrCreateLazyIterableContextData(this,
    /*lazyLoader=*/nullptr);
  contextInfo->loader->loadAllMembers(const_cast<Decl *>(container),
                                      contextInfo->memberData);

  --NumUnloadedLazyIterableDeclContexts;
  // FIXME: (transitional) decrement the redundant "always-on" counter.
  if (auto s = ctx.Stats)
    --s->getFrontendCounters().NumUnloadedLazyIterableDeclContexts;
}

// Checks whether members of this decl and their respective member decls
// (recursively) were deserialized into another module correctly, and
// emits a diagnostic if deserialization failed. Requires the other module
// module and this decl's module are in the same package, and this
// decl's module has package optimization enabled.
void IterableDeclContext::checkDeserializeMemberErrorInPackage(ModuleDecl *accessingModule) {
  // For decls in the same module, we can skip deserialization error checks.
  if (getDecl()->getModuleContext() == accessingModule)
    return;
  // Only check if accessing module is in the same package as this
  // decl's module, which has package optimization enabled.
  if (!getDecl()->getModuleContext()->inSamePackage(accessingModule) ||
      !getDecl()->getModuleContext()->isResilient() ||
      !getDecl()->getModuleContext()->serializePackageEnabled())
    return;
  // Bail if already checked for an error.
  if (checkedForDeserializeMemberError())
    return;
  // If members were not deserialized, force load here.
  if (!didDeserializeMembers()) {
    // This needs to be set to force load all members if not done already.
    setHasLazyMembers(true);
    // Calling getMembers actually loads the members.
    (void)getMembers();
    assert(!hasLazyMembers());
    assert(didDeserializeMembers());
  }
  // Members could have been deserialized from other flows. Check
  // for an error here. First mark this decl 'checked' to prevent
  // infinite recursion in case of self-referencing members.
  setCheckedForDeserializeMemberError(true);

  // If members are already loaded above or by other flows,
  // calling getMembers here should be inexpensive.
  auto memberList = getMembers();

  // This decl contains a member deserialization error; emit a diag.
  if (hasDeserializeMemberError()) {
    auto containerID = Identifier();
    if (auto container = dyn_cast<NominalTypeDecl>(getDecl())) {
      containerID = container->getBaseIdentifier();
    }

    auto diagID = diag::cannot_bypass_resilience_due_to_missing_member_warn;
    if (getASTContext().LangOpts.AbortOnDeserializationFailForPackageCMO)
      diagID = diag::cannot_bypass_resilience_due_to_missing_member;

    auto foundMissing = false;
    for (auto member: memberList) {
      // Only storage vars can affect memory layout so
      // look up pattern binding decl or var decl.
      if (auto *PBD = dyn_cast<PatternBindingDecl>(member)) {
        // If this pattern binding decl is empty, we have
        // a missing member.
        if (PBD->getNumPatternEntries() == 0)
          foundMissing = true;
      }
      // Check if a member can be cast to MissingMemberDecl.
      if (auto missingMember = dyn_cast<MissingMemberDecl>(member)) {
        if (!missingMember->getName().getBaseName().isSpecial() &&
            foundMissing) {
          foundMissing = false;
          auto missingMemberID = missingMember->getName().getBaseIdentifier();
          getASTContext().Diags.diagnose(member->getLoc(),
                                         diagID,
                                         missingMemberID,
                                         missingMemberID.empty(),
                                         containerID,
                                         getDecl()->getModuleContext()->getBaseIdentifier(),
                                         accessingModule->getBaseIdentifier());
          continue;
        }
      }
      // If not handled above, emit a diag here.
      if (foundMissing) {
        getASTContext().Diags.diagnose(getDecl()->getLoc(),
                                       diagID,
                                       Identifier(),
                                       true,
                                       containerID,
                                       getDecl()->getModuleContext()->getBaseIdentifier(),
                                       accessingModule->getBaseIdentifier());
      }
    }
  } else {
    // This decl does not contain a member deserialization error.
    // Check for members of this decl's members recursively to
    // see if a member deserialization failed.
    for (auto member: memberList) {
      // Only storage vars can affect memory layout so
      // look up pattern binding decl or var decl.
      if (auto *PBD = dyn_cast<PatternBindingDecl>(member)) {
        for (auto i : range(PBD->getNumPatternEntries())) {
          auto pattern = PBD->getPattern(i);
          pattern->forEachVariable([&](const VarDecl *VD) {
            // Bail if the var is static or has no storage
            if (VD->isStatic() ||
               !VD->hasStorageOrWrapsStorage())
              return;
            // Unwrap in case this var is optional.
            auto varType = VD->getInterfaceType()->getCanonicalType();
            if (auto unwrapped = varType->getCanonicalType()->getOptionalObjectType()) {
              varType = unwrapped->getCanonicalType();
            }
            // Handle BoundGenericType, e.g. [Foo: Bar], Dictionary<Foo, Bar>.
            // Check for its arguments types, i.e. Foo, Bar.
            if (auto boundGeneric = varType->getAs<BoundGenericType>()) {
                for (auto arg : boundGeneric->getGenericArgs()) {
                  if (auto argNominal = arg->getNominalOrBoundGenericNominal()) {
                    if (auto argIDC = dyn_cast<IterableDeclContext>(argNominal)) {
                      argIDC->checkDeserializeMemberErrorInPackage(getDecl()->getModuleContext());
                      if (argIDC->hasDeserializeMemberError()) {
                         setHasDeserializeMemberError(true);
                        break;
                      }
                    }
                  }
                }
            } else if (auto tupleType = varType->getAs<TupleType>()) {
              // Handle TupleType, e.g. (Foo, Var).
              for (auto element : tupleType->getElements()) {
                if (auto elementNominal = element.getType()->getNominalOrBoundGenericNominal()) {
                    if (auto elementIDC = dyn_cast<IterableDeclContext>(elementNominal)) {
                      elementIDC->checkDeserializeMemberErrorInPackage(getDecl()->getModuleContext());
                      if (elementIDC->hasDeserializeMemberError()) {
                         setHasDeserializeMemberError(true);
                        break;
                      }
                    }
                  }
                }
            } else if (auto varNominal = varType->getNominalOrBoundGenericNominal()) {
              if (auto varIDC = dyn_cast<IterableDeclContext>(varNominal)) {
                varIDC->checkDeserializeMemberErrorInPackage(getDecl()->getModuleContext());
                if (varIDC->hasDeserializeMemberError()) {
                   setHasDeserializeMemberError(true);
                }
              }
            }
          });
        }
      }
    }
  }
}

bool IterableDeclContext::wasDeserialized() const {
  const DeclContext *DC = getAsGenericContext();
  if (auto F = dyn_cast<FileUnit>(DC->getModuleScopeContext())) {
    return F->getKind() == FileUnitKind::SerializedAST;
  }
  return false;
}

bool IterableDeclContext::classof(const Decl *D) {
  switch (D->getKind()) {
  default: return false;
#define DECL(ID, PARENT) // See previous line
#define ITERABLE_DECL(ID, PARENT) \
  case DeclKind::ID: return true;
#include "swift/AST/DeclNodes.def"
  }
}

IterableDeclContext *
IterableDeclContext::castDeclToIterableDeclContext(const Decl *D) {
  switch (D->getKind()) {
  default: llvm_unreachable("Decl is not a IterableDeclContext.");
#define DECL(ID, PARENT) // See previous line
#define ITERABLE_DECL(ID, PARENT) \
  case DeclKind::ID: \
    return const_cast<IterableDeclContext *>( \
        static_cast<const IterableDeclContext*>(cast<ID##Decl>(D)));
#include "swift/AST/DeclNodes.def"
  }
}

std::optional<Fingerprint> IterableDeclContext::getBodyFingerprint() const {
  auto fileUnit = dyn_cast<FileUnit>(getAsGenericContext()->getModuleScopeContext());
  if (!fileUnit)
    return std::nullopt;

  if (isa<SourceFile>(fileUnit)) {
    auto mutableThis = const_cast<IterableDeclContext *>(this);
    return evaluateOrDefault(getASTContext().evaluator,
                             ParseMembersRequest{mutableThis},
                             FingerprintAndMembers())
        .fingerprint;
  }

  if (getDecl()->isImplicit())
    return std::nullopt;

  return fileUnit->loadFingerprint(this);
}

/// Return the DeclContext to compare when checking private access in
/// Swift 4 mode. The context returned is the type declaration if the context
/// and the type declaration are in the same file, otherwise it is the types
/// last extension in the source file. If the context does not refer to a
/// declaration or extension, the supplied context is returned.
static const DeclContext *
getPrivateDeclContext(const DeclContext *DC, const SourceFile *useSF) {
  auto NTD = DC->getSelfNominalTypeDecl();
  if (!NTD)
    return DC;

  // use the type declaration as the private scope if it is in the same
  // file as useSF. This occurs for both extensions and declarations.
  if (NTD->getOutermostParentSourceFile() == useSF)
    return NTD;

  // Otherwise use the last extension declaration in the same file.
  const DeclContext *lastExtension = nullptr;
  for (ExtensionDecl *ED : NTD->getExtensions())
    if (ED->getOutermostParentSourceFile() == useSF)
      lastExtension = ED;

  // If there's no last extension, return the supplied context.
  return lastExtension ? lastExtension : DC;
}

AccessScope::AccessScope(const DeclContext *DC, bool isPrivate)
    : Value(DC, isPrivate) {
  if (isPrivate) {
    DC = getPrivateDeclContext(DC, DC->getOutermostParentSourceFile());
    Value.setPointer(DC);
  }
  if (!DC || isa<ModuleDecl>(DC) || isa<PackageUnit>(DC))
    assert(!isPrivate && "public, package, or internal scope can't be private");
}

bool AccessScope::isFileScope() const {
  auto DC = getDeclContext();
  return DC && isa<FileUnit>(DC);
}

bool AccessScope::isInternal() const {
  auto DC = getDeclContext();
  return DC && isa<ModuleDecl>(DC);
}

bool AccessScope::isPackage() const {
  auto DC = getDeclContext();
  return DC && isa<PackageUnit>(DC);
}

AccessLevel AccessScope::accessLevelForDiagnostics() const {
  if (isPublic())
    return AccessLevel::Public;
  if (isPackage())
    return AccessLevel::Package;
  if (isa<ModuleDecl>(getDeclContext()))
    return AccessLevel::Internal;
  if (getDeclContext()->isModuleScopeContext()) {
    return isPrivate() ? AccessLevel::Private : AccessLevel::FilePrivate;
  }

  return AccessLevel::Private;
}

bool AccessScope::allowsPrivateAccess(const DeclContext *useDC, const DeclContext *sourceDC) {
  // Check the lexical scope.
  if (useDC->isChildContextOf(sourceDC))
    return true;

  // If the decl site has package acl, but the use site
  // has internal or less acl, check if it belongs to
  // the same package as the decl site's to allow access.
  if (auto srcPkg = sourceDC->getPackageContext()) {
    if (auto usePkg = useDC->getPackageContext(/*lookupIfNotCurrent*/ true)) {
      return usePkg->isSamePackageAs(srcPkg);
    }
  }

  // Do not allow access if the sourceDC does not represent a type.
  auto sourceNTD = sourceDC->getSelfNominalTypeDecl();
  if (!sourceNTD)
    return false;

  // Do not allow access if the sourceDC is in a different file
  auto *useSF = useDC->getOutermostParentSourceFile();
  if (useSF != sourceDC->getOutermostParentSourceFile()) {
    // sourceDC might be a C++ record with a SWIFT_PRIVATE_FILEID attribute,
    // which asks us to treat it as if it were defined in the file
    // with the specified FileID.
    auto clangDecl = sourceNTD->getDecl()->getClangDecl();

    if (isa_and_nonnull<clang::EnumDecl>(clangDecl)) {
      // Consider:  class C { private: enum class E { M }; };
      // If sourceDC is a C++ enum (e.g, E), then we are looking at one of its
      // members (e.g., E.M). If this is the case, then we should consider
      // the SWIFT_PRIVATE_FILEID of its enclosing class decl (e.g., C), if any.
      // Doing so allows the nested private enum's members to inherit the access
      // of the nested enum type itself.
      clangDecl = dyn_cast<clang::CXXRecordDecl>(clangDecl->getDeclContext());
      sourceDC = sourceNTD->getDeclContext();
    }

    if (!isa_and_nonnull<clang::CXXRecordDecl>(clangDecl))
      return false;

    auto recordDecl = cast<clang::CXXRecordDecl>(clangDecl);

    // Diagnostics should enforce that there is at most SWIFT_PRIVATE_FILEID,
    // but this handles the case where there is more than anyway (whether that
    // is a feature or a bug). Allow access check to proceed if useSF is blessed
    // by any of the SWIFT_PRIVATE_FILEID annotations (i.e., disallow private
    // access if none of them bless useSF).
    if (!llvm::any_of(
            importer::getPrivateFileIDAttrs(recordDecl), [&](auto &blessed) {
              auto blessedFileID = SourceFile::FileIDStr::parse(blessed.first);
              return blessedFileID && blessedFileID->matches(useSF);
            })) {
      return false;
    }
  }

  // Compare the private scopes and iterate over the parent types.
  sourceDC = getPrivateDeclContext(sourceDC, useSF);
  while (!useDC->isModuleContext()) {
    useDC = getPrivateDeclContext(useDC, useSF);
    if (useDC == sourceDC)
      return true;

    // Get the parent type. If the context represents a type, look at the types
    // declaring context instead of the contexts parent. This will crawl up
    // the type hierarchy in nested extensions correctly.
    if (auto NTD = useDC->getSelfNominalTypeDecl())
      useDC = NTD->getDeclContext();
    else
      useDC = useDC->getParent();
  }

  return false;
}

DeclContext *Decl::getDeclContextForModule() const {
  if (auto module = dyn_cast<ModuleDecl>(this))
    return const_cast<ModuleDecl *>(module);

  return nullptr;
}

DeclContextKind DeclContext::getContextKind() const {
  switch (ParentAndKind.getInt()) {
  case ASTHierarchy::Expr:
    return DeclContextKind::AbstractClosureExpr;
  case ASTHierarchy::Initializer:
    return DeclContextKind::Initializer;
  case ASTHierarchy::SerializedAbstractClosure:
    return DeclContextKind::SerializedAbstractClosure;
  case ASTHierarchy::SerializedTopLevelCodeDecl:
    return DeclContextKind::SerializedTopLevelCodeDecl;
  case ASTHierarchy::FileUnit:
    return DeclContextKind::FileUnit;
  case ASTHierarchy::Package:
    return DeclContextKind::Package;
  case ASTHierarchy::Decl: {
    auto decl = reinterpret_cast<const Decl*>(this + 1);
    if (isa<AbstractFunctionDecl>(decl))
      return DeclContextKind::AbstractFunctionDecl;
    if (isa<GenericTypeDecl>(decl))
      return DeclContextKind::GenericTypeDecl;
    switch (decl->getKind()) {
    case DeclKind::Module:
      return DeclContextKind::Module;
    case DeclKind::TopLevelCode:
      return DeclContextKind::TopLevelCodeDecl;
    case DeclKind::Subscript:
      return DeclContextKind::SubscriptDecl;
    case DeclKind::EnumElement:
      return DeclContextKind::EnumElementDecl;
    case DeclKind::Extension:
      return DeclContextKind::ExtensionDecl;
    case DeclKind::Macro:
      return DeclContextKind::MacroDecl;
    default:
      llvm_unreachable("Unhandled Decl kind");
    }
  }
  }
  llvm_unreachable("Unhandled DeclContext ASTHierarchy");
}

bool DeclContext::hasValueSemantics() const {
  if (getExtendedProtocolDecl())
    return !isClassConstrainedProtocolExtension();
  return !getDeclaredInterfaceType()->hasReferenceSemantics();
}

bool DeclContext::isClassConstrainedProtocolExtension() const {
  if (getExtendedProtocolDecl()) {
    auto ED = cast<ExtensionDecl>(this);
    if (auto sig = ED->getGenericSignature()) {
      return sig->requiresClass(ED->getSelfInterfaceType());
    }
  }
  return false;
}

bool DeclContext::isAsyncContext() const {
  switch (getContextKind()) {
  case DeclContextKind::Initializer:
  case DeclContextKind::EnumElementDecl:
  case DeclContextKind::ExtensionDecl:
  case DeclContextKind::SerializedAbstractClosure:
  case DeclContextKind::SerializedTopLevelCodeDecl:
  case DeclContextKind::Package:
  case DeclContextKind::Module:
  case DeclContextKind::GenericTypeDecl:
  case DeclContextKind::MacroDecl:
    return false;
  case DeclContextKind::FileUnit:
    if (const SourceFile *sf = dyn_cast<SourceFile>(this))
      return sf->isAsyncTopLevelSourceFile();
    return false;
  case DeclContextKind::TopLevelCodeDecl:
    return getParent()->isAsyncContext();
  case DeclContextKind::AbstractClosureExpr:
    return cast<AbstractClosureExpr>(this)->isBodyAsync();
  case DeclContextKind::AbstractFunctionDecl:
    return cast<AbstractFunctionDecl>(this)->hasAsync();
  case DeclContextKind::SubscriptDecl:
    return cast<SubscriptDecl>(this)->isAsync();
  }
  llvm_unreachable("Unhandled DeclContextKind switch");
}

SourceLoc swift::extractNearestSourceLoc(const DeclContext *dc) {
  assert(dc && "Expected non-null DeclContext!");

  switch (dc->getContextKind()) {
  case DeclContextKind::Package:
  case DeclContextKind::Module:
    return SourceLoc();
  case DeclContextKind::AbstractFunctionDecl:
  case DeclContextKind::EnumElementDecl:
  case DeclContextKind::ExtensionDecl:
  case DeclContextKind::GenericTypeDecl:
  case DeclContextKind::SubscriptDecl:
  case DeclContextKind::TopLevelCodeDecl:
  case DeclContextKind::MacroDecl:
    return extractNearestSourceLoc(dc->getAsDecl());

  case DeclContextKind::AbstractClosureExpr: {
    SourceLoc loc = cast<AbstractClosureExpr>(dc)->getLoc();
    if (loc.isValid())
      return loc;
    return extractNearestSourceLoc(dc->getParent());
  }

  case DeclContextKind::FileUnit:
    return SourceLoc();

  case DeclContextKind::Initializer:
  case DeclContextKind::SerializedAbstractClosure:
  case DeclContextKind::SerializedTopLevelCodeDecl:
    return extractNearestSourceLoc(dc->getParent());
  }
  llvm_unreachable("Unhandled DeclContextKindIn switch");
}

#define DECL(Id, Parent) \
  static_assert(!std::is_base_of<DeclContext, Id##Decl>::value, \
                "Non-context Decl node has context?");
#define CONTEXT_DECL(Id, Parent) \
  static_assert(alignof(DeclContext) == alignof(Id##Decl), "Alignment error"); \
  static_assert(std::is_base_of<DeclContext, Id##Decl>::value, \
                "CONTEXT_DECL nodes must inherit from DeclContext");
#define CONTEXT_VALUE_DECL(Id, Parent) \
  static_assert(alignof(DeclContext) == alignof(Id##Decl), "Alignment error"); \
  static_assert(std::is_base_of<DeclContext, Id##Decl>::value, \
                "CONTEXT_VALUE_DECL nodes must inherit from DeclContext");
#include "swift/AST/DeclNodes.def"

#define EXPR(Id, Parent) \
  static_assert(!std::is_base_of<DeclContext, Id##Expr>::value, \
                "Non-context Expr node has context?");
#define CONTEXT_EXPR(Id, Parent) \
  static_assert(alignof(DeclContext) == alignof(Id##Expr), "Alignment error"); \
  static_assert(std::is_base_of<DeclContext, Id##Expr>::value, \
                "CONTEXT_EXPR nodes must inherit from DeclContext");
#include "swift/AST/ExprNodes.def"

#ifndef NDEBUG
// XXX -- static_cast is not static enough for use with static_assert().
// DO verify this by temporarily breaking a Decl or Expr.
// DO NOT assume that the compiler will emit this code blindly.
SWIFT_CONSTRUCTOR
static void verify_DeclContext_is_start_of_node() {
  auto decl = reinterpret_cast<Decl*>(0x1000 + sizeof(DeclContext));
#define DECL(Id, Parent)
#define CONTEXT_DECL(Id, Parent) \
  assert(reinterpret_cast<DeclContext*>(0x1000) == \
         static_cast<Id##Decl*>(decl));
#define CONTEXT_VALUE_DECL(Id, Parent) \
  assert(reinterpret_cast<DeclContext*>(0x1000) == \
         static_cast<Id##Decl*>(decl));
#include "swift/AST/DeclNodes.def"

  auto expr = reinterpret_cast<Expr*>(0x1000 + sizeof(DeclContext));
#define EXPR(Id, Parent)
#define CONTEXT_EXPR(Id, Parent) \
  assert(reinterpret_cast<DeclContext*>(0x1000) == \
         static_cast<Id##Expr*>(expr));
#include "swift/AST/ExprNodes.def"
}
#endif

void swift::simple_display(llvm::raw_ostream &out,
                           const IterableDeclContext *idc) {
  simple_display(out, idc->getDecl());
}

SourceLoc swift::extractNearestSourceLoc(const IterableDeclContext *idc) {
  return extractNearestSourceLoc(idc->getDecl());
}

static bool isSpecializeExtensionContext(const DeclContext *dc) {
  if (dc->isModuleScopeContext())
    return false;
  if (auto *extCtx = dyn_cast<ExtensionDecl>(dc)) {
    // and has specialized attr ...
    return extCtx->getAttrs().hasAttribute<SpecializeExtensionAttr>();
  }
  auto *parentDecl = dc->getParent();
  return isSpecializeExtensionContext(parentDecl);
}

bool DeclContext::isInSpecializeExtensionContext() const {
   return isSpecializeExtensionContext(this);
}

bool DeclContext::isUnsupportedNestedProtocol() const {
  return isa<ProtocolDecl>(this) && getParent()->isGenericContext();
}

bool DeclContext::isAlwaysAvailableConformanceContext() const {
  auto *ext = dyn_cast<ExtensionDecl>(this);
  if (ext == nullptr)
    return true;

  // Check whether the extension is always available relative to the deployment
  // target.
  auto &ctx = getASTContext();
  auto deploymentTarget = AvailabilityContext::forDeploymentTarget(ctx);
  auto constraints = getAvailabilityConstraintsForDecl(ext, deploymentTarget);
  return !constraints.getPrimaryConstraint();
}