[test] add sendable method and function tests

Author: angela-laar

lib/Sema/TypeCheckConcurrency.cpp

@@ -2467,7 +2467,7 @@ namespace {
         auto valueRef = declRef->getDeclRef();
         auto value = valueRef.getDecl();
         auto loc = declRef->getLoc();
-        
+
         //FIXME: Should this be subsumed in reference checking?
         if (value->isLocalCapture())
           checkLocalCapture(valueRef, loc, declRef);
@@ -3104,11 +3104,6 @@ namespace {
           getContextIsolation().isActorIsolated())
         unsatisfiedIsolation = ActorIsolation::forNonisolated();
 
-      // move check for sendability of arguments earlier
-      if (!ctx.LangOpts.hasFeature(Feature::DeferredSendableChecking)) {
-        diagnoseApplyArgSendability(apply, getDeclContext());
-      }
-
       // If there was no unsatisfied actor isolation, we're done.
       if (!unsatisfiedIsolation)
         return false;

test/Concurrency/sendable_functions.swift

@@ -46,3 +46,12 @@ extension S: Sendable where T: Sendable {
 
 @available(SwiftStdlib 5.1, *)
 @MainActor @Sendable func globalActorFuncAsync() async { }
+
+func doWork() -> Int {
+  Int.random(in: 1..<42)
+}
+
+// unapplied global func call
+let work: @Sendable () -> Int = doWork
+Task<Int, Never>.detached(priority: nil, operation: doWork)
+Task<Int, Never>.detached(priority: nil, operation: work)

test/Concurrency/sendable_methods.swift

@@ -0,0 +1,116 @@
+// RUN: %target-typecheck-verify-swift
+// REQUIRES: concurrency
+
+final class C : Sendable {
+  func f() {}
+}
+
+struct S : Sendable {
+  func f(){}
+}
+
+enum E : Sendable {
+  case a, b, c
+  
+  func f() {}
+}
+
+protocol P : Sendable {
+  init()
+}
+
+func g<T>(_ f: @escaping @Sendable (T) -> (@Sendable () -> Void)) where T: P {
+  Task {
+    let instance = T()
+    f(instance)()
+  }
+}
+
+final class InferredSendableC: P {
+  func f() { }
+}
+
+struct InferredSendableS: P {
+  func f() { }
+}
+
+enum InferredSendableE: P {
+  case a, b
+  
+  func f() { }
+}
+
+struct GenericS<T>: P {
+  func f() { }
+}
+
+final class GenericC<T>: P {
+  func f() { }
+}
+
+// Conditional Conformances
+extension GenericS : Sendable where T : Sendable { }
+extension GenericC : Sendable where T : Sendable { }
+
+class NonSendable {
+  func f() {}
+}
+
+extension E {
+  init(){
+    self = .a
+  }
+  
+}
+
+extension InferredSendableE {
+  init(){
+    self = .a
+  }
+}
+
+// Unapplied Func Parameter
+g(InferredSendableS.f)
+g(InferredSendableC.f)
+g(InferredSendableE.f)
+
+g(GenericS<Int>.f)
+g(GenericC<Int>.f)
+
+g(GenericS<NonSendable>.f)
+g(GenericC<NonSendable>.f)
+
+func executeAsTask (_ f: @escaping  @Sendable () -> Void) {
+  Task {
+    f()
+  }
+}
+
+// Partial Apply Parameter
+executeAsTask(C().f)
+executeAsTask(S().f)
+executeAsTask(E().f)
+
+// Declarations
+let us:  @Sendable (GenericS<Int>) -> (@Sendable () -> Void) = GenericS<Int>.f
+let uc:  @Sendable (GenericC<Int>) -> (@Sendable () -> Void) = GenericC<Int>.f
+
+let unappliedStruct:  @Sendable (S) -> (@Sendable () -> Void) = S.f
+let unappliedClass:  @Sendable (C) -> (@Sendable () -> Void) = C.f
+let unappliedEnum:  @Sendable (E) -> (@Sendable () -> Void) = E.f
+
+var partialStruct : @Sendable () -> Void = S().f
+var partialClass : @Sendable () -> Void = C().f
+var partialEnum : @Sendable () -> Void = E().f
+
+// Reassign
+partialClass = NonSendable().f
+partialStruct = NonSendable().f
+partialEnum = NonSendable().f
+
+// Static Functions 
+struct World {
+  static func greet () { print("hello") }
+}
+
+let helloworld:  @Sendable () -> Void = World.greet