Add support for @actorIndependent on closures.

Closures often end up being implicitly actor-isolated. Allow them to opt
out with `@actorIndependent`, as as other declarations can opt out of
actor isolation.

Author: DougGregor

lib/Sema/TypeCheckAttr.cpp

@@ -5614,6 +5614,10 @@ class ClosureAttributeChecker
     // Nothing else to check.
   }
 
+  void visitActorIndependentAttr(ActorIndependentAttr *attr) {
+    // Nothing else to check.
+  }
+
   void visitCustomAttr(CustomAttr *attr) {
     // Check whether this custom attribute is the global actor attribute.
     auto globalActorAttr = evaluateOrDefault(

lib/Sema/TypeCheckConcurrency.cpp

@@ -1566,22 +1566,8 @@ namespace {
 
       auto dc = const_cast<DeclContext *>(constDC);
       while (!dc->isModuleScopeContext()) {
-        if (auto closure = dyn_cast<AbstractClosureExpr>(dc)) {
-          // If this closure has specific isolation, use it.
-          auto closureIsolation = getActorIsolationOfContext(dc);
-          if (closureIsolation != ActorIsolation::Independent)
-            return closureIsolation;
-
-          // Look through non-escaping closures.
-          if (auto type = closure->getType()) {
-            if (auto fnType = type->getAs<AnyFunctionType>()) {
-              if (fnType->isNoEscape()) {
-                dc = closure->getParent();
-                continue;
-              }
-            }
-          }
-        }
+        if (auto closure = dyn_cast<AbstractClosureExpr>(dc))
+          return getActorIsolationOfContext(dc);
 
         // Functions have actor isolation defined on them.
         if (auto func = dyn_cast<AbstractFunctionDecl>(dc))
@@ -2243,6 +2229,9 @@ namespace {
         AbstractClosureExpr *closure) {
       // If the closure specifies a global actor, use it.
       if (auto explicitClosure = dyn_cast<ClosureExpr>(closure)) {
+        if (explicitClosure->getAttrs().hasAttribute<ActorIndependentAttr>())
+          return ClosureActorIsolation::forIndependent();
+
         if (Type globalActorType = resolveGlobalActorType(explicitClosure))
           return ClosureActorIsolation::forGlobalActor(globalActorType);
       }

test/Concurrency/actor_inout_isolation.swift

@@ -196,7 +196,7 @@ struct MyGlobalActor {
 // expected-note@-3{{mutation of this var is only permitted within the actor}}
 
 // expected-error@+2{{actor-isolated var 'number' cannot be passed 'inout' to 'async' function call}}
-// expected-error@+1{{var 'number' isolated to global actor 'MyGlobalActor' can not be used 'inout' from this context}}
+// expected-error@+1{{var 'number' isolated to global actor 'MyGlobalActor' can not be used 'inout' from a non-isolated context}}
 let _ = Task.runDetached { await { (_ foo: inout Int) async in foo += 1 }(&number) }
 
 // attempt to pass global state owned by the global actor to another async function

test/Concurrency/closure_isolation.swift

@@ -45,6 +45,8 @@ struct SomeGlobalActor {
 
 func someAsyncFunc() async { }
 
+@SomeGlobalActor func getGlobal7() -> Int { 7 }
+
 // CHECK-LABEL: someGlobalActorFunc
 @SomeGlobalActor func someGlobalActorFunc() async {
   // CHECK: acceptAsyncClosure
@@ -66,5 +68,4 @@ func someAsyncFunc() async { }
   // CHECK: closure_expr
   // CHECK-NOT:actor-isolated
   acceptEscapingAsyncClosure { () async in print("hello") }
-
 }

test/Concurrency/global_actor_from_ordinary_context.swift

@@ -61,12 +61,12 @@ func callGlobalActor() {
 
 func fromClosure() {
   { () -> Void in
-    // expected-error@+1 {{global function 'syncGlobActorFn()' isolated to global actor 'SomeGlobalActor' can not be referenced from this context}}
+    // expected-error@+1 {{global function 'syncGlobActorFn()' isolated to global actor 'SomeGlobalActor' can not be referenced from a non-isolated context}}
     let x = syncGlobActorFn
     x()
   }()
 
-  // expected-error@+1 {{global function 'syncGlobActorFn()' isolated to global actor 'SomeGlobalActor' can not be referenced from this synchronous context}}
+  // expected-error@+1 {{global function 'syncGlobActorFn()' isolated to global actor 'SomeGlobalActor' can not be referenced from a non-isolated synchronous context}}
   let _ = { syncGlobActorFn() }()
 }
 

test/Concurrency/global_actor_inference.swift

@@ -426,3 +426,14 @@ struct HasWrapperOnUnsafeActor {
     synced = 17
   }
 }
+
+// ----------------------------------------------------------------------
+// Actor-independent closures
+// ----------------------------------------------------------------------
+@SomeGlobalActor func getGlobal7() -> Int { 7 } // expected-note{{calls to global function 'getGlobal7()' from outside of its actor context are implicitly asynchronous}}
+func acceptClosure<T>(_: () -> T) { }
+
+@SomeGlobalActor func someGlobalActorFunc() async {
+  acceptClosure { getGlobal7() } // okay
+  acceptClosure { @actorIndependent in getGlobal7() } // expected-error{{global function 'getGlobal7()' isolated to global actor 'SomeGlobalActor' can not be referenced from a non-isolated synchronous context}}
+}