[Associated type inference] Infer escaping function types, not noescape ones.

When inferring an associated type witness by matching a function signature,
adjust non-escaping function types to escaping function types, because only
escaping function types could be written as explicit witnesses and
non-escaping function types are not permitted outside of function
parameters.

Addresses the first part of rdar://problem/35297911, eliminating the
type-soundness issue.

Author: DougGregor

lib/Sema/TypeCheckProtocolInference.cpp

@@ -607,6 +607,33 @@ AssociatedTypeInference::inferTypeWitnessesViaAssociatedType(
   return result;
 }
 
+/// Perform any necessary adjustments to the inferred associated type to
+/// make it suitable for later use.
+static Type adjustInferredAssociatedType(Type type) {
+  // If we have an optional type, adjust its wrapped type.
+  if (auto optionalObjectType = type->getOptionalObjectType()) {
+    auto newOptionalObjectType =
+      adjustInferredAssociatedType(optionalObjectType);
+    if (newOptionalObjectType.getPointer() == optionalObjectType.getPointer())
+      return type;
+
+    return OptionalType::get(newOptionalObjectType);
+  }
+
+  // If we have a noescape function type, make it escaping.
+  if (auto funcType = type->getAs<FunctionType>()) {
+    if (funcType->isNoEscape()) {
+      return FunctionType::get(funcType->getParams(), funcType->getResult(),
+                               funcType->getExtInfo().withNoEscape(false));
+    }
+  }
+
+  // We can only infer materializable types.
+  if (!type->isMaterializable()) return nullptr;
+
+  return type;
+}
+
 /// Attempt to resolve a type witness via a specific value witness.
 InferredAssociatedTypesByWitness
 AssociatedTypeInference::inferTypeWitnessesViaValueWitness(ValueDecl *req,
@@ -662,10 +689,14 @@ AssociatedTypeInference::inferTypeWitnessesViaValueWitness(ValueDecl *req,
       if (secondType->hasError())
         return true;
 
+      Type inferredType = adjustInferredAssociatedType(secondType);
+      if (!inferredType)
+        return true;
+
       auto proto = Conformance->getProtocol();
       if (auto assocType = getReferencedAssocTypeOfProtocol(firstDepMember,
                                                             proto)) {
-        Inferred.Inferred.push_back({assocType, secondType});
+        Inferred.Inferred.push_back({assocType, inferredType});
       }
 
       // Always allow mismatches here.

test/decl/protocol/conforms/associated_type.swift

@@ -32,3 +32,32 @@ class Foo: FooType {
     func foo(action: (Bar) -> Void) {
     }
 }
+
+// rdar://problem/35297911: noescape function types
+protocol P1 {
+  associatedtype A
+
+  func f(_: A)
+  // expected-note@-1 {{protocol requires function 'f' with type '(X1c.A) -> ()' (aka '((Int) -> Int) -> ()'); do you want to add a stub?}}
+  // expected-note@-2 {{protocol requires function 'f' with type '((Int) -> Int) -> ()'; do you want to add a stub?}}
+}
+
+struct X1a : P1 {
+  func f(_: @escaping (Int) -> Int) { }
+}
+
+struct X1b : P1 {
+  typealias A = (Int) -> Int
+
+  func f(_: @escaping (Int) -> Int) { }
+}
+
+struct X1c : P1 { // expected-error{{type 'X1c' does not conform to protocol 'P1'}}
+  typealias A = (Int) -> Int
+
+  func f(_: (Int) -> Int) { } // expected-note{{candidate has non-matching type '((Int) -> Int) -> ()'}}
+}
+
+struct X1d : P1 { // expected-error{{type 'X1d' does not conform to protocol 'P1'}}
+  func f(_: (Int) -> Int) { } // expected-note{{candidate has non-matching type '((Int) -> Int) -> ()' [with A = (Int) -> Int]}}
+}