[ConstraintSystem] Attempt types linked via subtyping in reverse order (supertypes first)

If there is a subtype relationship between N types we have to make
sure that type chain is attempted in reverse order because we can't
infer bindings transitively through type variables and attempting
it in any other way would miss potential bindings across the chain.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -347,6 +347,11 @@ ConstraintSystem::getPotentialBindingForRelationalConstraint(
 
     result.InvolvesTypeVariables = true;
 
+    if (constraint->getKind() == ConstraintKind::Subtype &&
+        kind == AllowedBindingKind::Subtypes) {
+      result.SubtypeOf.insert(bindingTypeVar);
+    }
+
     // If we've already set addOptionalSupertypeBindings, or we aren't
     // allowing supertype bindings, we're done.
     if (addOptionalSupertypeBindings || kind != AllowedBindingKind::Supertypes)

lib/Sema/ConstraintSystem.h

@@ -3677,6 +3677,13 @@ class ConstraintSystem {
     /// A set of all constraints which contribute to pontential bindings.
     llvm::SmallPtrSet<Constraint *, 8> Sources;
 
+    /// A set of all not-yet-resolved type variables this type variable
+    /// is a subtype of. This is used to determine ordering inside a
+    /// chain of subtypes because binding inference algorithm can't,
+    /// at the moment, determine bindings transitively through supertype
+    /// type variables.
+    llvm::SmallPtrSet<TypeVariableType *, 4> SubtypeOf;
+
     PotentialBindings(TypeVariableType *typeVar)
         : TypeVar(typeVar), PotentiallyIncomplete(isGenericParameter()) {}
 
@@ -3713,6 +3720,20 @@ class ConstraintSystem {
       if (x.NumDefaultableBindings != y.NumDefaultableBindings)
         return x.NumDefaultableBindings < y.NumDefaultableBindings;
 
+      // If neither type variable is a "hole" let's check whether
+      // there is a subtype relationship between them and prefer
+      // type variable which represents superclass first in order
+      // for "subtype" type variable to attempt more bindings later.
+      // This is required because algorithm can't currently infer
+      // bindings for subtype transitively through superclass ones.
+      if (!(x.IsHole && y.IsHole)) {
+        if (x.SubtypeOf.count(y.TypeVar))
+          return false;
+
+        if (y.SubtypeOf.count(x.TypeVar))
+          return true;
+      }
+
       // As a last resort, let's check if the bindings are
       // potentially incomplete, and if so, let's de-prioritize them.
       return x.PotentiallyIncomplete < y.PotentiallyIncomplete;

test/Generics/deduction.swift

@@ -342,3 +342,29 @@ prefix func +-<T>(_: T) where T: Sequence, T.Element == Int {}
 
 +-"hello"
 // expected-error@-1 {{operator function '+-' requires the types 'String.Element' (aka 'Character') and 'Int' be equivalent}}
+
+func test_transitive_subtype_deduction_for_generic_params() {
+  class A {}
+
+  func foo<T: A>(_: [(String, (T) -> Void)]) {}
+
+  func bar<U>(_: @escaping (U) -> Void) -> (U) -> Void {
+    return { _ in }
+  }
+
+  // Here we have:
+  //  - `W subtype of A`
+  //  - `W subtype of U`
+  //
+  // Type variable associated with `U` has to be attempted
+  // first because solver can't infer bindings for `W` transitively
+  // through `U`.
+  func baz<W: A>(_ arr: [(String, (W) -> Void)]) {
+    foo(arr.map { ($0.0, bar($0.1)) }) // Ok
+  }
+
+  func fiz<T>(_ a: T, _ op: (T, T) -> Bool, _ b: T) {}
+  func biz(_ v: Int32) {
+    fiz(v, !=, -1) // Ok because -1 literal should be inferred as Int32
+  }
+}