[CSBindings] Allow hack that drops noEscape bit from function types to work during constraint generation phase

Previously bindings were inferred only during solving but now they
are inferred as soon as something changes in the constraint graph,
so the hack that dropped `noEscape` bit from function type when
inferred for generic parameter should be allowed during constraint
generation as well.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -1112,9 +1112,16 @@ PotentialBindings::inferFromRelational(Constraint *constraint) {
   // whether the parameter is a function type and if so whether it
   // should be allowed to escape. As a result we allow anything
   // passed in to escape.
-  if (auto *fnTy = type->getAs<AnyFunctionType>())
-    if (isGenericParameter() && !CS.shouldAttemptFixes())
+  if (auto *fnTy = type->getAs<AnyFunctionType>()) {
+    // Since inference now happens during constraint generation,
+    // this hack should be allowed in both `Solving`
+    // (during non-diagnostic mode) and `ConstraintGeneration` phases.
+    if (isGenericParameter() &&
+        (!CS.shouldAttemptFixes() ||
+         CS.getPhase() == ConstraintSystemPhase::ConstraintGeneration)) {
       type = fnTy->withExtInfo(fnTy->getExtInfo().withNoEscape(false));
+    }
+  }
 
   // Check whether we can perform this binding.
   if (auto boundType = checkTypeOfBinding(TypeVar, type)) {

test/Constraints/function.swift

@@ -223,3 +223,25 @@ func test_passing_nonescaping_to_escaping_function() {
     bar(handler) // expected-error {{passing non-escaping parameter 'handler' to function expecting an @escaping closure}}
   }
 }
+
+func test_passing_noescape_function_ref_to_generic_parameter() {
+  func cast<T, U>(_ t: T) -> U {
+    return t as! U
+  }
+
+  class A {
+    required init(factory: () -> Self) {
+      fatalError()
+    }
+  }
+
+  struct S {
+    func converter() -> B { fatalError() }
+  }
+
+  class B : A {
+    class func test(value: S) {
+      _ = self.init(factory: cast(value.converter)) // Ok
+    }
+  }
+}