---

yaml
---
r: 348411
b: refs/heads/master
c: 7bca729
h: refs/heads/master
i:
  348409: 5878e98
  348407: 8bc523d

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a4b80f50ca73994cee1ad1e0b7e02b1c71a66489
+refs/heads/master: 7bca7291e2a58d90b6ae9f082e3e58c976550e97
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/ASTContext.h

@@ -112,6 +112,10 @@ namespace swift {
 
   enum class KnownProtocolKind : uint8_t;
 
+namespace namelookup {
+  class ImportCache;
+}
+
 namespace syntax {
   class SyntaxArena;
 }
@@ -683,7 +687,9 @@ class ASTContext final {
   /// If there is no Clang module loader, returns a null pointer.
   /// The loader is owned by the AST context.
   ClangModuleLoader *getDWARFModuleLoader() const;
-  
+
+  namelookup::ImportCache &getImportCache() const;
+
   /// Asks every module loader to verify the ASTs it has loaded.
   ///
   /// Does nothing in non-asserts (NDEBUG) builds.

trunk/include/swift/AST/ImportCache.h

@@ -0,0 +1,191 @@
+//===--- ImportCache.h - Caching the import graph ---------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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 defines interfaces for querying the module import graph in an
+// efficient manner.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_IMPORT_CACHE_H
+#define SWIFT_AST_IMPORT_CACHE_H
+
+#include "swift/AST/Module.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/FoldingSet.h"
+
+namespace swift {
+class DeclContext;
+
+namespace namelookup {
+
+/// An object describing a set of modules visible from a DeclContext.
+///
+/// This consists of two arrays of modules; the top-level imports and the
+/// transitive imports.
+///
+/// The top-level imports contains all public imports of the parent module
+/// of 'dc', together with any private imports in the source file containing
+/// 'dc', if there is one.
+///
+/// The transitive imports contains all public imports reachable from the
+/// set of top-level imports.
+///
+/// Both sets only contain unique elements. The top-level imports always
+/// include the parent module of 'dc' explicitly.
+///
+/// The set of transitive imports does not contain any elements found in
+/// the top-level imports.
+///
+/// The Swift standard library module is not included in either set unless
+/// it was explicitly imported (or re-exported).
+class ImportSet final :
+    public llvm::FoldingSetNode,
+    private llvm::TrailingObjects<ImportSet, ModuleDecl::ImportedModule> {
+  friend TrailingObjects;
+  friend ImportCache;
+
+  unsigned NumTopLevelImports;
+  unsigned NumTransitiveImports;
+
+  ImportSet(ArrayRef<ModuleDecl::ImportedModule> topLevelImports,
+            ArrayRef<ModuleDecl::ImportedModule> transitiveImports);
+
+  ImportSet(const ImportSet &) = delete;
+  void operator=(const ImportSet &) = delete;
+
+public:
+  void Profile(llvm::FoldingSetNodeID &ID) {
+    Profile(ID, getTopLevelImports());
+  }
+  static void Profile(
+      llvm::FoldingSetNodeID &ID,
+      ArrayRef<ModuleDecl::ImportedModule> topLevelImports);
+
+  size_t numTrailingObjects(OverloadToken<ModuleDecl::ImportedModule>) const {
+    return NumTopLevelImports + NumTransitiveImports;
+  }
+
+  ArrayRef<ModuleDecl::ImportedModule> getTopLevelImports() const {
+    return {getTrailingObjects<ModuleDecl::ImportedModule>(),
+            NumTopLevelImports};
+  }
+
+  ArrayRef<ModuleDecl::ImportedModule> getTransitiveImports() const {
+    return {getTrailingObjects<ModuleDecl::ImportedModule>() +
+              NumTopLevelImports,
+            NumTransitiveImports};
+  }
+
+  ArrayRef<ModuleDecl::ImportedModule> getAllImports() const {
+      return {getTrailingObjects<ModuleDecl::ImportedModule>(),
+              NumTopLevelImports + NumTransitiveImports};
+  }
+};
+
+class alignas(ModuleDecl::ImportedModule) ImportCache {
+  ImportCache(const ImportCache &) = delete;
+  void operator=(const ImportCache &) = delete;
+
+  llvm::FoldingSet<ImportSet> ImportSets;
+  llvm::DenseMap<const DeclContext *, ImportSet *> ImportSetForDC;
+  llvm::DenseMap<std::tuple<const ModuleDecl *,
+                            const DeclContext *>,
+                 ArrayRef<ModuleDecl::AccessPathTy>> VisibilityCache;
+  llvm::DenseMap<std::tuple<const ModuleDecl *,
+                            const ModuleDecl *,
+                            const DeclContext *>,
+                 ArrayRef<ModuleDecl::AccessPathTy>> ShadowCache;
+
+  ModuleDecl::AccessPathTy EmptyAccessPath;
+
+  ArrayRef<ModuleDecl::AccessPathTy> allocateArray(
+      ASTContext &ctx,
+      SmallVectorImpl<ModuleDecl::AccessPathTy> &results);
+
+  ImportSet &getImportSet(ASTContext &ctx,
+                          ArrayRef<ModuleDecl::ImportedModule> topLevelImports);
+
+public:
+  ImportCache() {}
+
+  /// Returns an object descripting all modules transtiively imported
+  /// from 'dc'.
+  ImportSet &getImportSet(const DeclContext *dc);
+
+  /// Returns all access paths into 'mod' that are visible from 'dc',
+  /// including transitively, via re-exports.
+  ArrayRef<ModuleDecl::AccessPathTy>
+  getAllVisibleAccessPaths(const ModuleDecl *mod, const DeclContext *dc);
+
+  bool isImportedBy(const ModuleDecl *mod,
+                    const DeclContext *dc) {
+    return !getAllVisibleAccessPaths(mod, dc).empty();
+  }
+
+  /// Determines if 'mod' is visible from 'dc' as a result of a scoped import.
+  /// Note that if 'mod' was not imported from 'dc' at all, this also returns
+  /// false.
+  bool isScopedImport(const ModuleDecl *mod, DeclBaseName name,
+                      const DeclContext *dc) {
+    auto accessPaths = getAllVisibleAccessPaths(mod, dc);
+    for (auto accessPath : accessPaths) {
+      if (accessPath.empty())
+        continue;
+      if (ModuleDecl::matchesAccessPath(accessPath, name))
+        return true;
+    }
+
+    return false;
+  }
+
+  /// Returns all access paths in 'mod' that are visible from 'dc' if we
+  /// subtract imports of 'other'.
+  ArrayRef<ModuleDecl::AccessPathTy>
+  getAllAccessPathsNotShadowedBy(const ModuleDecl *mod,
+                                 const ModuleDecl *other,
+                                 const DeclContext *dc);
+
+  /// Returns 'true' if a declaration named 'name' defined in 'other' shadows
+  /// defined in 'mod', because no access paths can find 'name' in 'mod' from
+  /// 'dc' if we ignore imports of 'other'.
+  bool isShadowedBy(const ModuleDecl *mod,
+                    const ModuleDecl *other,
+                    DeclBaseName name,
+                    const DeclContext *dc) {
+     auto accessPaths = getAllAccessPathsNotShadowedBy(mod, other, dc);
+     return llvm::none_of(accessPaths,
+                          [&](ModuleDecl::AccessPathTy accessPath) {
+                            return ModuleDecl::matchesAccessPath(accessPath, name);
+                          });
+  }
+
+  /// Qualified lookup into types uses a slightly different check that does not
+  /// take access paths into account.
+  bool isShadowedBy(const ModuleDecl *mod,
+                    const ModuleDecl *other,
+                    const DeclContext *dc) {
+    auto accessPaths = getAllAccessPathsNotShadowedBy(mod, other, dc);
+    return accessPaths.empty();
+  }
+
+  /// This is a hack to cope with main file parsing and REPL parsing, where
+  /// we can add ImportDecls after name binding.
+  void clear() {
+    ImportSetForDC.clear();
+  }
+};
+
+}  // namespace namelookup
+
+}  // namespace swift
+
+#endif

trunk/include/swift/AST/NameLookup.h

@@ -378,11 +378,11 @@ bool removeOverriddenDecls(SmallVectorImpl<ValueDecl*> &decls);
 /// other declarations in that set.
 ///
 /// \param decls The set of declarations being considered.
-/// \param curModule The current module.
+/// \param dc The DeclContext from which the lookup was performed.
 ///
 /// \returns true if any shadowed declarations were removed.
 bool removeShadowedDecls(SmallVectorImpl<ValueDecl*> &decls,
-                         const ModuleDecl *curModule);
+                         const DeclContext *dc);
 
 /// Finds decls visible in the given context and feeds them to the given
 /// VisibleDeclConsumer.  If the current DeclContext is nested in a function,

trunk/include/swift/Basic/Statistics.def

@@ -175,6 +175,19 @@ FRONTEND_STATISTIC(AST, NumBraceStmtASTScopeExpansions)
 /// Number of ASTScope lookups
 FRONTEND_STATISTIC(AST, NumASTScopeLookups)
 
+/// Number of lookups of the cached import graph for a module or
+/// source file.
+FRONTEND_STATISTIC(AST, ImportSetFoldHit)
+FRONTEND_STATISTIC(AST, ImportSetFoldMiss)
+
+FRONTEND_STATISTIC(AST, ImportSetCacheHit)
+FRONTEND_STATISTIC(AST, ImportSetCacheMiss)
+
+FRONTEND_STATISTIC(AST, ModuleVisibilityCacheHit)
+FRONTEND_STATISTIC(AST, ModuleVisibilityCacheMiss)
+
+FRONTEND_STATISTIC(AST, ModuleShadowCacheHit)
+FRONTEND_STATISTIC(AST, ModuleShadowCacheMiss)
 
 /// Number of full function bodies parsed.
 FRONTEND_STATISTIC(Parse, NumFunctionsParsed)

trunk/lib/AST/ASTContext.cpp

@@ -25,6 +25,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/GenericSignatureBuilder.h"
+#include "swift/AST/ImportCache.h"
 #include "swift/AST/KnownProtocols.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/ModuleLoader.h"
@@ -252,6 +253,9 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
   /// ASTContext.
   SmallVector<std::unique_ptr<swift::ModuleLoader>, 4> ModuleLoaders;
 
+  /// Singleton used to cache the import graph.
+  swift::namelookup::ImportCache TheImportCache;
+
   /// The module loader used to load Clang modules.
   ClangModuleLoader *TheClangModuleLoader = nullptr;
 
@@ -1494,6 +1498,10 @@ void ASTContext::verifyAllLoadedModules() const {
 #endif
 }
 
+swift::namelookup::ImportCache &ASTContext::getImportCache() const {
+  return getImpl().TheImportCache;
+}
+
 ClangModuleLoader *ASTContext::getClangModuleLoader() const {
   return getImpl().TheClangModuleLoader;
 }

trunk/lib/AST/CMakeLists.txt

@@ -50,6 +50,7 @@ add_swift_host_library(swiftAST STATIC
   GenericSignature.cpp
   GenericSignatureBuilder.cpp
   Identifier.cpp
+  ImportCache.cpp
   InlinableText.cpp
   LayoutConstraint.cpp
   Module.cpp