[Concurrency] Allow isolated parameters to have optional type.

Author: hborla

include/swift/Basic/Features.def

@@ -254,6 +254,9 @@ EXPERIMENTAL_FEATURE(Extern, true)
 // global functions and key paths.
 EXPERIMENTAL_FEATURE(InferSendableFromCaptures, false)
 
+// Allow optional isolated parameters.
+EXPERIMENTAL_FEATURE(OptionalIsolatedParameters, true)
+
 /// Enable the `@_staticExclusiveOnly` attribute.
 EXPERIMENTAL_FEATURE(StaticExclusiveOnly, true)
 

lib/AST/ASTPrinter.cpp

@@ -3829,6 +3829,25 @@ static bool usesFeatureInferSendableFromCaptures(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureOptionalIsolatedParameters(Decl *decl) {
+  auto *value = dyn_cast<ValueDecl>(decl);
+  if (!value)
+    return false;
+
+  auto *paramList = getParameterList(value);
+  if (!paramList)
+    return false;
+
+  for (auto param : *paramList) {
+    if (param->isIsolated()) {
+      auto paramType = param->getInterfaceType();
+      return !paramType->getOptionalObjectType().isNull();
+    }
+  }
+
+  return false;
+}
+
 static bool usesFeaturePlaygroundExtendedCallbacks(Decl *decl) {
   return false;
 }

lib/Sema/TypeCheckConcurrency.cpp

@@ -3289,12 +3289,17 @@ namespace {
               KnownProtocolKind::Actor);
         }
 
-        unsatisfiedIsolation =
-            ActorIsolation::forActorInstanceParameter(nominal, paramIdx);
+        // FIXME: Also allow 'Optional.none'
+        if (dyn_cast<NilLiteralExpr>(arg->findOriginalValue())) {
+          mayExitToNonisolated = true;
+        } else {
+          unsatisfiedIsolation =
+              ActorIsolation::forActorInstanceParameter(nominal, paramIdx);
+          mayExitToNonisolated = false;
+        }
 
         if (!fnType->getExtInfo().isAsync())
           callOptions |= ActorReferenceResult::Flags::AsyncPromotion;
-        mayExitToNonisolated = false;
 
         break;
       }
@@ -4613,7 +4618,13 @@ ActorIsolation ActorIsolationRequest::evaluate(
       }
     }
 
-    if (auto actor = paramType->getAnyActor())
+    Type actorType;
+    if (auto wrapped = paramType->getOptionalObjectType()) {
+      actorType = wrapped;
+    } else {
+      actorType = paramType;
+    }
+    if (auto actor = actorType->getAnyActor())
       return ActorIsolation::forActorInstanceParameter(actor, *paramIdx);
   }
 

lib/Sema/TypeCheckType.cpp

@@ -4485,6 +4485,14 @@ TypeResolver::resolveIsolatedTypeRepr(IsolatedTypeRepr *repr,
 
   // isolated parameters must be of actor type
   if (!type->hasTypeParameter() && !type->isActorType() && !type->hasError()) {
+    // Optional actor types are fine - `nil` represents `nonisolated`.
+    auto wrapped = type->getOptionalObjectType();
+    auto allowOptional = getASTContext().LangOpts
+        .hasFeature(Feature::OptionalIsolatedParameters);
+    if (allowOptional && wrapped && wrapped->isActorType()) {
+      return type;
+    }
+
     diagnoseInvalid(
         repr, repr->getSpecifierLoc(), diag::isolated_parameter_not_actor, type);
     return ErrorType::get(type);

test/Concurrency/isolated_parameters.swift

@@ -1,5 +1,5 @@
-// RUN: %target-swift-frontend  -disable-availability-checking -strict-concurrency=complete %s -emit-sil -o /dev/null -verify -verify-additional-prefix complete-
-// RUN: %target-swift-frontend  -disable-availability-checking -strict-concurrency=complete %s -emit-sil -o /dev/null -verify -enable-experimental-feature RegionBasedIsolation
+// RUN: %target-swift-frontend  -disable-availability-checking -strict-concurrency=complete -enable-experimental-feature OptionalIsolatedParameters %s -emit-sil -o /dev/null -verify -verify-additional-prefix complete-
+// RUN: %target-swift-frontend  -disable-availability-checking -strict-concurrency=complete -enable-experimental-feature OptionalIsolatedParameters %s -emit-sil -o /dev/null -verify -enable-experimental-feature RegionBasedIsolation
 
 // REQUIRES: concurrency
 // REQUIRES: asserts
@@ -357,3 +357,41 @@ func isolated_generic_bad_3<T: AnyActor>(_ t: isolated T) {}
 // expected-error@-1 {{'isolated' parameter 'T' must conform to 'Actor' or 'DistributedActor' protocol}}
 
 func isolated_generic_ok_1<T: Actor>(_ t: isolated T) {}
+
+class NotSendable {} // expected-complete-note 5 {{class 'NotSendable' does not conform to the 'Sendable' protocol}}
+
+func optionalIsolated(_ ns: NotSendable, to actor: isolated (any Actor)?) async {}
+func optionalIsolatedSync(_ ns: NotSendable, to actor: isolated (any Actor)?) {}
+
+nonisolated func callFromNonisolated(ns: NotSendable) async {
+  await optionalIsolated(ns, to: nil)
+
+  optionalIsolatedSync(ns, to: nil)
+
+  let myActor = A()
+
+  await optionalIsolated(ns, to: myActor)
+  // expected-complete-warning@-1 {{passing argument of non-sendable type 'NotSendable' into actor-isolated context may introduce data races}}
+
+  optionalIsolatedSync(ns, to: myActor)
+  // expected-error@-1 {{expression is 'async' but is not marked with 'await'}}
+  // expected-note@-2 {{calls to global function 'optionalIsolatedSync(_:to:)' from outside of its actor context are implicitly asynchronous}}
+  // expected-complete-warning@-3 {{passing argument of non-sendable type 'NotSendable' into actor-isolated context may introduce data races}}
+}
+
+@MainActor func callFromMainActor(ns: NotSendable) async {
+  await optionalIsolated(ns, to: nil)
+  // expected-complete-warning@-1 {{passing argument of non-sendable type 'NotSendable' outside of main actor-isolated context may introduce data races}}
+
+  optionalIsolatedSync(ns, to: nil)
+
+  let myActor = A()
+
+  await optionalIsolated(ns, to: myActor)
+  // expected-complete-warning@-1 {{passing argument of non-sendable type 'NotSendable' into actor-isolated context may introduce data races}}
+
+  optionalIsolatedSync(ns, to: myActor)
+  // expected-error@-1 {{expression is 'async' but is not marked with 'await'}}
+  // expected-note@-2 {{calls to global function 'optionalIsolatedSync(_:to:)' from outside of its actor context are implicitly asynchronous}}
+  // expected-complete-warning@-3 {{passing argument of non-sendable type 'NotSendable' into actor-isolated context may introduce data races}}
+}