[sending] Fix a few bugs around closure inference of sending parameters and results.

I found this while writing tests for the earlier part of this work. Since this
is also type checking work, I am just folding this work into that work.

Author: gottesmm

include/swift/AST/Types.h

@@ -3237,6 +3237,9 @@ class AnyFunctionType : public TypeBase {
     /// Whether the parameter is 'isolated'.
     bool isIsolated() const { return Flags.isIsolated(); }
 
+    /// Whether or not the parameter is 'sending'.
+    bool isSending() const { return Flags.isSending(); }
+
     /// Whether the parameter is 'isCompileTimeConst'.
     bool isCompileTimeConst() const { return Flags.isCompileTimeConst(); }
 

lib/Parse/ParseType.cpp

@@ -1555,6 +1555,8 @@ bool Parser::canParseType() {
     consumeToken();
   } else if (Tok.isContextualKeyword("each")) {
     consumeToken();
+  } else if (Tok.isContextualKeyword("sending")) {
+    consumeToken();
   }
 
   switch (Tok.getKind()) {

lib/Sema/CSSimplify.cpp

@@ -11810,10 +11810,10 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
         if (contextualParam->isIsolated() && !flags.isIsolated() && paramDecl)
           isolatedParams.insert(paramDecl);
 
-        param =
-            param.withFlags(flags.withInOut(contextualParam->isInOut())
-                                 .withVariadic(contextualParam->isVariadic())
-                                 .withIsolated(contextualParam->isIsolated()));
+        param = param.withFlags(flags.withInOut(contextualParam->isInOut())
+                                    .withVariadic(contextualParam->isVariadic())
+                                    .withIsolated(contextualParam->isIsolated())
+                                    .withSending(contextualParam->isSending()));
       }
     }
 
@@ -11940,6 +11940,12 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
       closureExtInfo = closureExtInfo.withSendable();
   }
 
+  // Propagate sending result from the contextual type to the closure.
+  if (auto contextualFnType = contextualType->getAs<FunctionType>()) {
+    if (contextualFnType->hasExtInfo() && contextualFnType->hasSendingResult())
+      closureExtInfo = closureExtInfo.withSendingResult();
+  }
+
   // Isolated parameters override any other kind of isolation we might infer.
   if (hasIsolatedParam) {
     closureExtInfo = closureExtInfo.withIsolation(

test/Concurrency/sending_closure_inference.swift

@@ -0,0 +1,44 @@
+// RUN: %target-swift-frontend -swift-version 6 %s -emit-silgen | %FileCheck %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 {}
+
+/////////////////
+// MARK: Tests //
+/////////////////
+
+// CHECK: sil private [ossa] @$s25sending_closure_inference38testAnonymousParameterSendingInferenceyyFySSYucfU_ : $@convention(thin) (@sil_sending @guaranteed String) -> () {
+func testAnonymousParameterSendingInference() {
+  let _: (sending String) -> () = {
+    print($0)
+  }
+}
+
+// CHECK: sil private [ossa] @$s25sending_closure_inference38testNamedOnlyParameterSendingInferenceyyFySSYucfU_ : $@convention(thin) (@sil_sending @guaranteed String) -> () {
+func testNamedOnlyParameterSendingInference() {
+  let _: (sending String) -> () = { x in
+    print(x)
+  }
+}
+
+// CHECK: sil private [ossa] @$s25sending_closure_inference38testNamedTypeParameterSendingInferenceyyFySSnYucfU_ : $@convention(thin) (@sil_sending @owned String) -> () {
+func testNamedTypeParameterSendingInference() {
+  let _: (sending String) -> () = { (x: sending String) in
+    print(x)
+  }
+}
+
+// CHECK: sil private [ossa] @$s25sending_closure_inference26testSendingResultInferenceyyFSSyYTcfU_ : $@convention(thin) () -> @sil_sending @owned String {
+func testSendingResultInference() {
+  let _: () -> sending String = { "" }
+}