---

yaml
---
r: 327659
b: refs/heads/tensorflow
c: 52479ca
h: refs/heads/master
i:
  327657: 8eb0e07
  327655: a9e36e7

Author: slavapestov

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: bd3b827fd613fc4d59509d5231366c269e2152fe
+refs/heads/tensorflow: 52479cadd5fb4dc73983998186296e7b10aa47d9
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/include/swift/AST/ImportCache.h

@@ -140,52 +140,13 @@ class alignas(ModuleDecl::ImportedModule) ImportCache {
     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() {

branches/tensorflow/lib/AST/NameLookup.cpp

@@ -193,6 +193,27 @@ static void recordShadowedDeclsAfterSignatureMatch(
     auto firstDecl = decls[firstIdx];
     auto firstModule = firstDecl->getModuleContext();
     auto name = firstDecl->getBaseName();
+
+    auto isShadowed = [&](ArrayRef<ModuleDecl::AccessPathTy> paths) {
+      for (auto path : paths) {
+        if (ModuleDecl::matchesAccessPath(path, name))
+          return false;
+      }
+
+      return true;
+    };
+
+    auto isScopedImport = [&](ArrayRef<ModuleDecl::AccessPathTy> paths) {
+      for (auto path : paths) {
+        if (path.empty())
+          continue;
+        if (ModuleDecl::matchesAccessPath(path, name))
+          return true;
+      }
+
+      return false;
+    };
+
     for (unsigned secondIdx : range(firstIdx + 1, decls.size())) {
       // Determine whether one module takes precedence over another.
       auto secondDecl = decls[secondIdx];
@@ -206,22 +227,28 @@ static void recordShadowedDeclsAfterSignatureMatch(
       if (firstModule != secondModule &&
           firstDecl->getDeclContext()->isModuleScopeContext() &&
           secondDecl->getDeclContext()->isModuleScopeContext()) {
-        // First, scoped imports shadow unscoped imports.
-        bool firstScoped = imports.isScopedImport(firstModule, name, dc);
-        bool secondScoped = imports.isScopedImport(secondModule, name, dc);
-        if (!firstScoped && secondScoped) {
+        auto firstPaths = imports.getAllAccessPathsNotShadowedBy(
+          firstModule, secondModule, dc);
+        auto secondPaths = imports.getAllAccessPathsNotShadowedBy(
+          secondModule, firstModule, dc);
+
+        // Check if one module shadows the other.
+        if (isShadowed(firstPaths)) {
           shadowed.insert(firstDecl);
           break;
-        } else if (firstScoped && !secondScoped) {
+        } else if (isShadowed(secondPaths)) {
           shadowed.insert(secondDecl);
           continue;
         }
 
-        // Now check if one module shadows the other.
-        if (imports.isShadowedBy(firstModule, secondModule, name, dc)) {
+        // We might be in a situation where neither module shadows the
+        // other, but one declaration is visible via a scoped import.
+        bool firstScoped = isScopedImport(firstPaths);
+        bool secondScoped = isScopedImport(secondPaths);
+        if (!firstScoped && secondScoped) {
           shadowed.insert(firstDecl);
           break;
-        } else if (imports.isShadowedBy(secondModule, firstModule, name, dc)) {
+        } else if (firstScoped && !secondScoped) {
           shadowed.insert(secondDecl);
           continue;
         }
@@ -278,10 +305,16 @@ static void recordShadowedDeclsAfterSignatureMatch(
       if (firstModule != secondModule &&
           !firstDecl->getDeclContext()->isModuleScopeContext() &&
           !secondDecl->getDeclContext()->isModuleScopeContext()) {
-        if (imports.isShadowedBy(firstModule, secondModule, dc)) {
+        auto firstPaths = imports.getAllAccessPathsNotShadowedBy(
+          firstModule, secondModule, dc);
+        auto secondPaths = imports.getAllAccessPathsNotShadowedBy(
+          secondModule, firstModule, dc);
+
+        // Check if one module shadows the other.
+        if (isShadowed(firstPaths)) {
           shadowed.insert(firstDecl);
           break;
-        } else if (imports.isShadowedBy(secondModule, firstModule, dc)) {
+        } else if (isShadowed(secondPaths)) {
           shadowed.insert(secondDecl);
           continue;
         }

branches/tensorflow/lib/Sema/CSRanking.cpp

@@ -822,27 +822,17 @@ SolutionCompareResult ConstraintSystem::compareSolutions(
         continue;
       }
 
-      if (choice1.getKind() == OverloadChoiceKind::KeyPathDynamicMemberLookup) {
-        if (choice2.getKind() == OverloadChoiceKind::DynamicMemberLookup)
-          // Dynamic member lookup through a keypath is better than one using
-          // string because it carries more type information.
-          score1 += weight;
-        else
-          // Otherwise let's prefer non-dynamic declaration.
-          score2 += weight;
-
+      // Dynamic member lookup through a keypath is better than one using string
+      // because it carries more type information.
+      if (choice1.getKind() == OverloadChoiceKind::KeyPathDynamicMemberLookup &&
+          choice2.getKind() == OverloadChoiceKind::DynamicMemberLookup) {
+        score1 += weight;
         continue;
       }
 
-      if (choice2.getKind() == OverloadChoiceKind::KeyPathDynamicMemberLookup) {
-        if (choice1.getKind() == OverloadChoiceKind::DynamicMemberLookup)
-          // Dynamic member lookup through a keypath is better than one using
-          // string because it carries more type information.
-          score2 += weight;
-        else
-          // Otherwise let's prefer non-dynamic declaration.
-          score1 += weight;
-
+      if (choice1.getKind() == OverloadChoiceKind::DynamicMemberLookup &&
+          choice2.getKind() == OverloadChoiceKind::KeyPathDynamicMemberLookup) {
+        score2 += weight;
         continue;
       }
 

branches/tensorflow/lib/Sema/MiscDiagnostics.cpp

@@ -22,16 +22,13 @@
 #include "swift/AST/Pattern.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/SourceManager.h"
-#include "swift/Basic/Statistic.h"
 #include "swift/Basic/StringExtras.h"
 #include "swift/Parse/Lexer.h"
 #include "swift/Parse/Parser.h"
 #include "swift/Sema/IDETypeChecking.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/SaveAndRestore.h"
-
-#define DEBUG_TYPE "Sema"
 using namespace swift;
 
 /// Return true if this expression is an implicit promotion from T to T?.
@@ -1995,10 +1992,6 @@ class VarDeclUsageChecker : public ASTWalker {
   /// This is a mapping from VarDecls to the if/while/guard statement that they
   /// occur in, when they are in a pattern in a StmtCondition.
   llvm::SmallDenseMap<VarDecl*, LabeledConditionalStmt*> StmtConditionForVD;
-
-#ifndef NDEBUG
-  llvm::SmallPtrSet<Expr*, 32> AllExprsSeen;
-#endif
 
   bool sawError = false;
 
@@ -2739,19 +2732,13 @@ void VarDeclUsageChecker::markStoredOrInOutExpr(Expr *E, unsigned Flags) {
 
 /// The heavy lifting happens when visiting expressions.
 std::pair<bool, Expr *> VarDeclUsageChecker::walkToExprPre(Expr *E) {
-  STATISTIC(VarDeclUsageCheckerExprVisits,
-            "# of times VarDeclUsageChecker::walkToExprPre is called");
-  ++VarDeclUsageCheckerExprVisits;
-
   // Sema leaves some subexpressions null, which seems really unfortunate.  It
   // should replace them with ErrorExpr.
   if (E == nullptr || !E->getType() || E->getType()->hasError()) {
     sawError = true;
     return { false, E };
   }
 
-  assert(AllExprsSeen.insert(E).second && "duplicate traversal");
-
   // If this is a DeclRefExpr found in a random place, it is a load of the
   // vardecl.
   if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
@@ -2796,13 +2783,9 @@ std::pair<bool, Expr *> VarDeclUsageChecker::walkToExprPre(Expr *E) {
     return { false, E };
   }
 
-  // If we see an OpenExistentialExpr, remember the mapping for its OpaqueValue
-  // and only walk the subexpr.
-  if (auto *oee = dyn_cast<OpenExistentialExpr>(E)) {
+  // If we see an OpenExistentialExpr, remember the mapping for its OpaqueValue.
+  if (auto *oee = dyn_cast<OpenExistentialExpr>(E))
     OpaqueValueMap[oee->getOpaqueValue()] = oee->getExistentialValue();
-    oee->getSubExpr()->walk(*this);
-    return { false, E };
-  }
 
   // Visit bindings.
   if (auto ove = dyn_cast<OpaqueValueExpr>(E)) {

branches/tensorflow/test/Constraints/keypath_dynamic_member_lookup.swift

@@ -367,26 +367,3 @@ func make_sure_delayed_keypath_dynamic_member_works() {
     }
   }
 }
-
-
-// SR-11465 - Ambiguity in expression which matches both dynamic member lookup and declaration from constrained extension
-
-@dynamicMemberLookup
-struct SR_11465<RawValue> {
-  var rawValue: RawValue
-
-  subscript<Subject>(dynamicMember keyPath: KeyPath<RawValue, Subject>) -> Subject {
-    rawValue[keyPath: keyPath]
-  }
-}
-
-extension SR_11465: Hashable, Equatable where RawValue: Hashable {
-  func hash(into hasher: inout Hasher) {
-    hasher.combine(self.rawValue)
-  }
-}
-
-func test_constrained_ext_vs_dynamic_member() {
-  // CHECK: function_ref @$s29keypath_dynamic_member_lookup8SR_11465VAASHRzlE9hashValueSivg
-  _ = SR_11465<Int>(rawValue: 1).hashValue // Ok, keep choice from constrained extension
-}

branches/tensorflow/test/NameBinding/Inputs/sdf.swift

@@ -0,0 +1,5 @@
+@_exported import asdf
+
+public struct S { public init(x: Int) {} }
+public struct D { public init(x: Int) {} }
+public struct F { public init(x: Int) {} }

branches/tensorflow/test/NameBinding/import-resolution-3.swift

@@ -0,0 +1,10 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/asdf.swift
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/sdf.swift -I %t
+// RUN: %target-swift-frontend -typecheck %s -I %t -verify
+
+import asdf
+import sdf
+import struct sdf.S
+
+var uS: S = sdf.S(x: 123)

branches/tensorflow/test/ParseableInterface/inherited-generic-parameters.swift

@@ -3,9 +3,10 @@
 // RUN: %target-swift-frontend -typecheck %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution
 // RUN: %FileCheck %s < %t/main.swiftinterface
 
-// RUN: %target-swift-frontend -emit-module -module-name main -primary-file %s -emit-module-path %t/main~partial.swiftmodule -enable-library-evolution
+// RUN: %target-build-swift %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution
+// RUN: %FileCheck %s < %t/main.swiftinterface
 
-// RUN: %target-swift-frontend -merge-modules %t/main~partial.swiftmodule -emit-module-path %t/main.swiftmodule -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution
+// RUN: %target-build-swift %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution -wmo
 // RUN: %FileCheck %s < %t/main.swiftinterface
 
 // This test makes sure that we substitute uses of the superclass's generic

branches/tensorflow/test/ParseableInterface/where-clause.swift

@@ -3,9 +3,10 @@
 // RUN: %target-swift-frontend -typecheck %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution
 // RUN: %FileCheck %s < %t/main.swiftinterface
 
-// RUN: %target-swift-frontend -emit-module -module-name main -primary-file %s -emit-module-path %t/main~partial.swiftmodule -enable-library-evolution
+// RUN: %target-build-swift %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution
+// RUN: %FileCheck %s < %t/main.swiftinterface
 
-// RUN: %target-swift-frontend -merge-modules %t/main~partial.swiftmodule -emit-module-path %t/main.swiftmodule -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution
+// RUN: %target-build-swift %s -emit-module-interface-path %t/main.swiftinterface -enable-library-evolution -wmo
 // RUN: %FileCheck %s < %t/main.swiftinterface
 
 // CHECK: import Swift