[Concurrency] Assume non-escaping closures don't run concurrently.

Non-escaping closures are assumed to run non-concurrently, so don't
complain about accesses to actor-isolated state on self within them.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -483,12 +483,32 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
     /// concurrently with code in the definition context.
     bool mayExecuteConcurrentlyWith(
         const DeclContext *useContext, const DeclContext *defContext) {
-      // If it's the same context, it won't execute concurrently.
-      if (useContext == defContext)
-        return false;
 
-      // Assume all child contexts can execute concurrently.
-      return true;
+      // 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 (auto closure = dyn_cast<AbstractClosureExpr>(useContext)) {
+          if (auto type = closure->getType()) {
+            if (auto fnType = type->getAs<AnyFunctionType>())
+              if (!fnType->isNoEscape())
+                return true;
+          }
+        }
+
+        // If we find a local function, it can escape and be run concurrently.
+        if (auto func = dyn_cast<AbstractFunctionDecl>(useContext)) {
+          if (func->isLocalCapture())
+            return true;
+        }
+
+        // If we hit a module-scope context, it's not concurrent.
+        useContext = useContext->getParent();
+        if (useContext->isModuleScopeContext())
+          return false;
+      }
+
+      // We hit the same context, so it won't execute concurrently.
+      return false;
     }
 
     // Retrieve the nearest enclosing actor context.

test/Concurrency/actor_isolation.swift

@@ -23,12 +23,12 @@ actor class MySuperActor {
 
 actor class MyActor: MySuperActor {
   let immutable: Int = 17
-  var text: [String] = [] // expected-note 4{{mutable state is only available within the actor instance}}
+  var text: [String] = [] // expected-note 5{{mutable state is only available within the actor instance}}
 
   class func synchronousClass() { }
   static func synchronousStatic() { }
 
-  func synchronous() -> String { text.first ?? "nothing" } // expected-note 4{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func synchronous() -> String { text.first ?? "nothing" } // expected-note 5{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
   func asynchronous() async -> String { synchronous() }
 }
 
@@ -71,20 +71,41 @@ extension MyActor {
 
     // Closures.
     let localConstant = 17
-    var localVar = 17 // expected-note 2{{var declared here}}
+    var localVar = 17 // expected-note 3{{var declared here}}
+
+    // Non-escaping closures are okay.
     acceptClosure {
-      _ = text[0] // expected-error{{actor-isolated property 'text' is unsafe to reference in code that may execute concurrently}}
+      _ = text[0]
+      _ = self.synchronous()
+      _ = localVar
+      _ = 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}}
       _ = 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
     }
 
-    acceptEscapingClosure {
+    // Local functions might run concurrently.
+    func localFn1() {
       _ = 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
     }
+
+    func localFn2() {
+      acceptClosure {
+        _ = 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
+      }
+    }
+
     localVar = 0
   }
 }