refactor and update tests per PR feedback

Author: jamieQ

include/swift/AST/DiagnosticsSema.def

@@ -5031,6 +5031,10 @@ ERROR(capture_across_type_decl,none,
       "scope",
       (const NominalTypeDecl *, const ValueDecl *))
 
+ERROR(isolated_any_conversion_to_synchronous_func,none,
+      "converting @isolated(any) function of type %0 to synchronous function type %1 is not allowed",
+      (Type, Type))
+
 ERROR(reference_to_invalid_decl,none,
       "cannot reference invalid declaration %0", (const ValueDecl *))
 

lib/Sema/CSSimplify.cpp

@@ -2943,11 +2943,6 @@ ConstraintSystem::matchFunctionIsolations(FunctionType *func1,
                                           ConstraintLocatorBuilder locator) {
   auto isolation1 = func1->getIsolation(), isolation2 = func2->getIsolation();
 
-  // An @isolated(any) function cannot be converted to a non-@isolated(any)
-  // synchronous function regardless of whether or not it is itself async.
-  if (isolation1.isErased() && !isolation2.isErased() && !func2->isAsync())
-    return false;
-
   // If we have a difference in isolation kind, we need a conversion.
   // Make sure that we're looking for a conversion, and increase the
   // function-conversion score to make sure this solution is worse than

lib/Sema/TypeCheckConcurrency.cpp

@@ -2703,6 +2703,18 @@ namespace {
             }
           }
 
+          // @isolated(any) functions (async or not) cannot be converted to
+          // non-@isolated(any) synchronous functions.
+          if (fromIsolation.isErased() && !toIsolation.isErased() &&
+              !toFnType->isAsync()) {
+            ctx.Diags
+                .diagnose(funcConv->getLoc(),
+                          diag::isolated_any_conversion_to_synchronous_func,
+                          fromFnType, toFnType)
+                .warnUntilSwiftVersion(7);
+            return;
+          }
+
           // Conversions from non-Sendable types are handled by
           // region-based isolation.
           // Function conversions are used to inject concurrency attributes

test/Concurrency/isolated_any.swift

@@ -71,10 +71,16 @@ func testConvertIsolatedAnyToNonIsolated(fn: @Sendable @isolated(any) () -> ())
 
 func requireSendableNonIsolated_sync(_ fn: @Sendable () -> ()) {}
 func testConvertIsolatedAnyToNonIsolated_sync(fn: @Sendable @isolated(any) () -> ()) {
-  // expected-error @+1 {{cannot convert value of type '@isolated(any) @Sendable () -> ()' to expected argument type '@Sendable () -> ()}}
+  // expected-warning @+1 {{converting @isolated(any) function of type '@isolated(any) @Sendable () -> ()' to synchronous function type '@Sendable () -> ()' is not allowed; this will be an error in a future Swift language mode}}
   requireSendableNonIsolated_sync(fn)
 }
 
+func requireNonSendableNonIsolated_sync(_ fn: () -> ()) {}
+func testConvertIsolatedAnyToNonSendableNonIsolated_sync(fn: @isolated(any) () -> ()) {
+  // expected-warning @+1 {{converting @isolated(any) function of type '@isolated(any) () -> ()' to synchronous function type '() -> ()' is not allowed; this will be an error in a future Swift language mode}}
+  requireNonSendableNonIsolated_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 () -> ()'}}
@@ -131,8 +137,22 @@ func testFunctionIsolationExprTuple(
   return (fn1?.isolation, fn2?.isolation)
 }
 
-func nonSendableIsolatedAny(
+func nonSendableIsolatedAnySyncToSendableSync(
   _ fn: @escaping @isolated(any) () -> Void // expected-note {{parameter 'fn' is implicitly non-sendable}}
 ) {
   let _: @Sendable () -> Void = fn  // expected-warning {{using non-sendable parameter 'fn' in a context expecting a @Sendable closure}}
+  // expected-warning @-1 {{converting @isolated(any) function of type '@isolated(any) () -> Void' to synchronous function type '@Sendable () -> Void' is not allowed; this will be an error in a future Swift language mode}}
+}
+
+func nonSendableIsolatedAnyAsyncToSendableSync(
+  _ fn: @escaping @isolated(any) () async -> Void // expected-note {{parameter 'fn' is implicitly non-sendable}}
+) {
+  let _: @Sendable () -> Void = fn  // expected-warning {{using non-sendable parameter 'fn' in a context expecting a @Sendable closure}}
+  // expected-error @-1 {{invalid conversion from 'async' function of type '@isolated(any) () async -> Void' to synchronous function type '@Sendable () -> Void'}}
+}
+
+func nonSendableIsolatedAnyAsyncToSendableAsync(
+  _ fn: @escaping @isolated(any) () async -> Void // expected-note {{parameter 'fn' is implicitly non-sendable}}
+) {
+  let _: @Sendable () async -> Void = fn  // expected-warning {{using non-sendable parameter 'fn' in a context expecting a @Sendable closure}}
 }