Allow @sendable contravariance in witness params

If a requirement calls for a parameter's function type to be @sendable, Swift will now permit a witness that does *not* make that parameter @sendable. This is fine because @sendable does not affect the calling convention and the witness may not need to exploit the opportunity to send the closure anywhere.

In other words, this code is now valid:

```
protocol P {
    func fn(_: @sendable () -> Void)
}
struct S: P {
    func fn(_: () -> Void)
}
```

There's an edge case where this still isn't allowed when an associated type is @sendable.

Author: beccadax

lib/Sema/TypeCheckProtocol.cpp

@@ -139,15 +139,31 @@ 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;
+  // adjust the witness type to be escaping; likewisse for sendability. This
+  // permits a limited form of covariance.
+  auto applyAdjustment = [&](TypeAdjustment adjustment) {
+    // Sometimes the witness has a function type, but the requirement has
+    // something else (a dependent type we need to infer, in the most relevant
+    // case). In that situation, should we behave as though the requirement type
+    // *did* need the adjustment, or as though it *did not*?
+    //
+    // For noescape, we want to behave as though it was necessary because any
+    // function type not in a parameter is, more or less, implicitly @escaping.
+    // For Sendable, we want to behave as though it was not necessary because
+    // function types that aren't in a parameter can be Sendable or not.
+    // FIXME: Should we check for a Sendable bound on the requirement type?
+    bool inRequirement = (adjustment != TypeAdjustment::NoescapeToEscaping);
+    (void)adjustInferredAssociatedType(adjustment, reqtType, inRequirement);
+
+    bool inWitness = false;
+    Type adjustedWitnessType =
+      adjustInferredAssociatedType(adjustment, witnessType, inWitness);
+    if (inWitness && !inRequirement)
+      witnessType = adjustedWitnessType;
+  };
+
+  applyAdjustment(TypeAdjustment::NoescapeToEscaping);
+  applyAdjustment(TypeAdjustment::NonsendableToSendable);
 
   // For @objc protocols, deal with differences in the optionality.
   // FIXME: It probably makes sense to extend this to non-@objc

lib/Sema/TypeCheckProtocol.h

@@ -1128,12 +1128,19 @@ matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
 AssociatedTypeDecl *getReferencedAssocTypeOfProtocol(Type type,
                                                      ProtocolDecl *proto);
 
+enum class TypeAdjustment : uint8_t {
+  NoescapeToEscaping, NonsendableToSendable
+};
+
 /// 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);
+/// \param performed Will be set \c true if this operation performed
+/// the adjustment, or \c false if the operation found a type that the
+/// adjustment could have applied to but did not actually need to adjust it.
+/// Unchanged otherwise.
+Type adjustInferredAssociatedType(TypeAdjustment adjustment, Type type,
+                                  bool &performed);
 
 /// Find the @objc requirement that are witnessed by the given
 /// declaration.

lib/Sema/TypeCheckProtocolInference.cpp

@@ -633,24 +633,37 @@ AssociatedTypeInference::inferTypeWitnessesViaAssociatedType(
   return result;
 }
 
-Type swift::adjustInferredAssociatedType(Type type, bool &noescapeToEscaping) {
+Type swift::adjustInferredAssociatedType(TypeAdjustment adjustment, Type type,
+                                         bool &performed) {
   // If we have an optional type, adjust its wrapped type.
   if (auto optionalObjectType = type->getOptionalObjectType()) {
     auto newOptionalObjectType =
-      adjustInferredAssociatedType(optionalObjectType, noescapeToEscaping);
+      adjustInferredAssociatedType(adjustment, optionalObjectType, performed);
     if (newOptionalObjectType.getPointer() == optionalObjectType.getPointer())
       return type;
 
     return OptionalType::get(newOptionalObjectType);
   }
 
+  auto needsAdjustment = [=](FunctionType *funcType) -> bool {
+    if (adjustment == TypeAdjustment::NoescapeToEscaping)
+      return funcType->isNoEscape();
+    else
+      return !funcType->isSendable();
+  };
+  auto adjust = [=](const ASTExtInfo &info) -> ASTExtInfo {
+    if (adjustment == TypeAdjustment::NoescapeToEscaping)
+      return info.withNoEscape(false);
+    else
+      return info.withConcurrent(true);
+  };
+
   // If we have a noescape function type, make it escaping.
   if (auto funcType = type->getAs<FunctionType>()) {
-    if (funcType->isNoEscape()) {
-      noescapeToEscaping = true;
+    performed = needsAdjustment(funcType);
+    if (performed)
       return FunctionType::get(funcType->getParams(), funcType->getResult(),
-                               funcType->getExtInfo().withNoEscape(false));
-    }
+                               adjust(funcType->getExtInfo()));
   }
   return type;
 }
@@ -713,7 +726,8 @@ AssociatedTypeInference::inferTypeWitnessesViaValueWitness(ValueDecl *req,
       // Adjust the type to a type that can be written explicitly.
       bool noescapeToEscaping = false;
       Type inferredType =
-        adjustInferredAssociatedType(secondType, noescapeToEscaping);
+        adjustInferredAssociatedType(TypeAdjustment::NoescapeToEscaping,
+                                     secondType, noescapeToEscaping);
       if (!inferredType->isMaterializable())
         return true;
 

test/decl/protocol/conforms/associated_type.swift

@@ -33,22 +33,40 @@ class Foo: FooType {
 }
 
 // rdar://problem/35297911: noescape function types
+// (and @Sendable equivalents of some cases)
 protocol P1 {
   associatedtype A
 
-  func f(_: A)
+  func f(_: A) // expected-note {{protocol requires function 'f' with type '(@escaping SendableX1b.A) -> ()' (aka '(@escaping @Sendable (Int) -> Int) -> ()'); do you want to add a stub?}}
 }
 
 struct X1a : P1 {
   func f(_: @escaping (Int) -> Int) { }
 }
 
+struct SendableX1a : P1 {
+  func f(_: @Sendable (Int) -> Int) { }
+}
+
 struct X1b : P1 {
   typealias A = (Int) -> Int
 
   func f(_: @escaping (Int) -> Int) { }
 }
 
+// FIXME: We would like this case to work. It doesn't because, by the time we
+//        actually look through the DependentMemberType and see that `A` is a
+//        @Sendable function type, we are simplifying a Bind constraint and
+//        don't have the flexibility to adjust the witness's type. Perhaps
+//        instead of adjusting types before adding them to the constraint
+//        graph, we should introduce a new constraint kind that allows only a
+//        witness's adjustments.
+struct SendableX1b : P1 { // expected-error {{type 'SendableX1b' does not conform to protocol 'P1'}}
+  typealias A = @Sendable (Int) -> Int
+
+  func f(_: (Int) -> Int) { } // expected-note {{candidate has non-matching type '((Int) -> Int) -> ()'}}
+}
+
 struct X1c : P1 {
   typealias A = (Int) -> Int
 
@@ -60,17 +78,41 @@ struct X1d : P1 {
 }
 
 protocol P2 {
-  func f(_: (Int) -> Int) // expected-note{{protocol requires function 'f' with type '((Int) -> Int) -> ()'; do you want to add a stub?}}
+  func f(_: (Int) -> Int) // expected-note 3 {{protocol requires function 'f' with type '((Int) -> Int) -> ()'; do you want to add a stub?}}
+  func g(_: @escaping (Int) -> Int) // expected-note 2 {{protocol requires function 'g' with type '(@escaping (Int) -> Int) -> ()'; do you want to add a stub?}}
+  func h(_: @Sendable (Int) -> Int) // expected-note 2 {{protocol requires function 'h' with type '(@Sendable (Int) -> Int) -> ()'; do you want to add a stub?}}
+  func i(_: @escaping @Sendable (Int) -> Int)
 }
 
 struct X2a : P2 {
   func f(_: (Int) -> Int) { }
+  func g(_: (Int) -> Int) { }
+  func h(_: (Int) -> Int) { }
+  func i(_: (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) -> ()'}}
+  func g(_: @escaping (Int) -> Int) { }
+  func h(_: @escaping (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@escaping (Int) -> Int) -> ()'}}
+  func i(_: @escaping (Int) -> Int) { }
 }
 
+struct X2c : P2 { // expected-error{{type 'X2c' does not conform to protocol 'P2'}}
+  func f(_: @Sendable (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@Sendable (Int) -> Int) -> ()'}}
+  func g(_: @Sendable (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@Sendable (Int) -> Int) -> ()'}}
+  func h(_: @Sendable (Int) -> Int) { }
+  func i(_: @Sendable (Int) -> Int) { }
+}
+
+struct X2d : P2 { // expected-error{{type 'X2d' does not conform to protocol 'P2'}}
+  func f(_: @escaping @Sendable (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@escaping @Sendable (Int) -> Int) -> ()'}}
+  func g(_: @escaping @Sendable (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@escaping @Sendable (Int) -> Int) -> ()'}}
+  func h(_: @escaping @Sendable (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@escaping @Sendable (Int) -> Int) -> ()'}}
+  func i(_: @escaping @Sendable (Int) -> Int) { }
+}
+
+
 // SR-12707
 
 class SR_12707_C<T> {}