[Concurrency] Ban actor-isolated operations from being @objc.

Actor-isolated operations must not be directly accessible from anywhere
that is not already guaranteed to be running within the actor context.
Prevent such operations from being `@objc`, because that would allow
Objective-C code to violate actor isolation.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4101,6 +4101,9 @@ ERROR(not_objc_function_async,none,
       "'async' function cannot be represented in Objective-C", ())
 NOTE(not_objc_function_type_async,none,
       "'async' function types cannot be represented in Objective-C", ())
+ERROR(actor_isolated_objc,none,
+      "actor-isolated %0 %1 cannot be @objc",
+       (DescriptiveDeclKind, DeclName))
 NOTE(protocol_witness_async_conflict,none,
      "candidate is %select{not |}0'async', but protocol requirement is%select{| not}0",
      (bool))

lib/Sema/TypeCheckDeclObjC.cpp

@@ -16,6 +16,7 @@
 //===----------------------------------------------------------------------===//
 #include "TypeCheckObjC.h"
 #include "TypeChecker.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckProtocol.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
@@ -368,6 +369,32 @@ static bool checkObjCInForeignClassContext(const ValueDecl *VD,
   return true;
 }
 
+/// Actor-isolated declarations cannot be @objc.
+static bool checkObjCActorIsolation(const ValueDecl *VD,
+                                    ObjCReason Reason) {
+  // Check actor isolation.
+  bool Diagnose = shouldDiagnoseObjCReason(Reason, VD->getASTContext());
+
+  switch (getActorIsolation(const_cast<ValueDecl *>(VD))) {
+  case ActorIsolation::ActorInstance:
+    // Actor-isolated functions cannot be @objc.
+    if (Diagnose) {
+      VD->diagnose(
+          diag::actor_isolated_objc, VD->getDescriptiveKind(),  VD->getName());
+      describeObjCReason(VD, Reason);
+      if (auto FD = dyn_cast<FuncDecl>(VD)) {
+        addAsyncNotes(const_cast<FuncDecl *>(FD));
+      }
+    }
+    return true;
+
+  case ActorIsolation::ActorPrivileged:
+  case ActorIsolation::Independent:
+  case ActorIsolation::Unspecified:
+    return false;
+  }
+}
+
 static VersionRange getMinOSVersionForClassStubs(const llvm::Triple &target) {
   if (target.isMacOSX())
     return VersionRange::allGTE(llvm::VersionTuple(10, 15, 0));
@@ -512,6 +539,8 @@ bool swift::isRepresentableInObjC(
     return false;
   if (checkObjCInExtensionContext(AFD, Diagnose))
     return false;
+  if (checkObjCActorIsolation(AFD, Reason))
+    return false;
 
   if (AFD->isOperator()) {
     AFD->diagnose((isa<ProtocolDecl>(AFD->getDeclContext())
@@ -686,10 +715,12 @@ bool swift::isRepresentableInObjC(
     Type resultType = FD->mapTypeIntoContext(FD->getResultInterfaceType());
     if (auto tupleType = resultType->getAs<TupleType>()) {
       for (const auto &tupleElt : tupleType->getElements()) {
-        addCompletionHandlerParam(tupleElt.getType());
+        if (addCompletionHandlerParam(tupleElt.getType()))
+          return false;
       }
     } else {
-      addCompletionHandlerParam(resultType);
+      if (addCompletionHandlerParam(resultType))
+        return false;
     }
 
     // For a throwing asynchronous function, an Error? parameter is added
@@ -939,6 +970,8 @@ bool swift::isRepresentableInObjC(const VarDecl *VD, ObjCReason Reason) {
 
   if (checkObjCInForeignClassContext(VD, Reason))
     return false;
+  if (checkObjCActorIsolation(VD, Reason))
+    return false;
 
   if (!Diagnose || Result)
     return Result;
@@ -967,6 +1000,8 @@ bool swift::isRepresentableInObjC(const SubscriptDecl *SD, ObjCReason Reason) {
     return false;
   if (checkObjCWithGenericParams(SD, Reason))
     return false;
+  if (checkObjCActorIsolation(SD, Reason))
+    return false;
 
   // ObjC doesn't support class subscripts.
   if (!SD->isInstanceMember()) {

test/attr/attr_objc_async.swift

@@ -3,10 +3,11 @@
 // RUN: not %target-swift-frontend -typecheck -dump-ast -disable-objc-attr-requires-foundation-module %s -swift-version 5 -enable-source-import -I %S/Inputs -enable-experimental-concurrency > %t.ast
 // RUN: %FileCheck -check-prefix CHECK-DUMP %s < %t.ast
 // REQUIRES: objc_interop
+// REQUIRES: concurrency
 import Foundation
 
-// CHECK: class Concurrency
-class Concurrency {
+// CHECK: class MyClass
+class MyClass {
   // CHECK: @objc func doBigJob() async -> Int
   // CHECK-DUMP: func_decl{{.*}}doBigJob{{.*}}foreign_async=@convention(block) (Int) -> (),completion_handler_param=0
   @objc func doBigJob() async -> Int { return 0 }
@@ -21,3 +22,27 @@ class Concurrency {
   @objc class func createAsynchronously() async -> Self? { nil }
   // expected-error@-1{{asynchronous method returning 'Self' cannot be '@objc'}}
 }
+
+// Actor class exporting Objective-C entry points.
+
+// CHECK: class MyActor
+actor class MyActor {
+  // CHECK: @objc func doBigJob() async -> Int
+  // CHECK-DUMP: func_decl{{.*}}doBigJob{{.*}}foreign_async=@convention(block) (Int) -> (),completion_handler_param=0
+  @objc func doBigJob() async -> Int { return 0 }
+
+  // CHECK: @objc func doBigJobOrFail(_: Int) async throws -> (AnyObject, Int)
+  // CHECK-DUMP: func_decl{{.*}}doBigJobOrFail{{.*}}foreign_async=@convention(block) (Optional<AnyObject>, Int, Optional<Error>) -> (),completion_handler_param=1,error_param=2
+  @objc func doBigJobOrFail(_: Int) async throws -> (AnyObject, Int) { return (self, 0) }
+
+  // Actor-isolated entities cannot be exposed to Objective-C.
+  @objc func synchronousBad() { } // expected-error{{actor-isolated instance method 'synchronousBad()' cannot be @objc}}
+  // expected-note@-1{{add 'async' to function 'synchronousBad()' to make it asynchronous}}
+  // expected-note@-2{{add '@asyncHandler' to function 'synchronousBad()' to create an implicit asynchronous context}}
+
+  @objc var badProp: AnyObject { self } // expected-error{{actor-isolated property 'badProp' cannot be @objc}}
+  @objc subscript(index: Int) -> AnyObject { self } // expected-error{{actor-isolated subscript 'subscript(_:)' cannot be @objc}}
+
+  // CHECK: @objc @actorIndependent func synchronousGood()
+  @objc @actorIndependent func synchronousGood() { }
+}