[Concurrency] Teach data race & isolation checking about @Concurrent functions.

@Concurrent functions are, of course, concurrent. Treat them that way.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -653,6 +653,16 @@ static bool isEscapingClosure(const AbstractClosureExpr *closure) {
   return true;
 }
 
+/// Determine whether this closure is escaping.
+static bool isConcurrentClosure(const AbstractClosureExpr *closure) {
+  if (auto type = closure->getType()) {
+    if (auto fnType = type->getAs<AnyFunctionType>())
+      return fnType->isConcurrent();
+  }
+
+  return false;
+}
+
 namespace {
   /// Check whether a particular context may execute concurrently within
   /// another context.
@@ -1370,8 +1380,8 @@ namespace {
     /// isolation checked.
     ClosureActorIsolation determineClosureIsolation(
         AbstractClosureExpr *closure) {
-      // An escaping closure is always actor-independent.
-      if (isEscapingClosure(closure))
+      // Escaping and concurrent closures are always actor-independent.
+      if (isEscapingClosure(closure) || isConcurrentClosure(closure))
         return ClosureActorIsolation::forIndependent();
 
       // A non-escaping closure gets its isolation from its context.
@@ -1565,9 +1575,11 @@ bool ConcurrentExecutionChecker::mayExecuteConcurrentlyWith(
     const DeclContext *useContext, const DeclContext *defContext) {
   // Walk the context chain from the use to the definition.
   while (useContext != defContext) {
-    // If we find an escaping closure, it can be run concurrently.
+    // If we find a concurrent closure... it can be run concurrently.
+    // NOTE: We also classify escaping closures this way, which detects more
+    // problematic cases.
     if (auto closure = dyn_cast<AbstractClosureExpr>(useContext)) {
-      if (isEscapingClosure(closure))
+      if (isEscapingClosure(closure) || isConcurrentClosure(closure))
         return true;
     }
 

test/Concurrency/actor_isolation.swift

@@ -6,6 +6,7 @@ var mutableGlobal: String = "can't touch this" // expected-note 3{{var declared
 
 func globalFunc() { }
 func acceptClosure<T>(_: () -> T) { }
+func acceptConcurrentClosure<T>(_: @concurrent () -> T) { }
 func acceptEscapingClosure<T>(_: @escaping () -> T) { }
 func acceptEscapingClosure<T>(_: (String) -> ()) async -> T? { nil }
 
@@ -29,12 +30,12 @@ actor class MySuperActor {
 
 actor class MyActor: MySuperActor {
   let immutable: Int = 17
-  var text: [String] = [] // expected-note 9{{mutable state is only available within the actor instance}}
+  var text: [String] = [] // expected-note 10{{mutable state is only available within the actor instance}}
 
   class func synchronousClass() { }
   static func synchronousStatic() { }
 
-  func synchronous() -> String { text.first ?? "nothing" } // expected-note 20{{calls to instance method 'synchronous()' from outside of its actor context are implicitly asynchronous}}
+  func synchronous() -> String { text.first ?? "nothing" } // expected-note 21{{calls to instance method 'synchronous()' from outside of its actor context are implicitly asynchronous}}
   func asynchronous() async -> String { synchronous() }
 }
 
@@ -127,7 +128,7 @@ extension MyActor {
 
     // Closures.
     let localConstant = 17
-    var localVar = 17 // expected-note 3{{var declared here}}
+    var localVar = 17 // expected-note 4{{var declared here}}
 
     // Non-escaping closures are okay.
     acceptClosure {
@@ -137,6 +138,14 @@ extension MyActor {
       _ = localConstant
     }
 
+    // Concurrent closures might run... concurrently.
+    acceptConcurrentClosure {
+      _ = self.text[0] // expected-error{{actor-isolated property 'text' is unsafe to reference in code that may execute concurrently}}
+      _ = self.synchronous() // expected-error{{actor-isolated instance method 'synchronous()' is unsafe to reference in code that may execute concurrently}}
+      _ = localVar // expected-warning{{local var 'localVar' is unsafe to reference in code that may execute concurrently}}
+      _ = localConstant
+    }
+
     // Escaping closures might run concurrently.
     acceptEscapingClosure {
       _ = self.text[0] // expected-error{{actor-isolated property 'text' is unsafe to reference in code that may execute concurrently}}