[Sema]: ban @isolated(any) conversions to synchronous function types

Author: jamieQ

include/swift/AST/DiagnosticsSema.def

@@ -5023,6 +5023,9 @@ NOTE(add_explicit_escaping,none,
      "add explicit @escaping to function parameter #%0",
      (unsigned))
 
+ERROR(converting_func_loses_isolation,none,
+      "converting function value of type %0 to %1 loses isolation",
+      (Type, Type))
 ERROR(converting_func_loses_global_actor,none,
       "converting function value of type %0 to %1 loses global actor %2",
       (Type, Type, Type))

lib/Sema/CSSimplify.cpp

@@ -2985,6 +2985,10 @@ ConstraintSystem::matchFunctionIsolations(FunctionType *func1,
     case FunctionTypeIsolation::Kind::Erased:
       return matchIfConversion();
 
+      // TODO: should this be handled here?
+      //    case FunctionTypeIsolation::Kind::Erased:
+      //      return func2->isAsync() && matchIfConversion();
+
     // Parameter isolation is value-dependent and cannot be erased.
     case FunctionTypeIsolation::Kind::Parameter:
       return false;

lib/Sema/TypeCheckConcurrency.cpp

@@ -2711,6 +2711,14 @@ namespace {
           if (!fromFnType->isSendable())
             return;
 
+          // @isolated(any) cannot be converted to a synchronous function type
+          if (fromIsolation.isErased() && !toFnType->isAsync()) {
+            ctx.Diags.diagnose(funcConv->getLoc(),
+                               diag::converting_func_loses_isolation,
+                               fromFnType, toFnType);
+            return;
+          }
+
           switch (toIsolation.getKind()) {
           // Converting to `@execution(caller)` function type
           case FunctionTypeIsolation::Kind::NonIsolatedCaller: {

test/Concurrency/isolated_any.swift

@@ -64,11 +64,17 @@ func testEraseFromIsolatedArgument() {
   requireIsolatedAnyWithActorArgument(hasIsolatedArgument)
 }
 
-func requireSendableNonIsolated(_ fn: @Sendable () -> ()) {}
+func requireSendableNonIsolated(_ fn: @Sendable () async -> ()) {}
 func testConvertIsolatedAnyToNonIsolated(fn: @Sendable @isolated(any) () -> ()) {
   requireSendableNonIsolated(fn)
 }
 
+func requireSendableNonIsolated_sync(_ fn: @Sendable () -> ()) {}
+func testConvertIsolatedAnyToNonIsolated_sync(fn: @Sendable @isolated(any) () -> ()) {
+  // expected-error @+1 {{converting function value of type '@isolated(any) @Sendable () -> ()' to '@Sendable () -> ()' loses isolation}}
+  requireSendableNonIsolated_sync(fn)
+}
+
 func requireSendableGlobalActor(_ fn: @Sendable @MainActor () -> ()) {}
 func testConvertIsolatedAnyToMainActor(fn: @Sendable @isolated(any) () -> ()) {
   // expected-error @+1 {{cannot convert value of type '@isolated(any) @Sendable () -> ()' to expected argument type '@MainActor @Sendable () -> ()'}}