[Sema/SILGen] Import ObjC async functions as nonisolated(nonsending) by default

These functions already have special code generation that keeps them
in the caller's isolation context, so there is no behavior change here.

Resolves: rdar://145672343
(cherry picked from commit 07bad98)

Author: xedin

lib/SIL/IR/SILFunctionType.cpp

@@ -1706,8 +1706,12 @@ class DestructureInputs {
 
     // If we are an async function that is unspecified or nonisolated, insert an
     // isolated parameter if AsyncCallerExecution is enabled.
+    //
+    // NOTE: The parameter is not inserted for async functions imported
+    // from ObjC because they are handled in a special way that doesn't
+    // require it.
     if (IsolationInfo && IsolationInfo->isCallerIsolationInheriting() &&
-        extInfoBuilder.isAsync()) {
+        extInfoBuilder.isAsync() && !Foreign.async) {
       auto actorProtocol = TC.Context.getProtocol(KnownProtocolKind::Actor);
       auto actorType =
           ExistentialType::get(actorProtocol->getDeclaredInterfaceType());

lib/Sema/TypeCheckConcurrency.cpp

@@ -5852,6 +5852,18 @@ computeDefaultInferredActorIsolation(ValueDecl *value) {
                         // isolation for this decl.
   }
 
+  // Asynchronous variants for functions imported from ObjC are
+  // `nonisolated(nonsending)` by default.
+  if (value->hasClangNode()) {
+    if (auto *AFD = dyn_cast<AbstractFunctionDecl>(value)) {
+      if (!isa<ProtocolDecl>(AFD->getDeclContext()) &&
+          AFD->getForeignAsyncConvention()) {
+        return {
+            {ActorIsolation::forCallerIsolationInheriting(), {}}, nullptr, {}};
+      }
+    }
+  }
+
   // We did not find anything special, return unspecified.
   return {{ActorIsolation::forUnspecified(), {}}, nullptr, {}};
 }

test/Concurrency/attr_execution_objc.swift

@@ -0,0 +1,41 @@
+// RUN: %empty-directory(%t)
+// RUN: %empty-directory(%t/src)
+// RUN: split-file %s %t/src
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck %t/src/main.swift \
+// RUN:   -import-objc-header %t/src/Test.h \
+// RUN:   -swift-version 6 \
+// RUN:   -module-name main -I %t -verify
+
+// REQUIRES: objc_interop
+
+//--- Test.h
+#define MAIN_ACTOR __attribute__((__swift_attr__("@MainActor")))
+
+#pragma clang assume_nonnull begin
+
+@import Foundation;
+
+@interface Test : NSObject
+- (void)loadWithCompletionHandler:(void (^)(void)) completionHandler;
+@end
+
+MAIN_ACTOR
+@interface TestIsolated : NSObject
+- (void)loadWithCompletionHandler:(void (^)(void)) completionHandler;
+@end
+
+#pragma clang assume_nonnull end
+
+//--- main.swift
+
+func test(t: Test, i: TestIsolated) async throws {
+  let fn = t.load // nonisolated(nonsending) () async -> Void
+
+  let _: @isolated(any) () async -> Void = fn
+  // expected-error@-1 {{cannot convert value of type 'nonisolated(nonsending) () async -> Void' to specified type '@isolated(any) () async -> Void'}}
+
+  let isolatedFn = i.load
+  let _: () -> Void = isolatedFn
+  // expected-error@-1 {{invalid conversion from 'async' function of type '@MainActor @Sendable () async -> Void' to synchronous function type '() -> Void'}}
+}