Module.cpp

//===--- Module.cpp - Swift Language Module 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
//
//===----------------------------------------------------------------------===//
//
// This file implements the Module class and subclasses.
//
//===----------------------------------------------------------------------===//

#include"swift/AST/Module.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/ASTMangler.h"
#include"swift/AST/ASTPrinter.h"
#include"swift/AST/ASTWalker.h"
#include"swift/AST/AccessScope.h"
#include"swift/AST/AttrKind.h"
#include"swift/AST/Builtins.h"
#include"swift/AST/ClangModuleLoader.h"
#include"swift/AST/DiagnosticsSema.h"
#include"swift/AST/ExistentialLayout.h"
#include"swift/AST/FileUnit.h"
#include"swift/AST/GenericEnvironment.h"
#include"swift/AST/Import.h"
#include"swift/AST/ImportCache.h"
#include"swift/AST/LazyResolver.h"
#include"swift/AST/LinkLibrary.h"
#include"swift/AST/MacroDefinition.h"
#include"swift/AST/ModuleLoader.h"
#include"swift/AST/NameLookup.h"
#include"swift/AST/NameLookupRequests.h"
#include"swift/AST/PackConformance.h"
#include"swift/AST/ParseRequests.h"
#include"swift/AST/PrettyStackTrace.h"
#include"swift/AST/PrintOptions.h"
#include"swift/AST/ProtocolConformance.h"
#include"swift/AST/SourceFile.h"
#include"swift/AST/SourceFileExtras.h"
#include"swift/AST/SynthesizedFileUnit.h"
#include"swift/AST/Type.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/Compiler.h"
#include"swift/Basic/Defer.h"
#include"swift/Basic/SourceManager.h"
#include"swift/Basic/Statistic.h"
#include"swift/Basic/StringExtras.h"
#include"swift/Demangling/ManglingMacros.h"
#include"swift/Parse/Token.h"
#include"swift/Strings.h"
#include"clang/Basic/Module.h"
#include"llvm/ADT/DenseMap.h"
#include"llvm/ADT/DenseSet.h"
#include"llvm/ADT/STLExtras.h"
#include"llvm/ADT/SmallPtrSet.h"
#include"llvm/ADT/StringExtras.h"
#include"llvm/ADT/TinyPtrVector.h"
#include"llvm/Support/CommandLine.h"
#include"llvm/Support/MD5.h"
#include"llvm/Support/MemoryBuffer.h"
#include"llvm/Support/Path.h"
#include"llvm/Support/SaveAndRestore.h"
#include"llvm/Support/YAMLTraits.h"
#include"llvm/Support/raw_ostream.h"

usingnamespaceswift;

static_assert(IsTriviallyDestructible<FileUnit>::value,
"FileUnits are BumpPtrAllocated; the d'tor may not be called");
static_assert(IsTriviallyDestructible<LoadedFile>::value,
"LoadedFiles are BumpPtrAllocated; the d'tor may not be called");

//===----------------------------------------------------------------------===//
// Builtin Module Name lookup
//===----------------------------------------------------------------------===//

classBuiltinUnit::LookupCache {
/// The cache of identifiers we've already looked up. We use a
/// single hashtable for both types and values as a minor
/// optimization; this prevents us from having both a builtin type
/// and a builtin value with the same name, but that's okay.
 llvm::DenseMap<Identifier, ValueDecl*> Cache;

public:
voidlookupValue(Identifier Name, NLKind LookupKind, const BuiltinUnit &M,
 SmallVectorImpl<ValueDecl*> &Result);
};

BuiltinUnit::LookupCache &BuiltinUnit::getCache() const {
// FIXME: This leaks. Sticking this into ASTContext isn't enough because then
// the DenseMap will leak.
if (!Cache)
const_cast<BuiltinUnit *>(this)->Cache = std::make_unique<LookupCache>();
return *Cache;
}

voidBuiltinUnit::LookupCache::lookupValue(
 Identifier Name, NLKind LookupKind, const BuiltinUnit &M,
 SmallVectorImpl<ValueDecl*> &Result) {
// Only qualified lookup ever finds anything in the builtin module.
if (LookupKind != NLKind::QualifiedLookup) return;

 ValueDecl *&Entry = Cache[Name];
 ASTContext &Ctx = M.getParentModule()->getASTContext();
if (!Entry) {
if (Type Ty = getBuiltinType(Ctx, Name.str())) {
auto *TAD = new (Ctx) TypeAliasDecl(SourceLoc(), SourceLoc(),
 Name, SourceLoc(),
/*genericparams*/nullptr,
const_cast<BuiltinUnit*>(&M));
 TAD->setUnderlyingType(Ty);
 TAD->setAccess(AccessLevel::Public);
 Entry = TAD;
 }
 }

if (!Entry)
 Entry = getBuiltinValueDecl(Ctx, Name);

if (Entry)
 Result.push_back(Entry);
}

// Out-of-line because std::unique_ptr wants LookupCache to be complete.
BuiltinUnit::BuiltinUnit(ModuleDecl &M)
 : FileUnit(FileUnitKind::Builtin, M) {
 M.getASTContext().addDestructorCleanup(*this);
}

//===----------------------------------------------------------------------===//
// Normal Module Name Lookup
//===----------------------------------------------------------------------===//

SourceFile::~SourceFile() = default;

/// A utility for caching global lookups into SourceFiles and modules of
/// SourceFiles. This is used for lookup of top-level declarations, as well
/// as operator lookup (which looks into types) and AnyObject dynamic lookup
/// (which looks at all class members).
classswift::SourceLookupCache {
/// A lookup map for value decls. When declarations are added they are added
/// under all variants of the name they can be found under.
classValueDeclMap {
 llvm::DenseMap<DeclName, TinyPtrVector<ValueDecl *>> Members;

public:
voidadd(ValueDecl *VD) {
if (!VD->hasName()) return;
 VD->getName().addToLookupTable(Members, VD);

auto abiRole = ABIRoleInfo(VD);
if (!abiRole.providesABI() && abiRole.getCounterpart())
 abiRole.getCounterpart()->getName()
 .addToLookupTable(Members, abiRole.getCounterpart());
 }

voidclear() {
 Members.shrink_and_clear();
 }

decltype(Members)::const_iterator begin() const { return Members.begin(); }
decltype(Members)::const_iterator end() const { return Members.end(); }
decltype(Members)::const_iterator find(DeclName Name) const {
return Members.find(Name);
 }
 };

 ValueDeclMap TopLevelValues;
 ValueDeclMap ClassMembers;
bool MemberCachePopulated = false;
 llvm::SmallVector<AbstractFunctionDecl *, 0> CustomDerivatives;
 DeclName UniqueMacroNamePlaceholder;

template<typename T>
using OperatorMap = llvm::DenseMap<Identifier, TinyPtrVector<T *>>;
 OperatorMap<OperatorDecl> Operators;
 OperatorMap<PrecedenceGroupDecl> PrecedenceGroups;

template <typename Range>
voidaddToUnqualifiedLookupCache(Range decls, bool onlyOperators,
bool onlyDerivatives);
template<typename Range>
voidaddToMemberCache(Range decls);

using AuxiliaryDeclMap = llvm::DenseMap<DeclName, TinyPtrVector<MissingDecl *>>;
 AuxiliaryDeclMap TopLevelAuxiliaryDecls;

/// Top-level macros that produce arbitrary names.
 SmallVector<MissingDecl *, 4> TopLevelArbitraryMacros;

 SmallVector<llvm::PointerUnion<Decl *, MacroExpansionExpr *>, 4>
 MayHaveAuxiliaryDecls;
voidpopulateAuxiliaryDeclCache();
SourceLookupCache(ASTContext &ctx);

public:
SourceLookupCache(const SourceFile &SF);
SourceLookupCache(const ModuleDecl &Mod);

voidlookupValue(DeclName Name, NLKind LookupKind,
 OptionSet<ModuleLookupFlags> Flags,
 SmallVectorImpl<ValueDecl*> &Result);

/// Retrieves all the operator decls. The order of the results is not
/// guaranteed to be meaningful.
voidgetOperatorDecls(SmallVectorImpl<OperatorDecl *> &results);

/// Retrieves all the precedence groups. The order of the results is not
/// guaranteed to be meaningful.
voidgetPrecedenceGroups(SmallVectorImpl<PrecedenceGroupDecl *> &results);

/// Retrieves all the function decls marked as @derivative. The order of the
/// results is not guaranteed to be meaningful.
 llvm::SmallVector<AbstractFunctionDecl *, 0> getCustomDerivativeDecls();

/// Look up an operator declaration.
///
/// \param name The operator name ("+", ">>", etc.)
/// \param fixity The fixity of the operator (infix, prefix or postfix).
voidlookupOperator(Identifier name, OperatorFixity fixity,
 TinyPtrVector<OperatorDecl *> &results);

/// Look up a precedence group.
///
/// \param name The operator name ("+", ">>", etc.)
voidlookupPrecedenceGroup(Identifier name,
 TinyPtrVector<PrecedenceGroupDecl *> &results);

voidlookupVisibleDecls(ImportPath::Access AccessPath,
 VisibleDeclConsumer &Consumer,
 NLKind LookupKind);

voidpopulateMemberCache(const SourceFile &SF);
voidpopulateMemberCache(const ModuleDecl &Mod);

voidlookupClassMembers(ImportPath::Access AccessPath,
 VisibleDeclConsumer &consumer);

voidlookupClassMember(ImportPath::Access accessPath,
 DeclName name,
 SmallVectorImpl<ValueDecl*> &results);

 SmallVector<ValueDecl *, 0> AllVisibleValues;
};

SourceLookupCache &SourceFile::getCache() const {
if (!Cache) {
const_cast<SourceFile *>(this)->Cache =
 std::make_unique<SourceLookupCache>(*this);
 }
return *Cache;
}

static Expr *getAsExpr(Decl *decl) { returnnullptr; }
static Decl *getAsDecl(Decl *decl) { return decl; }

static Expr *getAsExpr(ASTNode node) { return node.dyn_cast<Expr *>(); }
static Decl *getAsDecl(ASTNode node) { return node.dyn_cast<Decl *>(); }

template <typename Range>
voidSourceLookupCache::addToUnqualifiedLookupCache(Range items,
bool onlyOperators,
bool onlyDerivatives) {
for (auto item : items) {
// In script mode, we'll see macro expansion expressions for freestanding
// macros.
if (Expr *E = getAsExpr(item)) {
if (auto MEE = dyn_cast<MacroExpansionExpr>(E)) {
if (!onlyOperators)
 MayHaveAuxiliaryDecls.push_back(MEE);
 }
continue;
 }

 Decl *D = getAsDecl(item);
if (!D)
continue;

if (auto *VD = dyn_cast<ValueDecl>(D)) {
auto getDerivative = [VD]() -> AbstractFunctionDecl * {
if (auto *AFD = dyn_cast<AbstractFunctionDecl>(VD))
if (AFD->getAttrs().hasAttribute<DerivativeAttr>())
return AFD;
returnnullptr;
 };
if (onlyOperators && VD->isOperator())
 TopLevelValues.add(VD);
if (onlyDerivatives)
if (AbstractFunctionDecl *AFD = getDerivative())
 CustomDerivatives.push_back(AFD);
if (!onlyOperators && !onlyDerivatives && VD->hasName()) {
 TopLevelValues.add(VD);
if (VD->getAttrs().hasAttribute<CustomAttr>())
 MayHaveAuxiliaryDecls.push_back(VD);
if (AbstractFunctionDecl *AFD = getDerivative())
 CustomDerivatives.push_back(AFD);
 }
 }

if (auto *NTD = dyn_cast<NominalTypeDecl>(D)) {
bool onlyOperatorsArg =
 (!NTD->hasUnparsedMembers() || NTD->maybeHasOperatorDeclarations());
bool onlyDerivativesArg =
 (!NTD->hasUnparsedMembers() || NTD->maybeHasDerivativeDeclarations());
if (onlyOperatorsArg || onlyDerivativesArg) {
addToUnqualifiedLookupCache(NTD->getMembers(), onlyOperatorsArg,
 onlyDerivativesArg);
 }
 }

if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
// Avoid populating the cache with the members of invalid extension
// declarations. These members can be used to point validation inside of
// a malformed context.
if (ED->isInvalid()) continue;

if (ED->getAttrs().hasAttribute<CustomAttr>()) {
 MayHaveAuxiliaryDecls.push_back(ED);
 }

bool onlyOperatorsArg =
 (!ED->hasUnparsedMembers() || ED->maybeHasOperatorDeclarations());
bool onlyDerivativesArg =
 (!ED->hasUnparsedMembers() || ED->maybeHasDerivativeDeclarations());
if (onlyOperatorsArg || onlyDerivativesArg) {
addToUnqualifiedLookupCache(ED->getMembers(), onlyOperatorsArg,
 onlyDerivativesArg);
 }
 }

if (auto *OD = dyn_cast<OperatorDecl>(D))
 Operators[OD->getName()].push_back(OD);

elseif (auto *PG = dyn_cast<PrecedenceGroupDecl>(D))
 PrecedenceGroups[PG->getName()].push_back(PG);

elseif (auto *MED = dyn_cast<MacroExpansionDecl>(D)) {
if (!onlyOperators)
 MayHaveAuxiliaryDecls.push_back(MED);
 } elseif (auto TLCD = dyn_cast<TopLevelCodeDecl>(D)) {
if (auto body = TLCD->getBody()){
addToUnqualifiedLookupCache(body->getElements(), onlyOperators,
 onlyDerivatives);
 }
 }
 }
}

voidSourceLookupCache::populateMemberCache(const SourceFile &SF) {
if (MemberCachePopulated)
return;

 FrontendStatsTracer tracer(SF.getASTContext().Stats,
"populate-source-file-class-member-cache");
addToMemberCache(SF.getTopLevelDecls());
 MemberCachePopulated = true;
}

voidSourceLookupCache::populateMemberCache(const ModuleDecl &Mod) {
if (MemberCachePopulated)
return;

 FrontendStatsTracer tracer(Mod.getASTContext().Stats,
"populate-module-class-member-cache");

for (const FileUnit *file : Mod.getFiles()) {
assert(isa<SourceFile>(file) ||
 isa<SynthesizedFileUnit>(file));
 SmallVector<Decl *, 8> decls;
 file->getTopLevelDecls(decls);
addToMemberCache(decls);
 }

 MemberCachePopulated = true;
}

template <typename Range>
voidSourceLookupCache::addToMemberCache(Range decls) {
for (Decl *D : decls) {
if (auto *NTD = dyn_cast<NominalTypeDecl>(D)) {
if (!NTD->hasUnparsedMembers() ||
 NTD->maybeHasNestedClassDeclarations() ||
 NTD->mayContainMembersAccessedByDynamicLookup())
addToMemberCache(NTD->getMembers());

 } elseif (auto *ED = dyn_cast<ExtensionDecl>(D)) {
if (!ED->hasUnparsedMembers() ||
 ED->maybeHasNestedClassDeclarations() ||
 ED->mayContainMembersAccessedByDynamicLookup())
addToMemberCache(ED->getMembers());

 } elseif (auto *VD = dyn_cast<ValueDecl>(D)) {
if (VD->canBeAccessedByDynamicLookup())
 ClassMembers.add(VD);
 }
 }
}

voidSourceLookupCache::populateAuxiliaryDeclCache() {
using MacroRef = llvm::PointerUnion<FreestandingMacroExpansion *, CustomAttr *>;
for (auto item : MayHaveAuxiliaryDecls) {
 TopLevelCodeDecl *topLevelCodeDecl = nullptr;

// Gather macro-introduced peer names.
 llvm::SmallDenseMap<MacroRef, llvm::SmallVector<DeclName, 2>>
 introducedNames;

/// Introduce names for a freestanding macro.
auto introduceNamesForFreestandingMacro =
 [&](FreestandingMacroExpansion *macroRef, Decl *decl, MacroRole role) {
bool introducesArbitraryNames = false;
namelookup::forEachPotentialResolvedMacro(
 decl->getDeclContext()->getModuleScopeContext(),
 macroRef->getMacroName(), role,
 [&](MacroDecl *macro, const MacroRoleAttr *roleAttr) {
// First check for arbitrary names.
if (roleAttr->hasNameKind(MacroIntroducedDeclNameKind::Arbitrary)) {
 introducesArbitraryNames = true;
 }

 macro->getIntroducedNames(role,
/*attachedTo*/nullptr,
 introducedNames[macroRef]);
 });

return introducesArbitraryNames;
 };

// Handle macro expansion expressions, which show up in when we have
// freestanding macros in "script" mode.
if (auto expr = item.dyn_cast<MacroExpansionExpr *>()) {
 topLevelCodeDecl = dyn_cast<TopLevelCodeDecl>(expr->getDeclContext());
if (topLevelCodeDecl) {
bool introducesArbitraryNames = false;
if (introduceNamesForFreestandingMacro(
 expr, topLevelCodeDecl, MacroRole::Declaration))
 introducesArbitraryNames = true;

if (introduceNamesForFreestandingMacro(
 expr, topLevelCodeDecl, MacroRole::CodeItem))
 introducesArbitraryNames = true;

// Record this macro if it introduces arbitrary names.
if (introducesArbitraryNames) {
 TopLevelArbitraryMacros.push_back(
MissingDecl::forUnexpandedMacro(expr, topLevelCodeDecl));
 }
 }
 }

auto *decl = item.dyn_cast<Decl *>();
if (decl) {
// This code deliberately avoids `forEachAttachedMacro`, because it
// will perform overload resolution and possibly invoke unqualified
// lookup for macro arguments, which will recursively populate the
// auxiliary decl cache and cause request cycles.
//
// We do not need a fully resolved macro until expansion. Instead, we
// conservatively consider peer names for all macro declarations with a
// custom attribute name. Unqualified lookup for that name will later
// invoke expansion of the macro, and will yield no results if the resolved
// macro does not produce the requested name, so the only impact is possibly
// expanding earlier than needed / unnecessarily looking in the top-level
// auxiliary decl cache.
for (auto attrConst : decl->getAttrs().getAttributes<CustomAttr>()) {
auto *attr = const_cast<CustomAttr *>(attrConst);
 UnresolvedMacroReference macroRef(attr);
bool introducesArbitraryNames = false;
namelookup::forEachPotentialResolvedMacro(
 decl->getDeclContext()->getModuleScopeContext(),
 macroRef.getMacroName(), MacroRole::Peer,
 [&](MacroDecl *macro, const MacroRoleAttr *roleAttr) {
// First check for arbitrary names.
if (roleAttr->hasNameKind(
 MacroIntroducedDeclNameKind::Arbitrary)) {
 introducesArbitraryNames = true;
 }

 macro->getIntroducedNames(MacroRole::Peer,
 dyn_cast<ValueDecl>(decl),
 introducedNames[attr]);
 });

// Record this macro where appropriate.
if (introducesArbitraryNames)
 TopLevelArbitraryMacros.push_back(
MissingDecl::forUnexpandedMacro(attr, decl));
 }
 }

if (auto *med = dyn_cast_or_null<MacroExpansionDecl>(decl)) {
bool introducesArbitraryNames =
introduceNamesForFreestandingMacro(med, decl, MacroRole::Declaration);

// Note whether this macro produces arbitrary names.
if (introducesArbitraryNames)
 TopLevelArbitraryMacros.push_back(MissingDecl::forUnexpandedMacro(med, decl));
 }

// Add macro-introduced names to the top-level auxiliary decl cache as
// unexpanded decls represented by a MissingDecl.
auto anchorDecl = decl ? decl : topLevelCodeDecl;
for (auto macroNames : introducedNames) {
auto macroRef = macroNames.getFirst();
for (auto name : macroNames.getSecond()) {
auto *placeholder = MissingDecl::forUnexpandedMacro(macroRef, anchorDecl);
 name.addToLookupTable(TopLevelAuxiliaryDecls, placeholder);
 }
 }
 }

 MayHaveAuxiliaryDecls.clear();
}

SourceLookupCache::SourceLookupCache(ASTContext &ctx)
 : UniqueMacroNamePlaceholder(MacroDecl::getUniqueNamePlaceholder(ctx)) { }

/// Populate our cache on the first name lookup.
SourceLookupCache::SourceLookupCache(const SourceFile &SF)
 : SourceLookupCache(SF.getASTContext())
{
 FrontendStatsTracer tracer(SF.getASTContext().Stats,
"source-file-populate-cache");
addToUnqualifiedLookupCache(SF.getTopLevelItems(), false, false);
addToUnqualifiedLookupCache(SF.getHoistedDecls(), false, false);
}

SourceLookupCache::SourceLookupCache(const ModuleDecl &M)
 : SourceLookupCache(M.getASTContext())
{
 FrontendStatsTracer tracer(M.getASTContext().Stats,
"module-populate-cache");
for (const FileUnit *file : M.getFiles()) {
auto *SF = cast<SourceFile>(file);
addToUnqualifiedLookupCache(SF->getTopLevelItems(), false, false);
addToUnqualifiedLookupCache(SF->getHoistedDecls(), false, false);

if (auto *SFU = file->getSynthesizedFile()) {
addToUnqualifiedLookupCache(SFU->getTopLevelDecls(), false, false);
 }
 }
}

voidSourceLookupCache::lookupValue(DeclName Name, NLKind LookupKind,
 OptionSet<ModuleLookupFlags> Flags,
 SmallVectorImpl<ValueDecl*> &Result) {
auto I = TopLevelValues.find(Name);
if (I != TopLevelValues.end()) {
 Result.reserve(I->second.size());
for (ValueDecl *Elt : I->second)
if (ABIRoleInfo(Elt).matchesOptions(Flags))
 Result.push_back(Elt);
 }

// If we aren't supposed to find names introduced by macros, we're done.
if (Flags.contains(ModuleLookupFlags::ExcludeMacroExpansions))
return;

// Add top-level auxiliary decls to the result.
//
// FIXME: We need to not consider auxiliary decls if we're doing lookup
// from inside a macro argument at module scope.
populateAuxiliaryDeclCache();
 DeclName keyName = MacroDecl::isUniqueMacroName(Name.getBaseName())
 ? UniqueMacroNamePlaceholder
 : Name;
auto auxDecls = TopLevelAuxiliaryDecls.find(keyName);

// Check macro expansions that could produce this name.
 SmallVector<MissingDecl *, 4> unexpandedDecls;
if (auxDecls != TopLevelAuxiliaryDecls.end()) {
 unexpandedDecls.insert(
 unexpandedDecls.end(), auxDecls->second.begin(), auxDecls->second.end());
 }

// Check macro expansions that can produce arbitrary names.
 unexpandedDecls.insert(
 unexpandedDecls.end(),
 TopLevelArbitraryMacros.begin(), TopLevelArbitraryMacros.end());

if (unexpandedDecls.empty())
return;

// Add matching expanded peers and freestanding declarations to the results.
 SmallPtrSet<ValueDecl *, 4> macroExpandedDecls;
for (auto *unexpandedDecl : unexpandedDecls) {
 unexpandedDecl->forEachMacroExpandedDecl(
 [&](ValueDecl *decl) {
if (decl->getName().matchesRef(Name)) {
if (macroExpandedDecls.insert(decl).second)
 Result.push_back(decl);
 }
 });
 }
}

voidSourceLookupCache::getPrecedenceGroups(
 SmallVectorImpl<PrecedenceGroupDecl *> &results) {
for (auto &groups : PrecedenceGroups)
 results.append(groups.second.begin(), groups.second.end());
}

voidSourceLookupCache::getOperatorDecls(
 SmallVectorImpl<OperatorDecl *> &results) {
for (auto &ops : Operators)
 results.append(ops.second.begin(), ops.second.end());
}

llvm::SmallVector<AbstractFunctionDecl *, 0>
SourceLookupCache::getCustomDerivativeDecls() {
return CustomDerivatives;
}

voidSourceLookupCache::lookupOperator(Identifier name, OperatorFixity fixity,
 TinyPtrVector<OperatorDecl *> &results) {
auto ops = Operators.find(name);
if (ops == Operators.end())
return;

for (auto *op : ops->second)
if (op->getFixity() == fixity)
 results.push_back(op);
}

voidSourceLookupCache::lookupPrecedenceGroup(
 Identifier name, TinyPtrVector<PrecedenceGroupDecl *> &results) {
auto groups = PrecedenceGroups.find(name);
if (groups == PrecedenceGroups.end())
return;

for (auto *group : groups->second)
 results.push_back(group);
}

voidSourceLookupCache::lookupVisibleDecls(ImportPath::Access AccessPath,
 VisibleDeclConsumer &Consumer,
 NLKind LookupKind) {
assert(AccessPath.size() <= 1 && "can only refer to top-level decls");

if (!AccessPath.empty()) {
auto I = TopLevelValues.find(AccessPath.front().Item);
if (I == TopLevelValues.end()) return;

for (auto vd : I->second)
if (ABIRoleInfo(vd).matchesOptions(OptionSet<ModuleLookupFlags>())) // FIXME: figure this out
 Consumer.foundDecl(vd, DeclVisibilityKind::VisibleAtTopLevel);
return;
 }

for (auto &tlv : TopLevelValues) {
for (ValueDecl *vd : tlv.second) {
// Declarations are added under their full and simple names. Skip the
// entry for the simple name so that we report each declaration once.
if (tlv.first.isSimpleName() && !vd->getName().isSimpleName())
continue;
if (ABIRoleInfo(vd).matchesOptions(OptionSet<ModuleLookupFlags>())) // FIXME: figure this out
 Consumer.foundDecl(vd, DeclVisibilityKind::VisibleAtTopLevel);
 }
 }

populateAuxiliaryDeclCache();
 SmallVector<MissingDecl *, 4> unexpandedDecls;
for (auto &entry : TopLevelAuxiliaryDecls) {
for (auto &decl : entry.second) {
 (void) decl;
 unexpandedDecls.append(entry.second.begin(), entry.second.end());
 }
 }

// Store macro expanded decls in a 'SmallSetVector' because different
// MissingDecls might be created by a single macro expansion. (e.g. multiple
// 'names' in macro role attributes). Since expansions are cached, it doesn't
// cause duplicated expansions, but different 'unexpandedDecl' may report the
// same 'ValueDecl'.
 llvm::SmallSetVector<ValueDecl *, 4> macroExpandedDecls;
for (MissingDecl *unexpandedDecl : unexpandedDecls) {
 unexpandedDecl->forEachMacroExpandedDecl([&](ValueDecl *vd) {
 macroExpandedDecls.insert(vd);
 });
 }
for (auto *vd : macroExpandedDecls) {
if (ABIRoleInfo(vd).matchesOptions(OptionSet<ModuleLookupFlags>())) // FIXME: figure this out
 Consumer.foundDecl(vd, DeclVisibilityKind::VisibleAtTopLevel);
 }
}

voidSourceLookupCache::lookupClassMembers(ImportPath::Access accessPath,
 VisibleDeclConsumer &consumer) {
assert(accessPath.size() <= 1 && "can only refer to top-level decls");

 std::vector<std::pair<DeclName, TinyPtrVector<ValueDecl *>>> OrderedMembers;
for (auto &member : ClassMembers) {
if (!member.first.isSimpleName())
continue;
 OrderedMembers.emplace_back(member.first, member.second);
 }
llvm::sort(OrderedMembers,
 [](auto &LHS, auto &RHS) { return LHS.first < RHS.first; });

if (!accessPath.empty()) {
for (auto &member : OrderedMembers) {
for (ValueDecl *vd : member.second) {
auto *nominal = vd->getDeclContext()->getSelfNominalTypeDecl();
if (nominal && nominal->getName() == accessPath.front().Item)
if (ABIRoleInfo(vd).matchesOptions(OptionSet<ModuleLookupFlags>())) // FIXME: figure this out
 consumer.foundDecl(vd, DeclVisibilityKind::DynamicLookup,
 DynamicLookupInfo::AnyObject);
 }
 }
return;
 }

for (auto &member : OrderedMembers) {
for (ValueDecl *vd : member.second)
if (ABIRoleInfo(vd).matchesOptions(OptionSet<ModuleLookupFlags>())) // FIXME: figure this out
 consumer.foundDecl(vd, DeclVisibilityKind::DynamicLookup,
 DynamicLookupInfo::AnyObject);
 }
}

voidSourceLookupCache::lookupClassMember(ImportPath::Access accessPath,
 DeclName name,
 SmallVectorImpl<ValueDecl*> &results) {
assert(accessPath.size() <= 1 && "can only refer to top-level decls");

auto iter = ClassMembers.find(name);
if (iter == ClassMembers.end())
return;

if (!accessPath.empty()) {
for (ValueDecl *vd : iter->second) {
auto *nominal = vd->getDeclContext()->getSelfNominalTypeDecl();
if (nominal && nominal->getName() == accessPath.front().Item)
if (ABIRoleInfo(vd).matchesOptions(OptionSet<ModuleLookupFlags>())) // FIXME: figure this out
 results.push_back(vd);
 }
return;
 }

 results.append(iter->second.begin(), iter->second.end());
}

//===----------------------------------------------------------------------===//
// Module Implementation
//===----------------------------------------------------------------------===//

ModuleDecl::ModuleDecl(Identifier name, ASTContext &ctx,
 ImplicitImportInfo importInfo,
 PopulateFilesFn populateFiles,
bool isMainModule)
 : DeclContext(DeclContextKind::Module, nullptr),
 TypeDecl(DeclKind::Module, &ctx, name, SourceLoc(), {}),
ImportInfo(importInfo) {

 ctx.addDestructorCleanup(*this);
setImplicit();
setInterfaceType(ModuleType::get(this));
setAccess(AccessLevel::Public);

 Bits.ModuleDecl.StaticLibrary = 0;
 Bits.ModuleDecl.TestingEnabled = 0;
 Bits.ModuleDecl.FailedToLoad = 0;
 Bits.ModuleDecl.RawResilienceStrategy = 0;
 Bits.ModuleDecl.HasResolvedImports = 0;
 Bits.ModuleDecl.PrivateImportsEnabled = 0;
 Bits.ModuleDecl.ImplicitDynamicEnabled = 0;
 Bits.ModuleDecl.IsSystemModule = 0;
 Bits.ModuleDecl.IsNonSwiftModule = 0;
 Bits.ModuleDecl.IsMainModule = isMainModule;
 Bits.ModuleDecl.HasIncrementalInfo = 0;
 Bits.ModuleDecl.HasHermeticSealAtLink = 0;
 Bits.ModuleDecl.IsEmbeddedSwiftModule = 0;
 Bits.ModuleDecl.IsConcurrencyChecked = 0;
 Bits.ModuleDecl.ObjCNameLookupCachePopulated = 0;
 Bits.ModuleDecl.HasCxxInteroperability = 0;
 Bits.ModuleDecl.CXXStdlibKind = 0;
 Bits.ModuleDecl.AllowNonResilientAccess = 0;
 Bits.ModuleDecl.SerializePackageEnabled = 0;
 Bits.ModuleDecl.StrictMemorySafety = 0;

// Populate the module's files.
 SmallVector<FileUnit *, 2> files;
populateFiles(this, [&](FileUnit *file) {
// If this is a LoadedFile, make sure it loaded without error.
assert(!(isa<LoadedFile>(file) &&
 cast<LoadedFile>(file)->hadLoadError()));

// Require Main and REPL files to be the first file added.
assert(files.empty() ||
 !isa<SourceFile>(file) ||
 cast<SourceFile>(file)->Kind == SourceFileKind::Library ||
 cast<SourceFile>(file)->Kind == SourceFileKind::SIL);
 files.push_back(file);
 });
 Files.emplace(std::move(files));
}

voidModuleDecl::setIsSystemModule(bool flag) {
 Bits.ModuleDecl.IsSystemModule = flag;
}

boolModuleDecl::isNonUserModule() const {
// For clang submodules, retrieve their top level module (submodules have no
// source path, so we'd always return false for them).
 ModuleDecl *mod = const_cast<ModuleDecl *>(this)->getTopLevelModule();

auto &evaluator = getASTContext().evaluator;
returnevaluateOrDefault(evaluator, IsNonUserModuleRequest{mod}, false);
}

ImplicitImportList ModuleDecl::getImplicitImports() const {
auto &evaluator = getASTContext().evaluator;
auto *mutableThis = const_cast<ModuleDecl *>(this);
returnevaluateOrDefault(evaluator, ModuleImplicitImportsRequest{mutableThis},
 {});
}

SourceFile *ModuleDecl::getSourceFileContainingLocation(SourceLoc loc) {
if (loc.isInvalid())
returnnullptr;

auto &sourceMgr = getASTContext().SourceMgr;

// Check whether this location is in a "replaced" range, in which case
// we want to use the original source file.
 SourceLoc adjustedLoc = loc;
for (constauto &pair : sourceMgr.getReplacedRanges()) {
if (sourceMgr.rangeContainsTokenLoc(pair.second, loc)) {
 adjustedLoc = pair.first.Start;
break;
 }
 }

auto bufferID = sourceMgr.findBufferContainingLoc(adjustedLoc);
auto sourceFiles = sourceMgr.getSourceFilesForBufferID(bufferID);
for (auto sourceFile: sourceFiles) {
if (sourceFile->getParentModule() == this)
return sourceFile;
 }

returnnullptr;
}

std::pair<unsigned, SourceLoc>
ModuleDecl::getOriginalLocation(SourceLoc loc) const {
assert(loc.isValid());

 SourceManager &SM = getASTContext().SourceMgr;
unsigned bufferID = SM.findBufferContainingLoc(loc);

 SourceLoc startLoc = loc;
unsigned startBufferID = bufferID;
while (const GeneratedSourceInfo *info =
 SM.getGeneratedSourceInfo(bufferID)) {
switch (info->kind) {
#defineMACRO_ROLE(Name, Description) \
case GeneratedSourceInfo::Name##MacroExpansion:
#include"swift/Basic/MacroRoles.def"
 {
// Location was within a macro expansion, return the expansion site, not
// the insertion location.
if (info->attachedMacroCustomAttr) {
 loc = info->attachedMacroCustomAttr->getLocation();
 } else {
 ASTNode expansionNode = ASTNode::getFromOpaqueValue(info->astNode);
 loc = expansionNode.getStartLoc();
 }
 bufferID = SM.findBufferContainingLoc(loc);
break;
 }
case GeneratedSourceInfo::DefaultArgument:
// No original location as it's not actually in any source file
case GeneratedSourceInfo::ReplacedFunctionBody:
// There's not really any "original" location for locations within
// replaced function bodies. The body is actually different code to the
// original file.
case GeneratedSourceInfo::PrettyPrinted:
case GeneratedSourceInfo::AttributeFromClang:
// No original location, return the original buffer/location
return {startBufferID, startLoc};
 }
 }

return {bufferID, loc};
}

ArrayRef<SourceFile *>
PrimarySourceFilesRequest::evaluate(Evaluator &evaluator,
 ModuleDecl *mod) const {
assert(mod->isMainModule() && "Only the main module can have primaries");

 SmallVector<SourceFile *, 8> primaries;
for (auto *file : mod->getFiles()) {
if (auto *SF = dyn_cast<SourceFile>(file)) {
if (SF->isPrimary())
 primaries.push_back(SF);
 }
 }
return mod->getASTContext().AllocateCopy(primaries);
}

ArrayRef<SourceFile *> ModuleDecl::getPrimarySourceFiles() const {
auto &eval = getASTContext().evaluator;
auto *mutableThis = const_cast<ModuleDecl *>(this);
returnevaluateOrDefault(eval, PrimarySourceFilesRequest{mutableThis}, {});
}

#defineFORWARD(name, args) \
for (const FileUnit *file : getFiles()) { \
 file->name args; \
if (auto *synth = file->getSynthesizedFile()) { \
 synth->name args; \
 } \
 }

SourceLookupCache &ModuleDecl::getSourceLookupCache() const {
if (!Cache) {
const_cast<ModuleDecl *>(this)->Cache =
 std::make_unique<SourceLookupCache>(*this);
 }
return *Cache;
}

ModuleDecl *ModuleDecl::getTopLevelModule(bool overlay) {
// If this is a Clang module, ask the Clang importer for the top-level module.
// We need to check isNonSwiftModule() to ensure we don't look through
// overlays.
if (isNonSwiftModule()) {
if (auto *underlying = findUnderlyingClangModule()) {
auto &ctx = getASTContext();
auto *clangLoader = ctx.getClangModuleLoader();
return clangLoader->getWrapperForModule(underlying->getTopLevelModule(),
 overlay);
 }
 }
// Swift modules don't currently support submodules.
returnthis;
}

boolModuleDecl::isSubmoduleOf(const ModuleDecl *M) const {
// Swift modules don't currently support submodules.
if (!isNonSwiftModule())
returnfalse;

auto *ClangParent = M->findUnderlyingClangModule();
if (!ClangParent)
returnfalse;

auto *ClangModule = findUnderlyingClangModule();
if (!ClangModule)
returnfalse;

return ClangModule->isSubModuleOf(ClangParent);
}

staticboolisParsedModule(const ModuleDecl *mod) {
// FIXME: If we ever get mixed modules that contain both SourceFiles and other
// kinds of file units, this will break; there all callers of this function should
// themselves assert that all file units in the module are SourceFiles when this
// function returns true.
auto files = mod->getFiles();
return (files.size() > 0 &&
 isa<SourceFile>(files[0]) &&
 cast<SourceFile>(files[0])->Kind != SourceFileKind::SIL);
}

voidModuleDecl::lookupValue(DeclName Name, NLKind LookupKind,
 OptionSet<ModuleLookupFlags> Flags,
 SmallVectorImpl<ValueDecl*> &Result) const {
auto *stats = getASTContext().Stats;
if (stats)
 ++stats->getFrontendCounters().NumModuleLookupValue;

if (isParsedModule(this)) {
getSourceLookupCache().lookupValue(Name, LookupKind, Flags, Result);
return;
 }

FORWARD(lookupValue, (Name, LookupKind, Flags, Result));
}

TypeDecl * ModuleDecl::lookupLocalType(StringRef MangledName) const {
for (auto file : getFiles()) {
auto TD = file->lookupLocalType(MangledName);
if (TD)
return TD;
 }
returnnullptr;
}

OpaqueTypeDecl *
ModuleDecl::lookupOpaqueResultType(StringRef MangledName) {
for (auto file : getFiles()) {
auto OTD = file->lookupOpaqueResultType(MangledName);