---

yaml
---
r: 349444
b: refs/heads/master-next
c: ae932e8
h: refs/heads/master

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 29b9aec1ad13365727a66e7e05a0866f310a02ba
+refs/heads/master-next: ae932e864c6f629ba1f29b42eb650d1549a7cde2
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/lib/Sema/CSSimplify.cpp

@@ -1247,6 +1247,20 @@ static bool isSingleTupleParam(ASTContext &ctx,
   return (paramType->is<TupleType>() || paramType->isTypeVariableOrMember());
 }
 
+static ConstraintFix *fixRequirementFailure(ConstraintSystem &cs, Type type1,
+                                            Type type2, Expr *anchor,
+                                            ArrayRef<LocatorPathElt> path);
+
+static ConstraintFix *fixRequirementFailure(ConstraintSystem &cs, Type type1,
+                                            Type type2,
+                                            ConstraintLocatorBuilder locator) {
+  SmallVector<LocatorPathElt, 4> path;
+  if (auto *anchor = locator.getLocatorParts(path)) {
+    return fixRequirementFailure(cs, type1, type2, anchor, path);
+  }
+  return nullptr;
+}
+
 /// Attempt to fix missing arguments by introducing type variables
 /// and inferring their types from parameters.
 static bool fixMissingArguments(ConstraintSystem &cs, Expr *anchor,
@@ -1748,20 +1762,12 @@ ConstraintSystem::matchDeepEqualityTypes(Type type1, Type type2,
   // Match up the generic arguments, exactly.
 
   if (shouldAttemptFixes()) {
-    bool forRequirement = false;
-    if (auto last = locator.last()) {
-      forRequirement = last->is<LocatorPathElt::AnyRequirement>();
-    }
-
-    // Optionals and arrays have a lot of special diagnostics and only one
+    // Optionals have a lot of special diagnostics and only one
     // generic argument so if we' re dealing with one, don't produce generic
     // arguments mismatch fixes.
-    // TODO(diagnostics): Move Optional and Array diagnostics over to the
+    // TODO(diagnostics): Move Optional diagnostics over to the
     // new framework.
-    bool isOptional = bound1->getDecl()->isOptionalDecl();
-    bool isArray = isArrayType(bound1).hasValue();
-
-    if (forRequirement || isOptional || isArray)
+    if (bound1->getDecl()->isOptionalDecl())
       return matchDeepTypeArguments(*this, subflags, args1, args2, locator);
 
     SmallVector<unsigned, 4> mismatches;
@@ -1772,6 +1778,18 @@ ConstraintSystem::matchDeepEqualityTypes(Type type1, Type type2,
     if (mismatches.empty())
       return result;
 
+    if (auto last = locator.last()) {
+      if (last->is<LocatorPathElt::AnyRequirement>()) {
+        if (auto *fix = fixRequirementFailure(*this, type1, type2, locator)) {
+          if (recordFix(fix))
+            return getTypeMatchFailure(locator);
+
+          increaseScore(SK_Fix, mismatches.size());
+          return getTypeMatchSuccess();
+        }
+      }
+    }
+
     auto *fix = GenericArgumentsMismatch::create(
         *this, type1, type2, mismatches, getConstraintLocator(locator));
 
@@ -2503,8 +2521,16 @@ bool ConstraintSystem::repairFailures(
     if (lhs->hasDependentMember() || rhs->hasDependentMember())
       break;
 
+    // If requirement is something like `T == [Int]` let's let
+    // type matcher a chance to match generic parameters before
+    // recording a fix, because then we'll know exactly how many
+    // generic parameters did not match.
+    if (hasConversionOrRestriction(ConversionRestrictionKind::DeepEquality))
+      break;
+
     auto reqElt = elt.castTo<LocatorPathElt::AnyRequirement>();
     auto reqKind = reqElt.getRequirementKind();
+
     if (hasFixedRequirement(lhs, reqKind, rhs))
       return true;
 

branches/master-next/test/Sema/diag_type_conversion.swift

@@ -29,7 +29,9 @@ func foo6(a : A) {
 
 func foo7(b : [B]) {}
 func foo8(a : [A]) {
-  foo7(b : a) // expected-error {{cannot convert value of type '[A]' to expected argument type '[B]'}} {{13-13= as! [B]}}
+  // TODO(diagnostics): Since `A` and `B` are related it would make sense to suggest forced downcast.
+  foo7(b : a) // expected-error {{cannot convert value of type '[A]' to expected argument type '[B]'}}
+  // expected-note@-1 {{arguments to generic parameter 'Element' ('A' and 'B') are expected to be equal}}
 }
 
 protocol P1 {}

branches/master-next/test/expr/cast/array_bridge.swift

@@ -39,6 +39,7 @@ var b: [B] = []
 a = b as [A]
 
 b = a // expected-error {{cannot assign value of type '[A]' to type '[B]'}}
+// expected-note@-1 {{arguments to generic parameter 'Element' ('A' and 'B') are expected to be equal}}
 
 var aa: [[A]] = []
 var bb: [[B]] = []
@@ -76,6 +77,7 @@ var f: [F] = []
 
 e = f as [E]
 f = e // expected-error {{cannot assign value of type '[E]' to type '[F]'}}
+// expected-note@-1 {{arguments to generic parameter 'Element' ('E' and 'F') are expected to be equal}}
 
 class G {
   var x = 0
@@ -126,3 +128,4 @@ var i: [I] = []
 
 aoa = i as [AnyObject]
 i = aoa // expected-error {{cannot assign value of type '[AnyObject]' to type '[I]'}}
+// expected-note@-1 {{arguments to generic parameter 'Element' ('AnyObject' and 'I') are expected to be equal}}

branches/master-next/test/expr/cast/array_coerce.swift

@@ -17,6 +17,7 @@ var da: Array<D> = [d1]
 
 ca = da
 da = ca // expected-error{{cannot assign value of type 'Array<C>' to type 'Array<D>'}}
+// expected-note@-1 {{arguments to generic parameter 'Element' ('C' and 'D') are expected to be equal}}
 
 var caa = [ca]
 var daa = [da]
@@ -29,6 +30,7 @@ var das: [D] = [d1]
 
 cas = das
 das = cas // expected-error{{cannot assign value of type '[C]' to type '[D]'}}
+// expected-note@-1 {{arguments to generic parameter 'Element' ('C' and 'D') are expected to be equal}}
 
 // ArraySlice<T>
 var cs = ca[0...0]

branches/master-next/test/expr/closure/anonymous.swift

@@ -34,8 +34,10 @@ func variadic() {
   let _: (Int...) -> () = {takesIntArray($0)}
   // expected-error@-1 {{cannot convert value of type '([Int]) -> ()' to specified type '(Int...) -> ()'}}
 
+  // TODO(diagnostics): This requires special handling - variadic vs. array
   takesVariadicGeneric({takesIntArray($0)})
   // expected-error@-1 {{cannot convert value of type 'Array<Element>' to expected argument type '[Int]'}}
+  // expected-note@-2 {{arguments to generic parameter 'Element' ('Element' and 'Int') are expected to be equal}}
 
   takesVariadicGeneric({let _: [Int] = $0})
   // expected-error@-1 {{cannot convert value of type '(_) -> ()' to expected argument type '(_...) -> ()'}}

branches/master-next/test/type/subclass_composition.swift

@@ -4,7 +4,7 @@ protocol P1 {
   typealias DependentInConcreteConformance = Self
 }
 
-class Base<T> : P1 {
+class Base<T> : P1 { // expected-note {{arguments to generic parameter 'T' ('String' and 'Int') are expected to be equal}}
   typealias DependentClass = T
 
   required init(classInit: ()) {}
@@ -302,11 +302,11 @@ func conformsToAnyObject<T : AnyObject>(_: T) {}
 func conformsToP1<T : P1>(_: T) {}
 func conformsToP2<T : P2>(_: T) {}
 func conformsToBaseIntAndP2<T : Base<Int> & P2>(_: T) {}
-// expected-note@-1 {{where 'T' = 'Base<String>'}}
-// expected-note@-2 2 {{where 'T' = 'Base<Int>'}}
+// expected-note@-1 {{where 'T' = 'FakeDerived'}}
+// expected-note@-2 {{where 'T' = 'Base<Int>'}}
 
 func conformsToBaseIntAndP2WithWhereClause<T>(_: T) where T : Base<Int> & P2 {}
-// expected-note@-1 {{where 'T' = 'Base<String>'}}
+// expected-note@-1 {{where 'T' = 'FakeDerived'}}
 // expected-note@-2 {{where 'T' = 'Base<Int>'}}
 
 class FakeDerived : Base<String>, P2 {
@@ -421,16 +421,15 @@ func conformsTo<T1 : P2, T2 : Base<Int> & P2>(
   conformsToBaseIntAndP2(base)
   // expected-error@-1 {{argument type 'Base<Int>' does not conform to expected type 'P2'}}
 
-  // TODO(diagnostics): Diagnostic for this problem should mention both `Base<String>` not conforming to `P2`
-  // and invalid generic parameter (Int vs. String)
   conformsToBaseIntAndP2(badBase)
-  // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'Base<Int>' conform to 'P2'}}
+  // expected-error@-1 {{argument type 'Base<Int>' does not conform to expected type 'P2'}}
+  // expected-error@-2 {{cannot convert value of type 'Base<String>' to expected argument type 'Base<Int>'}}
 
   conformsToBaseIntAndP2(fakeDerived)
-  // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'Base<String>' inherit from 'Base<Int>'}}
+  // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'FakeDerived' inherit from 'Base<Int>'}}
 
   conformsToBaseIntAndP2WithWhereClause(fakeDerived)
-  // expected-error@-1 {{global function 'conformsToBaseIntAndP2WithWhereClause' requires that 'Base<String>' inherit from 'Base<Int>'}}
+  // expected-error@-1 {{global function 'conformsToBaseIntAndP2WithWhereClause' requires that 'FakeDerived' inherit from 'Base<Int>'}}
 
   conformsToBaseIntAndP2(p2Archetype)
   // expected-error@-1 {{global function 'conformsToBaseIntAndP2' requires that 'Base<Int>' conform to 'P2'}}