Require that concurrently-executed local functions be @Concurrent.

Author: DougGregor

include/swift/AST/Decl.h

@@ -5734,6 +5734,11 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// type of the function will be `async` as well.
   bool hasAsync() const { return Bits.AbstractFunctionDecl.Async; }
 
+  /// Determine whether the given function is concurrent.
+  ///
+  /// A function is concurrent if it has the @concurrent attribute.
+  bool isConcurrent() const;
+
   /// Returns true if the function is a suitable 'async' context.
   ///
   /// Functions that are an 'async' context can make calls to 'async' functions.

include/swift/AST/DiagnosticsSema.def

@@ -4261,6 +4261,11 @@ ERROR(actor_isolated_concurrent_access,none,
         "actor-isolated %0 %1 is unsafe to reference in code "
         "that may execute concurrently",
         (DescriptiveDeclKind, DeclName))
+ERROR(local_function_executed_concurrently,none,
+      "concurrently-executed %0 %1 must be marked as '@concurrent'",
+      (DescriptiveDeclKind, DeclName))
+NOTE(concurrent_access_here,none,
+     "access in concurrently-executed code here", ())
 NOTE(actor_isolated_sync_func,none,
      "calls to %0 %1 from outside of its actor context are "
      "implicitly asynchronous",

lib/AST/Decl.cpp

@@ -6768,6 +6768,10 @@ bool AbstractFunctionDecl::argumentNameIsAPIByDefault() const {
   return false;
 }
 
+bool AbstractFunctionDecl::isConcurrent() const {
+  return getAttrs().hasAttribute<ConcurrentAttr>();
+}
+
 bool AbstractFunctionDecl::isAsyncHandler() const {
   auto func = dyn_cast<FuncDecl>(this);
   if (!func)

lib/Sema/TypeCheckConcurrency.cpp

@@ -1583,14 +1583,30 @@ bool ConcurrentExecutionChecker::mayExecuteConcurrentlyWith(
         return true;
     }
 
-    // If we find a local function that was referenced in code that can be
-    // executed concurrently with where the local function was declared, the
-    // local function can be run concurrently.
     if (auto func = dyn_cast<FuncDecl>(useContext)) {
       if (func->isLocalCapture()) {
+        // If the function is @concurrent... it can be run concurrently.
+        if (func->isConcurrent())
+          return true;
+
+        // If we find a local function that was referenced in code that can be
+        // executed concurrently with where the local function was declared, the
+        // local function can be run concurrently.
         SourceLoc concurrentLoc = getConcurrentReferenceLoc(func);
-        if (concurrentLoc.isValid())
+        if (concurrentLoc.isValid()) {
+          ASTContext &ctx = func->getASTContext();
+          func->diagnose(
+              diag::local_function_executed_concurrently,
+              func->getDescriptiveKind(), func->getName())
+            .fixItInsert(func->getAttributeInsertionLoc(false), "@concurrent ");
+          ctx.Diags.diagnose(concurrentLoc, diag::concurrent_access_here);
+
+          // Add the @concurrent attribute implicitly, so we don't diagnose
+          // again.
+          const_cast<FuncDecl *>(func)->getAttrs().add(
+              new (ctx) ConcurrentAttr(true));
           return true;
+        }
       }
     }
 

lib/Sema/TypeCheckDecl.cpp

@@ -2524,8 +2524,7 @@ InterfaceTypeRequest::evaluate(Evaluator &eval, ValueDecl *D) const {
       AFD->getParameters()->getParams(argTy);
 
       infoBuilder = infoBuilder.withAsync(AFD->hasAsync());
-      infoBuilder = infoBuilder.withConcurrent(
-          AFD->getAttrs().hasAttribute<ConcurrentAttr>());
+      infoBuilder = infoBuilder.withConcurrent(AFD->isConcurrent());
       // 'throws' only applies to the innermost function.
       infoBuilder = infoBuilder.withThrows(AFD->hasThrows());
       // Defer bodies must not escape.

test/Concurrency/actor_isolation.swift

@@ -8,7 +8,7 @@ func globalFunc() { }
 func acceptClosure<T>(_: () -> T) { }
 func acceptConcurrentClosure<T>(_: @concurrent () -> T) { }
 func acceptEscapingClosure<T>(_: @escaping () -> T) { }
-func acceptEscapingClosure<T>(_: (String) -> ()) async -> T? { nil }
+func acceptEscapingClosure<T>(_: @escaping (String) -> ()) async -> T? { nil }
 
 func acceptAsyncClosure<T>(_: () async -> T) { }
 func acceptEscapingAsyncClosure<T>(_: @escaping () async -> T) { }
@@ -155,14 +155,14 @@ extension MyActor {
     }
 
     // Local functions might run concurrently.
-    func localFn1() {
+    @concurrent 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() {
+    @concurrent 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}}
@@ -341,8 +341,9 @@ func checkLocalFunctions() async {
     i = 17
   }
 
-  func local2() {
+  func local2() { // expected-error{{concurrently-executed local function 'local2()' must be marked as '@concurrent'}}{{3-3=@concurrent }}
     j = 42 // expected-warning{{local var 'j' is unsafe to reference in code that may execute concurrently}}
+    // FIXME: the above should be an error as well
   }
 
   // Okay to call locally.
@@ -357,7 +358,7 @@ func checkLocalFunctions() async {
 
   // Escaping closures can make the local function execute concurrently.
   acceptEscapingClosure {
-    local2()
+    local2() // expected-note{{access in concurrently-executed code here}}
   }
 
   print(i)
@@ -366,11 +367,11 @@ func checkLocalFunctions() async {
   var k = 17 // expected-note{{var declared here}}
   func local4() {
     acceptEscapingClosure {
-      local3()
+      local3() // expected-note{{access in concurrently-executed code here}}
     }
   }
 
-  func local3() {
+  func local3() { // expected-error{{concurrently-executed local function 'local3()' must be marked as '@concurrent'}}
     k = 25 // expected-warning{{local var 'k' is unsafe to reference in code that may execute concurrently}}
   }