[Sema] Global funcs should always be Sendable

Global funcs should be Sendable by default because they don't
capture anything.

Author: angela-laar

lib/Sema/CSSimplify.cpp

@@ -9521,7 +9521,7 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
 
   // Delay solving member constraint for unapplied methods
   // where the base type has a conditional Sendable conformance
-  if (functionRefKind == FunctionRefKind::Unapplied){
+  if (functionRefKind == FunctionRefKind::Unapplied) {
     auto sendableProtocol = DC->getParentModule()->getASTContext().getProtocol(KnownProtocolKind::Sendable);
     auto baseSendable = swift::TypeChecker::conformsToProtocol(instanceTy, sendableProtocol, DC->getParentModule());
 

lib/Sema/ConstraintSystem.cpp

@@ -1160,7 +1160,6 @@ FunctionType *ConstraintSystem::openFunctionType(
        DeclContext *outerDC) {
   if (auto *genericFn = funcType->getAs<GenericFunctionType>()) {
     auto signature = genericFn->getGenericSignature();
-    //TO-DO Maybe update here
     openGenericParameters(outerDC, signature, replacements, locator);
 
     openGenericRequirements(outerDC, signature,
@@ -1672,7 +1671,6 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
 
     OpenedTypeMap replacements;
 
-    // TO-DO check for sendable here and update type
     AnyFunctionType *funcType = func->getInterfaceType()
         ->castTo<AnyFunctionType>();
     auto openedType = openFunctionType(
@@ -1712,8 +1710,6 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     auto numLabelsToRemove = getNumRemovedArgumentLabels(
         funcDecl, /*isCurriedInstanceReference=*/false, functionRefKind);
 
-    //funcType = funcType->withExtInfo(functy->getExtInfo().withConcurrent())->castTo<AnyFunctionType>();
-
     auto openedType = openFunctionType(funcType, locator, replacements,
                                        funcDecl->getDeclContext())
                           ->removeArgumentLabels(numLabelsToRemove);
@@ -2628,13 +2624,14 @@ ConstraintSystem::getTypeOfMemberReference(
     functionType = unwrapPropertyWrapperParameterTypes(*this, funcDecl, functionRefKind,
                                                        functionType, locator);
     auto sendableProtocol = useDC->getParentModule()->getASTContext().getProtocol(KnownProtocolKind::Sendable);
-    // FIXME: Handle conditional conformances
     auto baseSendable = TypeChecker::conformsToProtocol( baseOpenedTy, sendableProtocol, useDC->getParentModule());
-    
+
     if (isSendableType(useDC->getParentModule(), baseOpenedTy)) {
       if (baseSendable.getConditionalRequirements().empty())
+        //Functions w/o conditional conformances should be marked @Sendable
         functionType = functionType->withExtInfo(functionType->getExtInfo().withConcurrent())->getAs<FunctionType>();
 
+      // Handle Conditional Conformances
       for (auto req : baseSendable.getConditionalRequirements()){
         if(!TypeChecker::conformsToProtocol( req.getFirstType(), sendableProtocol, useDC->getParentModule()).isInvalid()){
           functionType = functionType->withExtInfo(functionType->getExtInfo().withConcurrent())->getAs<FunctionType>();
@@ -2646,6 +2643,12 @@ ConstraintSystem::getTypeOfMemberReference(
     FunctionType::ExtInfo info;
     openedType =
         FunctionType::get(fullFunctionType->getParams(), functionType, info);
+
+    if (isSendableType(useDC->getParentModule(), baseOpenedTy)) {
+      // If this is actually a Sendable type, implicitly mark @Sendable
+      auto origFnType = openedType->castTo<FunctionType>();
+      openedType = origFnType->withExtInfo(origFnType->getExtInfo().withConcurrent());
+    }
   }
 
   // Adjust the opened type for concurrency.

lib/Sema/TypeCheckConcurrency.cpp

@@ -5480,6 +5480,15 @@ AnyFunctionType *swift::adjustFunctionTypeForConcurrency(
   // Apply unsafe concurrency features to the given function type.
   bool strictChecking = contextRequiresStrictConcurrencyChecking(
       dc, getType, isolatedByPreconcurrency);
+
+  auto func = dyn_cast_or_null<AbstractFunctionDecl>(decl);
+  auto doesNotCapture = func->getCaptureInfo().getCaptures().empty();
+
+  if (doesNotCapture) {
+    fnType = fnType->withExtInfo(fnType->getExtInfo().withConcurrent());
+    return fnType;
+  }
+
   fnType = applyUnsafeConcurrencyToFunctionType(
       fnType, decl, strictChecking, numApplies, isMainDispatchQueue);
 

test/Concurrency/sendable_functions.swift

@@ -46,12 +46,3 @@ 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

@@ -77,8 +77,10 @@ g(InferredSendableE.f)
 g(GenericS<Int>.f)
 g(GenericC<Int>.f)
 
-g(GenericS<NonSendable>.f)
-g(GenericC<NonSendable>.f)
+g(GenericS<NonSendable>.f) // expected-warning{{converting non-sendable function value to '@Sendable (GenericS<NonSendable>) -> (@Sendable () -> Void)' may introduce data races
+// expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races
+g(GenericC<NonSendable>.f) // expected-warning{{converting non-sendable function value to '@Sendable (GenericS<NonSendable>) -> (@Sendable () -> Void)' may introduce data races
+// expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races
 
 func executeAsTask (_ f: @escaping  @Sendable () -> Void) {
   Task {
@@ -90,6 +92,7 @@ func executeAsTask (_ f: @escaping  @Sendable () -> Void) {
 executeAsTask(C().f)
 executeAsTask(S().f)
 executeAsTask(E().f)
+executeAsTask(NonSendable().f) // expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races}}
 
 // Declarations
 let us:  @Sendable (GenericS<Int>) -> (@Sendable () -> Void) = GenericS<Int>.f
@@ -104,13 +107,31 @@ var partialClass : @Sendable () -> Void = C().f
 var partialEnum : @Sendable () -> Void = E().f
 
 // Reassign
-partialClass = NonSendable().f
-partialStruct = NonSendable().f
-partialEnum = NonSendable().f
+partialClass = NonSendable().f // expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races}}
+partialStruct = NonSendable().f // expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races}}
+partialEnum = NonSendable().f // expected-warning{{converting non-sendable function value to '@Sendable () -> Void' may introduce data races}}
 
 // Static Functions 
 struct World {
   static func greet () { print("hello") }
 }
 
 let helloworld:  @Sendable () -> Void = World.greet
+
+class NonSendableC {
+    var x: Int = 0
+
+    // TO-DO: Invalidate Sendable annotation in follow-up PR
+    @Sendable func inc() {
+        x += 1
+    }
+}
+
+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)