[sending] Do not let protocol function reqs with a sending result be witnessed by a function without a sending result.

This is important since the witness is not promising to return a disconnected
value and the caller of the requirement is going to accept that.

rdar://127675288

Author: gottesmm

lib/Sema/TypeCheckProtocol.cpp

@@ -743,6 +743,13 @@ RequirementMatch swift::matchWitness(
           reqTypeIsIUO != witnessTypeIsIUO)
         return RequirementMatch(witness, MatchKind::TypeConflict, witnessType);
 
+      // If our requirement says that it has a sending result, then our witness
+      // must also have a sending result since otherwise, in generic contexts,
+      // we would be returning non-disconnected values as disconnected.
+      if (reqFnType->hasExtInfo() && reqFnType->hasSendingResult() &&
+          (!witnessFnType->hasExtInfo() || !witnessFnType->hasSendingResult()))
+        return RequirementMatch(witness, MatchKind::TypeConflict, witnessType);
+
       if (auto result = matchTypes(std::get<0>(types), std::get<1>(types))) {
         return std::move(result.value());
       }
@@ -775,6 +782,12 @@ RequirementMatch swift::matchWitness(
       if (reqParams[i].isInOut() != witnessParams[i].isInOut())
         return RequirementMatch(witness, MatchKind::TypeConflict, witnessType);
 
+      // If we have a requirement without sending and our witness expects a
+      // sending parameter, error.
+      if (!reqParams[i].getParameterFlags().isSending() &&
+          witnessParams[i].getParameterFlags().isSending())
+        return RequirementMatch(witness, MatchKind::TypeConflict, witnessType);
+
       auto reqParamDecl = reqParamList->get(i);
       auto witnessParamDecl = witnessParamList->get(i);
 

test/Concurrency/transfernonsendable_functionsubtyping.swift

@@ -0,0 +1,57 @@
+// RUN: %target-swift-frontend -swift-version 6 -verify -c %s
+
+// READ THIS! This file only contains tests that validate that the relevant
+// function subtyping rules for sending work. Please do not put other tests in
+// the file!
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+
+////////////////////////
+// MARK: Declarations //
+////////////////////////
+
+class NonSendableKlass {}
+
+protocol ProtocolWithSendingReqs {
+  func sendingResult() -> sending NonSendableKlass // expected-note {{}}
+  func nonSendingParam(_ x: NonSendableKlass) // expected-note {{}}
+}
+
+protocol ProtocolWithMixedReqs {
+  func nonSendingParamAndSendingResult(_ x: NonSendableKlass) -> sending NonSendableKlass // expected-note 4{{}}
+}
+
+/////////////////
+// MARK: Tests //
+/////////////////
+
+struct MatchSuccess : ProtocolWithSendingReqs, ProtocolWithMixedReqs {
+  func sendingResult() -> sending NonSendableKlass { fatalError() }
+  func nonSendingParam(_ x: NonSendableKlass) -> () { fatalError() }
+  func nonSendingParamAndSendingResult(_ x: NonSendableKlass) -> sending NonSendableKlass { fatalError() }
+}
+
+struct FailToMatch : ProtocolWithSendingReqs, ProtocolWithMixedReqs { // expected-error 2{{}}
+  func sendingResult() -> NonSendableKlass { fatalError() }
+  // expected-note @-1 {{candidate has non-matching type '() -> NonSendableKlass'}}
+  func nonSendingParam(_ x: sending NonSendableKlass) -> () { fatalError() }
+  // expected-note @-1 {{candidate has non-matching type '(sending NonSendableKlass) -> ()'}}
+  func nonSendingParamAndSendingResult(_ x: sending NonSendableKlass) -> NonSendableKlass { fatalError() }
+  // expected-note @-1 {{candidate has non-matching type '(sending NonSendableKlass) -> NonSendableKlass'}}
+}
+
+struct FailToMatch2 : ProtocolWithMixedReqs { // expected-error {{}}
+  func nonSendingParamAndSendingResult(_ x: sending NonSendableKlass) -> NonSendableKlass { fatalError() }
+  // expected-note @-1 {{candidate has non-matching type '(sending NonSendableKlass) -> NonSendableKlass'}}
+}
+
+struct FailToMatch3 : ProtocolWithMixedReqs { // expected-error {{}}
+  func nonSendingParamAndSendingResult(_ x: NonSendableKlass) -> NonSendableKlass { fatalError() }
+  // expected-note @-1 {{candidate has non-matching type '(NonSendableKlass) -> NonSendableKlass'}}
+}
+
+struct FailToMatch4 : ProtocolWithMixedReqs { // expected-error {{}}
+  func nonSendingParamAndSendingResult(_ x: sending NonSendableKlass) -> sending NonSendableKlass { fatalError() }
+  // expected-note @-1 {{candidate has non-matching type '(sending NonSendableKlass) -> sending NonSendableKlass'}}
+}