---

yaml
---
r: 343213
b: refs/heads/master-rebranch
c: ec3975a
h: refs/heads/master
i:
  343211: 5284708

Author: gottesmm

[refs]

@@ -1455,7 +1455,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: 108a02f02bddddff8e910e99cf72d90fd0c69e39
+refs/heads/master-rebranch: ec3975a977f04810d8208bae491826cfb76f909e
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec

branches/master-rebranch/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.

branches/master-rebranch/include/swift/AST/Builtins.def

@@ -418,6 +418,14 @@ BUILTIN_MISC_OPERATION(Strideof, "strideof", "n", Special)
 /// IsPOD has type T.Type -> Bool
 BUILTIN_MISC_OPERATION(IsPOD, "ispod", "n", Special)
 
+/// IsConcrete has type (T.Type) -> Bool
+///
+/// If the meta type T is concrete, we can always transform this to `true` at
+/// any time in SIL. If it's generic, then we lower it to `false` right before
+/// IRGen in IRGenPrepare. This allows for the optimizer to specialize this at
+/// -O and eliminate conditional code.
+BUILTIN_MISC_OPERATION(IsConcrete, "isConcrete", "n", Special)
+
 /// IsBitwiseTakable has type T.Type -> Bool
 BUILTIN_MISC_OPERATION(IsBitwiseTakable, "isbitwisetakable", "n", Special)
 

branches/master-rebranch/include/swift/AST/DiagnosticsModuleDiffer.def

@@ -96,6 +96,8 @@ ERROR(decl_new_witness_table_entry,none,"%0 now requires %select{|no}1 new witne
 
 ERROR(new_decl_without_intro,none,"%0 is a new API without @available attribute", (StringRef))
 
+ERROR(objc_name_change,none,"%0 has ObjC name change from %1 to %2", (StringRef, StringRef, StringRef))
+
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)
 #  undef DIAG

branches/master-rebranch/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

branches/master-rebranch/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,

branches/master-rebranch/include/swift/Basic/LangOptions.h

@@ -259,7 +259,7 @@ namespace swift {
     bool WarnIfASTScopeLookup = false;
 
     /// Build the ASTScope tree lazily
-    bool LazyASTScopes = false;
+    bool LazyASTScopes = true;
 
     /// Whether to use the import as member inference system
     ///

branches/master-rebranch/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)

branches/master-rebranch/include/swift/Frontend/Frontend.h

@@ -297,7 +297,6 @@ class CompilerInvocation {
   /// Called from lldb, see rdar://53971116
   void disableASTScopeLookup() {
     LangOpts.EnableASTScopeLookup = false;
-    LangOpts.LazyASTScopes = false;
   }
 
   CodeCompletionCallbacksFactory *getCodeCompletionFactory() const {

branches/master-rebranch/include/swift/IDE/DigesterEnums.def

@@ -151,6 +151,7 @@ KEY_STRING(IntroiOS, intro_iOS)
 KEY_STRING(IntrotvOS, intro_tvOS)
 KEY_STRING(IntrowatchOS, intro_watchOS)
 KEY_STRING(Introswift, intro_swift)
+KEY_STRING(ObjCName, objc_name)
 
 KEY_STRING_ARR(SuperclassNames, superclassNames)
 KEY_STRING_ARR(ToolArgs, tool_arguments)

branches/master-rebranch/include/swift/Index/IndexSymbol.h

@@ -66,6 +66,7 @@ struct IndexSymbol : IndexRelation {
   SmallVector<IndexRelation, 3> Relations;
   unsigned line = 0;
   unsigned column = 0;
+  Optional<unsigned> offset;
 
   IndexSymbol() = default;
 

branches/master-rebranch/include/swift/SIL/MemoryLifetime.h

@@ -183,6 +183,11 @@ class MemoryLocations {
     return &locations[index];
   }
 
+  /// Registers an address projection instruction for a location.
+  void registerProjection(SingleValueInstruction *projection, unsigned locIdx) {
+    addr2LocIdx[projection] = locIdx;
+  }
+
   /// Sets the location bits os \p addr in \p bits, if \p addr is associated
   /// with a location.
   void setBits(Bits &bits, SILValue addr) {
@@ -341,13 +346,29 @@ class MemoryDataflow {
   /// Calculates the BlockState::exitReachable flags.
   void exitReachableAnalysis();
 
+  using JoinOperation = std::function<void (Bits &dest, const Bits &src)>;
+
   /// Derives the block exit sets from the entry sets by applying the gen and
   /// kill sets.
-  void solveDataflowForward();
+  /// At control flow joins, the \p join operation is applied.
+  void solveForward(JoinOperation join);
+
+  /// Calls solveForward() with a bit-intersection as join operation.
+  void solveForwardWithIntersect();
+
+  /// Calls solveForward() with a bit-union as join operation.
+  void solveForwardWithUnion();
 
   /// Derives the block entry sets from the exit sets by applying the gen and
   /// kill sets.
-  void solveDataflowBackward();
+  /// At control flow joins, the \p join operation is applied.
+  void solveBackward(JoinOperation join);
+
+  /// Calls solveBackward() with a bit-intersection as join operation.
+  void solveBackwardWithIntersect();
+
+  /// Calls solveBackward() with a bit-union as join operation.
+  void solveBackwardWithUnion();
 
   /// Debug dump the MemoryLifetime internals.
   void dump() const;

branches/master-rebranch/include/swift/SIL/SILInstruction.h

@@ -3240,6 +3240,9 @@ class LoadInst
     return LoadOwnershipQualifier(
       SILInstruction::Bits.LoadInst.OwnershipQualifier);
   }
+  void setOwnershipQualifier(LoadOwnershipQualifier qualifier) {
+    SILInstruction::Bits.LoadInst.OwnershipQualifier = unsigned(qualifier);
+  }
 };
 
 // *NOTE* When serializing, we can only represent up to 4 values here. If more
@@ -3279,6 +3282,9 @@ class StoreInst
     return StoreOwnershipQualifier(
       SILInstruction::Bits.StoreInst.OwnershipQualifier);
   }
+  void setOwnershipQualifier(StoreOwnershipQualifier qualifier) {
+    SILInstruction::Bits.StoreInst.OwnershipQualifier = unsigned(qualifier);
+  }
 };
 
 class EndBorrowInst;

branches/master-rebranch/include/swift/SILOptimizer/PassManager/Passes.def

@@ -132,6 +132,8 @@ PASS(DeadObjectElimination, "deadobject-elim",
      "Dead Object Elimination for Classes with Trivial Destruction")
 PASS(DefiniteInitialization, "definite-init",
      "Definite Initialization for Diagnostics")
+PASS(DestroyHoisting, "destroy-hoisting",
+     "Hoisting of value destroys")
 PASS(Devirtualizer, "devirtualizer",
      "Indirect Call Devirtualization")
 PASS(DiagnoseInfiniteRecursion, "diagnose-infinite-recursion",