Allow a witness's noescape parameter to match a requirement's escaping parameter

Extend protocol conformance checking to allow a requirement with an
escaping parameter (of function type) to be satisfied by a witness
with a corresponding non-escaping parameter. This limited form of
covariance was already supported by SILGen and is needed to address
the source-compatibility "regression" introduced by inferring escaping
function types for associated type witnesses. It's also obviously a
good idea :)

Fixes rdar://problem/35297911.

Author: DougGregor

lib/Sema/TypeCheckProtocol.cpp

@@ -138,6 +138,17 @@ static std::tuple<Type, Type, OptionalAdjustmentKind>
 getTypesToCompare(ValueDecl *reqt, Type reqtType, bool reqtTypeIsIUO,
                   Type witnessType, bool witnessTypeIsIUO,
                   VarianceKind variance) {
+  // If the witness type is noescape but the requirement type is not,
+  // adjust the witness type to be escaping. This permits a limited form of
+  // covariance.
+  bool reqNoescapeToEscaping = false;
+  (void)adjustInferredAssociatedType(reqtType, reqNoescapeToEscaping);
+  bool witnessNoescapeToEscaping = false;
+  Type adjustedWitnessType =
+    adjustInferredAssociatedType(witnessType, witnessNoescapeToEscaping);
+  if (witnessNoescapeToEscaping && !reqNoescapeToEscaping)
+    witnessType = adjustedWitnessType;
+
   // For @objc protocols, deal with differences in the optionality.
   // FIXME: It probably makes sense to extend this to non-@objc
   // protocols as well, but this requires more testing.
@@ -152,8 +163,7 @@ getTypesToCompare(ValueDecl *reqt, Type reqtType, bool reqtTypeIsIUO,
     reqtType = reqtValueType;
   }
   bool witnessIsOptional = false;
-  if (Type witnessValueType =
-      witnessType->getOptionalObjectType()) {
+  if (Type witnessValueType = witnessType->getOptionalObjectType()) {
     witnessIsOptional = true;
     witnessType = witnessValueType;
   }

lib/Sema/TypeCheckProtocol.h

@@ -852,6 +852,13 @@ RequirementMatch matchWitness(TypeChecker &tc,
 AssociatedTypeDecl *getReferencedAssocTypeOfProtocol(Type type,
                                                      ProtocolDecl *proto);
 
+/// Perform any necessary adjustments to the inferred associated type to
+/// make it suitable for later use.
+///
+/// \param noescapeToEscaping Will be set \c true if this operation performed
+/// the noescape-to-escaping adjustment.
+Type adjustInferredAssociatedType(Type type, bool &noescapeToEscaping);
+
 }
 
 #endif // SWIFT_SEMA_PROTOCOL_H

lib/Sema/TypeCheckProtocolInference.cpp

@@ -607,13 +607,11 @@ 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) {
+Type swift::adjustInferredAssociatedType(Type type, bool &noescapeToEscaping) {
   // If we have an optional type, adjust its wrapped type.
   if (auto optionalObjectType = type->getOptionalObjectType()) {
     auto newOptionalObjectType =
-      adjustInferredAssociatedType(optionalObjectType);
+      adjustInferredAssociatedType(optionalObjectType, noescapeToEscaping);
     if (newOptionalObjectType.getPointer() == optionalObjectType.getPointer())
       return type;
 
@@ -623,14 +621,11 @@ static Type adjustInferredAssociatedType(Type type) {
   // If we have a noescape function type, make it escaping.
   if (auto funcType = type->getAs<FunctionType>()) {
     if (funcType->isNoEscape()) {
+      noescapeToEscaping = true;
       return FunctionType::get(funcType->getParams(), funcType->getResult(),
                                funcType->getExtInfo().withNoEscape(false));
     }
   }
-
-  // We can only infer materializable types.
-  if (!type->isMaterializable()) return nullptr;
-
   return type;
 }
 
@@ -689,8 +684,11 @@ AssociatedTypeInference::inferTypeWitnessesViaValueWitness(ValueDecl *req,
       if (secondType->hasError())
         return true;
 
-      Type inferredType = adjustInferredAssociatedType(secondType);
-      if (!inferredType)
+      // Adjust the type to a type that can be written explicitly.
+      bool noescapeToEscaping = false;
+      Type inferredType =
+        adjustInferredAssociatedType(secondType, noescapeToEscaping);
+      if (!inferredType->isMaterializable())
         return true;
 
       auto proto = Conformance->getProtocol();

test/SILGen/witnesses.swift

@@ -512,3 +512,16 @@ class CrashableBase {
 // CHECK-NEXT: return [[RESULT]] : $()
 
 class GenericCrashable<T> : CrashableBase, Crashable {}
+
+// rdar://problem/35297911: allow witness with a noescape parameter to
+// match a requirement with an escaping paameter.
+protocol EscapingReq {
+  func f(_: @escaping (Int) -> Int)
+}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses18EscapingCovarianceVAA0B3ReqA2aDP1fyyS2icFTW : $@convention(witness_method: EscapingReq) (@guaranteed @callee_guaranteed (Int) -> Int, @in_guaranteed EscapingCovariance) -> ()
+// CHECK-NOT: return
+// CHECK: convert_escape_to_noescape %0
+struct EscapingCovariance: EscapingReq {
+  func f(_: (Int) -> Int) { }
+}

test/decl/protocol/conforms/associated_type.swift

@@ -38,8 +38,6 @@ 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 {
@@ -52,12 +50,24 @@ struct X1b : P1 {
   func f(_: @escaping (Int) -> Int) { }
 }
 
-struct X1c : P1 { // expected-error{{type 'X1c' does not conform to protocol 'P1'}}
+struct X1c : P1 {
   typealias A = (Int) -> Int
 
-  func f(_: (Int) -> Int) { } // expected-note{{candidate has non-matching type '((Int) -> Int) -> ()'}}
+  func f(_: (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]}}
+struct X1d : P1 {
+  func f(_: (Int) -> Int) { }
+}
+
+protocol P2 {
+  func f(_: (Int) -> Int) // expected-note{{protocol requires function 'f' with type '((Int) -> Int) -> ()'; do you want to add a stub?}}
+}
+
+struct X2a : P2 {
+  func f(_: (Int) -> Int) { }
+}
+
+struct X2b : P2 { // expected-error{{type 'X2b' does not conform to protocol 'P2'}}
+  func f(_: @escaping (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@escaping (Int) -> Int) -> ()'}}
 }