Diagnose unsafe global variable accesses within concurrent closures/functions.

Concurrent closures and functions are, of course... concurrent. Treat
them as such for the warnings about unsafe accesses to global variables.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -2025,18 +2025,21 @@ void swift::checkOverrideActorIsolation(ValueDecl *value) {
 static bool shouldDiagnoseExistingDataRaces(const DeclContext *dc) {
   while (!dc->isModuleScopeContext()) {
     if (auto closure = dyn_cast<AbstractClosureExpr>(dc)) {
-      // Async closures use concurrency features.
-      if (closure->getType() && closure->isBodyAsync())
-        return true;
+      // Async and concurrent closures use concurrency features.
+      if (auto closureType = closure->getType()) {
+        if (auto fnType = closureType->getAs<AnyFunctionType>())
+          if (fnType->isAsync() || fnType->isConcurrent())
+            return true;
+      }
     } else if (auto decl = dc->getAsDecl()) {
       // If any isolation attributes are present, we're using concurrency
       // features.
       if (getIsolationFromAttributes(decl, /*shouldDiagnose=*/false))
         return true;
 
       if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
-        // Async functions use concurrency features.
-        if (func->hasAsync())
+        // Async and concurrent functions use concurrency features.
+        if (func->hasAsync() || func->isConcurrent())
           return true;
 
         // If there is an explicit @asyncHandler, we're using concurrency

test/Concurrency/actor_isolation.swift

@@ -2,7 +2,7 @@
 // REQUIRES: concurrency
 
 let immutableGlobal: String = "hello"
-var mutableGlobal: String = "can't touch this" // expected-note 3{{var declared here}}
+var mutableGlobal: String = "can't touch this" // expected-note 5{{var declared here}}
 
 func globalFunc() { }
 func acceptClosure<T>(_: () -> T) { }
@@ -334,6 +334,16 @@ func testGlobalRestrictions(actor: MyActor) async {
   print(i)
 }
 
+func f() {
+  acceptConcurrentClosure {
+    _ = mutableGlobal // expected-warning{{reference to var 'mutableGlobal' is not concurrency-safe because it involves shared mutable state}}
+  }
+
+  @concurrent func g() {
+    _ = mutableGlobal // expected-warning{{reference to var 'mutableGlobal' is not concurrency-safe because it involves shared mutable state}}
+  }
+}
+
 // ----------------------------------------------------------------------
 // Local function isolation restrictions
 // ----------------------------------------------------------------------