---

yaml
---
r: 326655
b: refs/heads/tensorflow
c: 1f023c6
h: refs/heads/master
i:
  326653: d5e0b17
  326651: d0b6b38
  326647: 503d825
  326639: edf8aef
  326623: 2d0b34a
  326591: 14b4b3d
  326527: e67cc5e
  326399: 7607adc
  326143: a994ee4
  325631: 757ef7a

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: 1d9f1ec3f8cb537bcec974b9474edac7ccbd7b11
+refs/heads/tensorflow: 1f023c6b8847d939c9858e58bd236065849c2b49
 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/lib/SILOptimizer/UtilityPasses/LoopRegionPrinter.cpp

@@ -20,37 +20,66 @@
 #include "swift/SILOptimizer/Analysis/LoopRegionAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/Support/CommandLine.h"
 
 using namespace swift;
 
+static llvm::cl::opt<std::string>
+    SILViewCFGOnlyFun("sil-loop-region-view-cfg-only-function",
+                      llvm::cl::init(""),
+                      llvm::cl::desc("Only produce a graphviz file for the "
+                                     "loop region info of this function"));
+
+static llvm::cl::opt<std::string>
+    SILViewCFGOnlyFuns("sil-loop-region-view-cfg-only-functions",
+                       llvm::cl::init(""),
+                       llvm::cl::desc("Only produce a graphviz file for the "
+                                      "loop region info for the functions "
+                                      "whose name contains this substring"));
+
 namespace {
 
 class LoopRegionViewText : public SILModuleTransform {
   void run() override {
     invalidateAll();
-    LoopRegionAnalysis *LRA = PM->getAnalysis<LoopRegionAnalysis>();
-    for (auto &Fn : *getModule()) {
-      if (Fn.isExternalDeclaration()) continue;
+    auto *lra = PM->getAnalysis<LoopRegionAnalysis>();
+
+    for (auto &fn : *getModule()) {
+      if (fn.isExternalDeclaration())
+        continue;
+      if (!SILViewCFGOnlyFun.empty() && fn.getName() != SILViewCFGOnlyFun)
+        continue;
+      if (!SILViewCFGOnlyFuns.empty() &&
+          fn.getName().find(SILViewCFGOnlyFuns, 0) == StringRef::npos)
+        continue;
 
-      llvm::outs() << "@" << Fn.getName() << "@\n";
-      LRA->get(&Fn)->dump();
-      llvm::outs() << "\n";
+      // Ok, we are going to analyze this function. Invalidate all state
+      // associated with it so we recompute the loop regions.
+      llvm::outs() << "Start @" << fn.getName() << "@\n";
+      lra->get(&fn)->dump();
+      llvm::outs() << "End @" << fn.getName() << "@\n";
       llvm::outs().flush();
     }
   }
-
 };
 
 class LoopRegionViewCFG : public SILModuleTransform {
   void run() override {
+    invalidateAll();
+    auto *lra = PM->getAnalysis<LoopRegionAnalysis>();
 
-    LoopRegionAnalysis *LRA = PM->getAnalysis<LoopRegionAnalysis>();
-
-    auto *M = getModule();
-    for (auto &Fn : M->getFunctions()) {
-      if (Fn.isExternalDeclaration())
+    for (auto &fn : *getModule()) {
+      if (fn.isExternalDeclaration())
         continue;
-      LRA->get(&Fn)->viewLoopRegions();
+      if (!SILViewCFGOnlyFun.empty() && fn.getName() != SILViewCFGOnlyFun)
+        continue;
+      if (!SILViewCFGOnlyFuns.empty() &&
+          fn.getName().find(SILViewCFGOnlyFuns, 0) == StringRef::npos)
+        continue;
+
+      // Ok, we are going to analyze this function. Invalidate all state
+      // associated with it so we recompute the loop regions.
+      lra->get(&fn)->viewLoopRegions();
     }
   }
 };

branches/tensorflow/lib/Sema/CSDiagnostics.cpp

@@ -373,8 +373,36 @@ ValueDecl *RequirementFailure::getDeclRef() const {
   if (isFromContextualType())
     return getAffectedDeclFromType(cs.getContextualType());
 
-  if (auto overload = getChoiceFor(getRawAnchor()))
-    return overload->choice.getDecl();
+  if (auto overload = getChoiceFor(getRawAnchor())) {
+    // If there is a declaration associated with this
+    // failure e.g. an overload choice of the call
+    // expression, let's see whether failure is
+    // associated with it directly or rather with
+    // one of its parents.
+    if (auto *decl = overload->choice.getDeclOrNull()) {
+      auto *DC = decl->getDeclContext();
+
+      do {
+        if (auto *parent = DC->getAsDecl()) {
+          if (auto *GC = parent->getAsGenericContext()) {
+            if (GC->getGenericSignature() != Signature)
+              continue;
+
+            // If this is a signature if an extension
+            // then it means that code has referenced
+            // something incorrectly and diagnostic
+            // should point to the referenced declaration.
+            if (isa<ExtensionDecl>(parent))
+              break;
+
+            return cast<ValueDecl>(parent);
+          }
+        }
+      } while ((DC = DC->getParent()));
+
+      return decl;
+    }
+  }
 
   return getAffectedDeclFromType(getOwnerType());
 }

branches/tensorflow/lib/Sema/CSDiagnostics.h

@@ -304,31 +304,12 @@ class RequirementFailure : public FailureDiagnostic {
     if (isConditional())
       return true;
 
-    auto *anchor = getAnchor();
-    // In the situations like this:
-    //
-    // ```swift
-    // enum E<T: P> { case foo(T) }
-    // let _: E = .foo(...)
-    // ```
-    //
-    // `E` is going to be opened twice. First, when
-    // it's used as a contextual type, and when `E.foo`
-    // is found and its function type is opened.
-    // We still want to record both fixes but should
-    // avoid diagnosing the same problem multiple times.
-    if (isa<UnresolvedMemberExpr>(anchor)) {
-      auto path = getLocator()->getPath();
-      if (path.front().getKind() != ConstraintLocator::UnresolvedMember)
-        return false;
-    }
-
     // For static/initializer calls there is going to be
     // a separate fix, attached to the argument, which is
     // much easier to diagnose.
     // For operator calls we can't currently produce a good
     // diagnostic, so instead let's refer to expression diagnostics.
-    return !(Apply && (isOperator(Apply) || isa<TypeExpr>(anchor)));
+    return !(Apply && isOperator(Apply));
   }
 
   static bool isOperator(const ApplyExpr *apply) {

branches/tensorflow/lib/Sema/CSSimplify.cpp

@@ -2502,8 +2502,14 @@ bool ConstraintSystem::repairFailures(
     if (lhs->hasDependentMember() || rhs->hasDependentMember())
       break;
 
-    if (auto *fix = fixRequirementFailure(*this, lhs, rhs, anchor, path))
+    auto reqKind = static_cast<RequirementKind>(elt.getValue2());
+    if (hasFixedRequirement(lhs, reqKind, rhs))
+      return true;
+
+    if (auto *fix = fixRequirementFailure(*this, lhs, rhs, anchor, path)) {
+      recordFixedRequirement(lhs, reqKind, rhs);
       conversionsOrFixes.push_back(fix);
+    }
     break;
   }
 
@@ -3775,6 +3781,11 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
   if (type->isVoid() || type->isUninhabited())
     return SolutionKind::Error;
 
+  auto protocolTy = protocol->getDeclaredType();
+  // If this conformance has been fixed already, let's just consider this done.
+  if (hasFixedRequirement(type, RequirementKind::Conformance, protocolTy))
+    return SolutionKind::Solved;
+
   // If this is a generic requirement let's try to record that
   // conformance is missing and consider this a success, which
   // makes it much easier to diagnose problems like that.
@@ -3787,10 +3798,14 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
 
     if (path.back().isTypeParameterRequirement() ||
         path.back().isConditionalRequirement()) {
-      if (auto *fix = fixRequirementFailure(
-              *this, type, protocol->getDeclaredType(), anchor, path)) {
-        if (!recordFix(fix))
+      if (auto *fix =
+              fixRequirementFailure(*this, type, protocolTy, anchor, path)) {
+        if (!recordFix(fix)) {
+          // Record this conformance requirement as "fixed".
+          recordFixedRequirement(type, RequirementKind::Conformance,
+                                 protocolTy);
           return SolutionKind::Solved;
+        }
       }
     }
 

branches/tensorflow/lib/Sema/CSSolver.cpp

@@ -452,6 +452,7 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
   numSavedBindings = cs.solverState->savedBindings.size();
   numConstraintRestrictions = cs.ConstraintRestrictions.size();
   numFixes = cs.Fixes.size();
+  numFixedRequirements = cs.FixedRequirements.size();
   numDisjunctionChoices = cs.DisjunctionChoices.size();
   numOpenedTypes = cs.OpenedTypes.size();
   numOpenedExistentialTypes = cs.OpenedExistentialTypes.size();
@@ -505,6 +506,10 @@ ConstraintSystem::SolverScope::~SolverScope() {
   // Remove any opened types.
   truncate(cs.OpenedTypes, numOpenedTypes);
 
+  // Remove any conformances solver had to fix along
+  // the current path.
+  truncate(cs.FixedRequirements, numFixedRequirements);
+
   // Remove any opened existential types.
   truncate(cs.OpenedExistentialTypes, numOpenedExistentialTypes);
 

branches/tensorflow/lib/Sema/ConstraintSystem.h

@@ -1119,6 +1119,23 @@ class ConstraintSystem {
   SmallVector<std::pair<ConstraintLocator *, ArrayRef<OpenedType>>, 4>
     OpenedTypes;
 
+  /// The list of all generic requirements fixed along the current
+  /// solver path.
+  using FixedRequirement = std::tuple<TypeBase *, RequirementKind, TypeBase *>;
+  SmallVector<FixedRequirement, 4> FixedRequirements;
+
+  bool hasFixedRequirement(Type lhs, RequirementKind kind, Type rhs) {
+    auto reqInfo = std::make_tuple(lhs.getPointer(), kind, rhs.getPointer());
+    return llvm::any_of(
+        FixedRequirements,
+        [&reqInfo](const FixedRequirement &entry) { return entry == reqInfo; });
+  }
+
+  void recordFixedRequirement(Type lhs, RequirementKind kind, Type rhs) {
+    FixedRequirements.push_back(
+        std::make_tuple(lhs.getPointer(), kind, rhs.getPointer()));
+  }
+
   /// A mapping from constraint locators to the opened existential archetype
   /// used for the 'self' of an existential type.
   SmallVector<std::pair<ConstraintLocator *, OpenedArchetypeType *>, 4>
@@ -1614,6 +1631,9 @@ class ConstraintSystem {
     /// The length of \c Fixes.
     unsigned numFixes;
 
+    /// The length of \c FixedRequirements.
+    unsigned numFixedRequirements;
+
     /// The length of \c DisjunctionChoices.
     unsigned numDisjunctionChoices;
 

branches/tensorflow/stdlib/public/core/DictionaryBridging.swift

@@ -313,7 +313,6 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     let bridgedKeys = bridgeKeys()
     let bridgedValues = bridgeValues()
     var i = 0 // Current position in the output buffers
-    let bucketCount = native._storage._bucketCount
 
     defer { _fixLifetime(self) }
 

branches/tensorflow/stdlib/public/core/KeyPath.swift

@@ -357,7 +357,7 @@ public class ReferenceWritableKeyPath<
   internal final func _projectMutableAddress(from origBase: Root)
       -> (pointer: UnsafeMutablePointer<Value>, owner: AnyObject?) {
     var keepAlive: AnyObject?
-    var address: UnsafeMutablePointer<Value> = withBuffer {
+    let address: UnsafeMutablePointer<Value> = withBuffer {
       var buffer = $0
       // Project out the reference prefix.
       var base: Any = origBase

branches/tensorflow/stdlib/public/core/Sort.swift

@@ -246,8 +246,8 @@ extension MutableCollection where Self: RandomAccessCollection {
   public mutating func sort(
     by areInIncreasingOrder: (Element, Element) throws -> Bool
   ) rethrows {
-    let didSortUnsafeBuffer = try _withUnsafeMutableBufferPointerIfSupported {
-      buffer -> Void? in
+    let didSortUnsafeBuffer: Void? = try _withUnsafeMutableBufferPointerIfSupported {
+      buffer -> Void in
         try buffer._stableSortImpl(by: areInIncreasingOrder)
     }
     if didSortUnsafeBuffer == nil {

branches/tensorflow/test/Constraints/generics.swift

@@ -335,14 +335,14 @@ func testFixIts() {
   _ = AnyClassAndProtoBound() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{28-28=<<#Foo: SubProto & AnyObject#>>}}
   _ = AnyClassAndProtoBound2() // expected-error {{generic parameter 'Foo' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}} {{29-29=<<#Foo: SubProto & AnyObject#>>}}
 
-  _ = ClassAndProtoBound() // expected-error {{referencing initializer 'init()' on 'ClassAndProtoBound' requires that 'X' conform to 'SubProto'}}
+  _ = ClassAndProtoBound() // expected-error {{generic struct 'ClassAndProtoBound' requires that 'X' conform to 'SubProto'}}
 
-  _ = ClassAndProtosBound() 
-  // expected-error@-1 {{referencing initializer 'init()' on 'ClassAndProtosBound' requires that 'X' conform to 'NSCopyish'}}
-  // expected-error@-2 {{referencing initializer 'init()' on 'ClassAndProtosBound' requires that 'X' conform to 'SubProto'}}
+  _ = ClassAndProtosBound()
+  // expected-error@-1 {{generic struct 'ClassAndProtosBound' requires that 'X' conform to 'SubProto'}}
+  // expected-error@-2 {{generic struct 'ClassAndProtosBound' requires that 'X' conform to 'NSCopyish'}}
   _ = ClassAndProtosBound2()
-  // expected-error@-1 {{referencing initializer 'init()' on 'ClassAndProtosBound2' requires that 'X' conform to 'NSCopyish'}}
-  // expected-error@-2 {{referencing initializer 'init()' on 'ClassAndProtosBound2' requires that 'X' conform to 'SubProto'}}
+  // expected-error@-1 {{generic struct 'ClassAndProtosBound2' requires that 'X' conform to 'SubProto'}}
+  // expected-error@-2 {{generic struct 'ClassAndProtosBound2' requires that 'X' conform to 'NSCopyish'}}
 
   _ = Pair()
   // expected-error@-1 {{generic parameter 'T' could not be inferred}}
@@ -631,16 +631,16 @@ func rdar40537858() {
   }
 
   var arr: [S] = []
-  _ = List(arr, id: \.id) // expected-error {{referencing initializer 'init(_:id:)' on 'List' requires that 'S.Id' conform to 'Hashable'}}
+  _ = List(arr, id: \.id) // expected-error {{generic struct 'List' requires that 'S.Id' conform to 'Hashable'}}
 
   enum E<T: P> { // expected-note 2 {{where 'T' = 'S'}}
     case foo(T)
     case bar([T])
   }
 
   var s = S(id: S.Id())
-  let _: E = .foo(s)   // expected-error {{enum case 'foo' requires that 'S' conform to 'P'}}
-  let _: E = .bar([s]) // expected-error {{enum case 'bar' requires that 'S' conform to 'P'}}
+  let _: E = .foo(s)   // expected-error {{generic enum 'E' requires that 'S' conform to 'P'}}
+  let _: E = .bar([s]) // expected-error {{generic enum 'E' requires that 'S' conform to 'P'}}
 }
 
 // https://bugs.swift.org/browse/SR-8934
@@ -798,3 +798,20 @@ struct R_51413254 {
     self.str = try anyDict ==> Key("a") // Ok
   }
 }
+
+func test_correct_identification_of_requirement_source() {
+  struct X<T: P> { // expected-note {{where 'T' = 'Int'}}
+    init<U: P>(_: T, _: U) {} // expected-note {{where 'U' = 'Int'}}
+  }
+
+  struct A : P {
+    static func foo(_ arg: A) -> A {
+      return A()
+    }
+  }
+
+  _ = X(17, A())
+  // expected-error@-1 {{generic struct 'X' requires that 'Int' conform to 'P'}}
+  _ = X(A(), 17)
+  // expected-error@-1 {{initializer 'init(_:_:)' requires that 'Int' conform to 'P'}}
+}

branches/tensorflow/test/Constraints/rdar44569159.swift

@@ -6,13 +6,12 @@ struct S<V> where V: P { // expected-note {{where 'V' = 'Double'}}
 }
 
 struct A {
-  subscript<T>(_ v: S<T>) -> A { // expected-note {{where 'T' = 'Double'}}
+  subscript<T>(_ v: S<T>) -> A {
     fatalError()
   }
 }
 
 func foo(_ v: Double) {
   _ = A()[S(value: v)]
-// expected-error@-1 {{subscript 'subscript(_:)' requires that 'Double' conform to 'P'}}
-// expected-error@-2 {{referencing initializer 'init(value:)' on 'S' requires that 'Double' conform to 'P'}}
+ // expected-error@-1 {{generic struct 'S' requires that 'Double' conform to 'P'}}
 }