Synchronous closures can have global actors as part of their type

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4502,9 +4502,6 @@ ERROR(global_actor_non_unsafe_init,none,
 ERROR(actor_isolation_multiple_attr,none,
       "%0 %1 has multiple actor-isolation attributes ('%2' and '%3')",
       (DescriptiveDeclKind, DeclName, StringRef, StringRef))
-ERROR(global_actor_isolated_synchronous_closure,none,
-      "closure isolated to global actor %0 must be 'async'",
-      (Type))
 ERROR(actor_isolation_override_mismatch,none,
       "%0 %1 %2 has different actor isolation from %3 overridden declaration",
       (ActorIsolation, DescriptiveDeclKind, DeclName, ActorIsolation))

lib/Sema/CSGen.cpp

@@ -13,6 +13,7 @@
 // This file implements constraint generation for the type checker.
 //
 //===----------------------------------------------------------------------===//
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckType.h"
 #include "TypeChecker.h"
 #include "swift/AST/ASTVisitor.h"
@@ -2045,6 +2046,11 @@ namespace {
                                                           : TVO_CanBindToHole));
       }();
 
+      // For a non-async function type, add the global actor if present.
+      if (!extInfo.isAsync()) {
+        extInfo = extInfo.withGlobalActor(getExplicitGlobalActor(closure));
+      }
+
       return FunctionType::get(closureParams, resultTy, extInfo);
     }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -551,6 +551,25 @@ GlobalActorAttributeRequest::evaluate(
   return result;
 }
 
+Type swift::getExplicitGlobalActor(ClosureExpr *closure) {
+  // Look at the explicit attribute.
+  auto globalActorAttr = evaluateOrDefault(
+      closure->getASTContext().evaluator,
+      GlobalActorAttributeRequest{closure}, None);
+  if (!globalActorAttr)
+    return Type();
+
+  Type globalActor = evaluateOrDefault(
+      closure->getASTContext().evaluator,
+      CustomAttrTypeRequest{
+        globalActorAttr->first, closure, CustomAttrTypeKind::GlobalActor},
+        Type());
+  if (!globalActor || globalActor->hasError())
+    return Type();
+
+  return globalActor;
+}
+
 /// Determine the isolation rules for a given declaration.
 ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
     ConcreteDeclRef declRef) {
@@ -2176,34 +2195,16 @@ namespace {
 
     // Attempt to resolve the global actor type of a closure.
     Type resolveGlobalActorType(ClosureExpr *closure) {
-      auto globalActorAttr = evaluateOrDefault(
-          ctx.evaluator, GlobalActorAttributeRequest{closure}, None);
-      if (!globalActorAttr)
-        return Type();
-
-      Type globalActor = evaluateOrDefault(
-          ctx.evaluator,
-          CustomAttrTypeRequest{
-            globalActorAttr->first, closure, CustomAttrTypeKind::GlobalActor},
-            Type());
-      if (!globalActor || globalActor->hasError())
-        return Type();
-
-      // Actor-isolated closures must be async.
-      bool isAsync = false;
+      // Check whether the closure's type has a global actor already.
       if (Type closureType = closure->getType()) {
-        if (auto closureFnType = closureType->getAs<FunctionType>())
-          isAsync = closureFnType->isAsync();
-      }
-
-      if (!isAsync) {
-        ctx.Diags.diagnose(
-            closure->getLoc(), diag::global_actor_isolated_synchronous_closure,
-            globalActor);
-        return Type();
+        if (auto closureFnType = closureType->getAs<FunctionType>()) {
+          if (Type globalActor = closureFnType->getGlobalActor())
+            return globalActor;
+        }
       }
 
-      return globalActor;
+      // Look for an explicit attribute.
+      return getExplicitGlobalActor(closure);
     }
 
     /// Determine the isolation of a particular closure.

lib/Sema/TypeCheckConcurrency.h

@@ -28,6 +28,7 @@ class ActorIsolation;
 class AnyFunctionType;
 class ASTContext;
 class ClassDecl;
+class ClosureExpr;
 class ConcreteDeclRef;
 class CustomAttr;
 class Decl;
@@ -223,6 +224,9 @@ Optional<std::pair<CustomAttr *, NominalTypeDecl *>>
 checkGlobalActorAttributes(
     SourceLoc loc, DeclContext *dc, ArrayRef<CustomAttr *> attrs);
 
+/// Get the explicit global actor specified for a closure.
+Type getExplicitGlobalActor(ClosureExpr *closure);
+
 /// Check the correctness of the given ConcurrentValue conformance.
 ///
 /// \returns true if an error occurred.

lib/Sema/TypeCheckType.cpp

@@ -2100,12 +2100,7 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
           attrs.getCustomAttrs().begin(), attrs.getCustomAttrs().end()));
     if (foundGlobalActor) {
       globalActorAttr = foundGlobalActor->first;
-      globalActor = evaluateOrDefault(
-          getASTContext().evaluator,
-          CustomAttrTypeRequest{
-        foundGlobalActor->first, getDeclContext(),
-            CustomAttrTypeKind::GlobalActor},
-          Type());
+      globalActor = resolveType(globalActorAttr->getTypeRepr(), options);
       if (globalActor->hasError())
         globalActor = Type();
     }

test/Concurrency/actor_isolation.swift

@@ -372,7 +372,7 @@ func testGlobalActorClosures() {
     return 17
   }
 
-  acceptConcurrentClosure { @SomeGlobalActor in 5 } // expected-error{{closure isolated to global actor 'SomeGlobalActor' must be 'async'}}
+  acceptConcurrentClosure { @SomeGlobalActor in 5 } // expected-error{{converting function value of type '@SomeGlobalActor @concurrent () -> Int' to '@concurrent () -> Int' loses global actor 'SomeGlobalActor'}}
 }
 
 extension MyActor {

test/Concurrency/global_actor_function_types.swift

@@ -22,3 +22,28 @@ func testConversions(f: @escaping @SomeGlobalActor (Int) -> Void, g: @escaping (
   // FIXME: this could be better.
   let _: @OtherGlobalActor (Int) -> Void = f // expected-error{{cannot convert value of type 'SomeGlobalActor' to specified type 'OtherGlobalActor'}}
 }
+
+@SomeGlobalActor func onSomeGlobalActor() -> Int { 5 }
+
+func someSlowOperation() async -> Int { 5 }
+
+func acceptOnSomeGlobalActor<T>(_: @SomeGlobalActor () -> T) { }
+
+func testClosures() {
+  // Global actors on synchronous closures become part of the type
+  let cl1 = { @SomeGlobalActor in
+    onSomeGlobalActor()
+  }
+  let _: Double = cl1 // expected-error{{cannot convert value of type '@SomeGlobalActor () -> Int' to specified type 'Double'}}
+
+  // Global actors on async closures do not become part of the type
+  let cl2 = { @SomeGlobalActor in
+    await someSlowOperation()
+  }
+  let _: Double = cl2 // expected-error{{cannot convert value of type '() async -> Int' to specified type 'Double'}}
+
+  // okay to be explicit
+  acceptOnSomeGlobalActor { @SomeGlobalActor in
+    onSomeGlobalActor()
+  }
+}