Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

lib/Sema/ConstraintSystem.cpp

@@ -1414,11 +1414,6 @@ FunctionType::ExtInfo ClosureEffectsRequest::evaluate(
   bool async = expr->getAsyncLoc().isValid();
   bool sendable = expr->getAttrs().hasAttribute<SendableAttr>();
 
-  // `@concurrent` attribute is only valid on asynchronous function types.
-  if (expr->getAttrs().hasAttribute<ConcurrentAttr>()) {
-    async = true;
-  }
-
   if (throws || async) {
     return ASTExtInfoBuilder()
       .withThrows(throws, /*FIXME:*/Type())
@@ -1432,11 +1427,17 @@ FunctionType::ExtInfo ClosureEffectsRequest::evaluate(
   if (!body)
     return ASTExtInfoBuilder().withSendable(sendable).build();
 
+  // `@concurrent` attribute is only valid on asynchronous function types.
+  bool asyncFromAttr = false;
+  if (expr->getAttrs().hasAttribute<ConcurrentAttr>()) {
+    asyncFromAttr = true;
+  }
+
   auto throwFinder = FindInnerThrows(expr);
   body->walk(throwFinder);
   return ASTExtInfoBuilder()
       .withThrows(throwFinder.foundThrow(), /*FIXME:*/Type())
-      .withAsync(bool(findAsyncNode(expr)))
+      .withAsync(asyncFromAttr || bool(findAsyncNode(expr)))
       .withSendable(sendable)
       .build();
 }

lib/Sema/TypeCheckConcurrency.cpp

@@ -4781,13 +4781,18 @@ ActorIsolation ActorIsolationChecker::determineClosureIsolation(
 
     case ActorIsolation::ActorInstance: {
       if (checkIsolatedCapture) {
+        if (auto param = closure->getCaptureInfo().getIsolatedParamCapture())
+          return ActorIsolation::forActorInstanceCapture(param);
+
         auto *explicitClosure = dyn_cast<ClosureExpr>(closure);
         // @_inheritActorContext(always) forces the isolation capture.
-        if (explicitClosure && explicitClosure->alwaysInheritsActorContext())
+        if (explicitClosure && explicitClosure->alwaysInheritsActorContext()) {
+          if (parentIsolation.isActorInstanceIsolated()) {
+            if (auto *param = parentIsolation.getActorInstance())
+              return ActorIsolation::forActorInstanceCapture(param);
+          }
           return parentIsolation;
-
-        if (auto param = closure->getCaptureInfo().getIsolatedParamCapture())
-          return ActorIsolation::forActorInstanceCapture(param);
+        }
       } else {
         // If we don't have capture information during code completion, assume
         // that the closure captures the `isolated` parameter from the parent

test/SILGen/hop_to_executor.swift

@@ -325,6 +325,7 @@ func testGlobalActorFuncValue(_ fn: @RedActor () -> Void) async {
 
 func acceptAsyncSendableClosureInheriting<T>(@_inheritActorContext _: @Sendable () async -> T) { }
 func acceptAsyncSendableClosureAlwaysInheriting<T>(@_inheritActorContext(always) _: @Sendable () async -> T) { }
+func acceptAsyncSendableClosureAlwaysInheritingErased<T>(@_inheritActorContext(always) _: sending @isolated(any) () async -> T) { }
 
 extension MyActor {
   func synchronous() { }
@@ -385,6 +386,22 @@ func testIsolatedParameterWithInheritActorContext(_ isolation: isolated (any Act
   }
 }
 
+// CHECK-LABEL: sil hidden [ossa] @$s4test0a17IsolatedParamWithB3AnyyyScA_pYiF
+// CHECK: [[CLOSURE_REF:%.*]] = function_ref @$s4test0a17IsolatedParamWithB3AnyyyScA_pYiFyyYaXEfU_
+// CHECK-NEXT: [[ISOLATION_COPY_1:%.*]] = copy_value %0 : $any Actor
+// CHECK-NEXT: [[ISOLATION_COPY_2:%.*]] = copy_value [[ISOLATION_COPY_1]] : $any Actor
+// CHECK-NEXT: [[DYNAMIC_ISOLATION:%.*]] = enum $Optional<any Actor>, #Optional.some!enumelt, [[ISOLATION_COPY_2]] : $any Actor
+// CHECK-NEXT: [[CLOSURE_WITH_APPLIED_ISOLATION:%.*]] = partial_apply [callee_guaranteed] [isolated_any] [[CLOSURE_REF]]([[DYNAMIC_ISOLATION]], [[ISOLATION_COPY_1]])
+func testIsolatedParamWithIsolatedAny(_ isolation: isolated any Actor) {
+  // CHECK-LABEL: sil private [ossa] @$s4test0a17IsolatedParamWithB3AnyyyScA_pYiFyyYaXEfU_
+  // CHECK: bb0(%0 : $*(), [[DYNAMIC_ISOLATION:%[0-9]+]] : @guaranteed $Optional<any Actor>, [[CAPTURED_ISOLATION:%[0-9]+]] : @closureCapture @guaranteed $any Actor):
+  // CHECK: [[COPY:%[0-9]+]] = copy_value [[CAPTURED_ISOLATION]] : $any Actor
+  // CHECK-NEXT: [[BORROW:%[0-9]+]] = begin_borrow [[COPY]] : $any Actor
+  // CHECK-NEXT: hop_to_executor [[BORROW]] : $any Actor
+  acceptAsyncSendableClosureAlwaysInheritingErased {
+  }
+}
+
 func acceptAsyncClosure(_: () async -> Void) { }
 func acceptAsyncClosure2<T>(_: (T) async -> T) { }
 

test/attr/execution_behavior_attrs.swift

@@ -137,3 +137,24 @@ _ = { @MainActor @concurrent in
 _ = { @concurrent () -> Int in
   // expected-error@-1 {{@concurrent on non-async closure}}
 }
+
+// Make sure that explicit use of `@concurrent` doesn't interfere with inference of `throws` from the body.
+do {
+    func acceptsThrowing(_ body: () async throws -> Void) async {
+    }
+
+  struct Invocation {
+    func throwingFn() async throws {
+    }
+  }
+
+  func test(invocation: Invocation) async {
+    await acceptsThrowing({ @concurrent in try await invocation.throwingFn() }) // Ok
+    await acceptsThrowing({ @concurrent [invocation] in try await invocation.throwingFn() }) // Ok
+
+    await acceptsThrowing({ @concurrent in // Ok
+      _ = 42
+      try await invocation.throwingFn()
+    })
+  }
+}