Merge pull request #61882 from hyp/eng/actor-expose

hyp · web-flow · commit 56665d5ce9f6 · 2022-11-03T12:35:51.000-07:00
[interop][SwiftToCxx] add support for exposing non-isolated actor declarations
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -1538,8 +1538,8 @@ ERROR(expose_inside_unexposed_decl,none,
 ERROR(expose_invalid_name_pattern_init,none,
       "invalid declaration name '%0' specified in an @_expose attribute; "
       "exposed initializer name must start with 'init'", (StringRef))
-ERROR(expose_unsupported_actor_to_cxx,none,
-      "actor %0 can not be exposed to C++", (DeclName))
+ERROR(expose_unsupported_actor_isolated_to_cxx,none,
+      "actor-isolated %0 %1 can not be exposed to C++", (DescriptiveDeclKind, ValueDecl *))
 
 ERROR(attr_methods_only,none,
       "only methods can be declared %0", (DeclAttribute))
diff --git a/include/swift/AST/SwiftNameTranslation.h b/include/swift/AST/SwiftNameTranslation.h
@@ -65,7 +65,7 @@ getNameForCxx(const ValueDecl *VD,
 
 enum RepresentationKind { Representable, Unsupported };
 
-enum RepresentationError { UnrepresentableActorClass };
+enum RepresentationError { UnrepresentableIsolatedInActor };
 
 struct DeclRepresentation {
   RepresentationKind kind;
diff --git a/lib/AST/SwiftNameTranslation.cpp b/lib/AST/SwiftNameTranslation.cpp
@@ -167,11 +167,8 @@ swift::cxx_translation::getNameForCxx(const ValueDecl *VD,
 
 swift::cxx_translation::DeclRepresentation
 swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
-  if (auto *CD = dyn_cast<ClassDecl>(VD)) {
-    // Actors are not exposable to C++.
-    if (CD->isAnyActor())
-      return {Unsupported, UnrepresentableActorClass};
-  }
+  if (getActorIsolation(const_cast<ValueDecl *>(VD)).isActorIsolated())
+    return {Unsupported, UnrepresentableIsolatedInActor};
   return {Representable, llvm::None};
 }
 
diff --git a/lib/PrintAsClang/experimental-interoperability-version.json b/lib/PrintAsClang/experimental-interoperability-version.json
@@ -1 +1 @@
-5
+6
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -1931,7 +1931,7 @@ void AttributeChecker::visitCDeclAttr(CDeclAttr *attr) {
 }
 
 void AttributeChecker::visitExposeAttr(ExposeAttr *attr) {
-  const auto *VD = cast<ValueDecl>(D);
+  auto *VD = cast<ValueDecl>(D);
   // Expose cannot be mixed with '@objc'/'@_cdecl' declarations.
   if (VD->isObjC())
     diagnose(attr->getLocation(), diag::expose_only_non_other_attr, "@objc");
@@ -1957,9 +1957,10 @@ void AttributeChecker::visitExposeAttr(ExposeAttr *attr) {
   if (repr.isUnsupported()) {
     using namespace cxx_translation;
     switch (*repr.error) {
-    case UnrepresentableActorClass:
-      diagnose(attr->getLocation(), diag::expose_unsupported_actor_to_cxx,
-               decl->getName());
+    case UnrepresentableIsolatedInActor:
+      diagnose(attr->getLocation(),
+               diag::expose_unsupported_actor_isolated_to_cxx,
+               VD->getDescriptiveKind(), VD);
       break;
     }
   }
diff --git a/test/Interop/SwiftToCxx/class/swift-actor-execution.cpp b/test/Interop/SwiftToCxx/class/swift-actor-execution.cpp
@@ -0,0 +1,67 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %S/swift-actor-in-cxx.swift -typecheck -module-name Actor -clang-header-expose-decls=has-expose-attr -emit-clang-header-path %t/actor.h -disable-availability-checking
+
+// RUN: %target-interop-build-clangxx -c %s -I %t -o %t/swift-actor-execution.o
+// RUN: %target-interop-build-swift %S/swift-actor-in-cxx.swift -o %t/swift-actor-execution -Xlinker %t/swift-actor-execution.o -module-name Actor -Xfrontend -entry-point-function-name -Xfrontend swiftMain -Xfrontend -disable-availability-checking
+
+// RUN: %target-codesign %t/swift-actor-execution
+// RUN: %target-run %t/swift-actor-execution | %FileCheck %s
+
+// RUN: %empty-directory(%t-evo)
+
+// RUN: %target-swift-frontend %S/swift-actor-in-cxx.swift -typecheck -module-name Actor -clang-header-expose-decls=has-expose-attr -enable-library-evolution -emit-clang-header-path %t-evo/actor.h -disable-availability-checking
+
+// RUN: %target-interop-build-clangxx -c %s -I %t-evo -o %t-evo/swift-actor-execution.o
+// RUN: %target-interop-build-swift %S/swift-actor-in-cxx.swift -o %t-evo/swift-actor-execution-evo -Xlinker %t-evo/swift-actor-execution.o -module-name Actor -enable-library-evolution -Xfrontend -entry-point-function-name -Xfrontend swiftMain -Xfrontend -disable-availability-checking
+
+// RUN: %target-codesign %t-evo/swift-actor-execution-evo
+// RUN: %target-run %t-evo/swift-actor-execution-evo | %FileCheck %s
+
+// REQUIRES: executable_test
+
+// REQUIRES: concurrency
+
+#include <assert.h>
+#include "actor.h"
+#include <cstdio>
+
+extern "C" size_t swift_retainCount(void * _Nonnull obj);
+
+size_t getRetainCount(const Actor::ActorWithField & swiftClass) {
+  void *p = swift::_impl::_impl_RefCountedClass::getOpaquePointer(swiftClass);
+  return swift_retainCount(p);
+}
+
+int main() {
+  using namespace Actor;
+
+  // Ensure that the actor class is released.
+  {
+    auto x = ActorWithField::init();
+    assert(getRetainCount(x) == 1);
+  }
+// CHECK:      init ActorWithField
+// CHECK-NEXT: destroy ActorWithField
+    
+  {
+    auto x = ActorWithField::init();
+    {
+      takeActorWithIntField(x);
+      assert(getRetainCount(x) == 1);
+    }
+    assert(getRetainCount(x) == 1);
+  }
+// CHECK-NEXT: init ActorWithField
+// CHECK-NEXT: takeActorWithIntField
+// CHECK-NEXT: destroy ActorWithField
+    
+  {
+    auto x = ActorWithField::init();
+    x.method();
+  }
+// CHECK-NEXT: init ActorWithField
+// CHECK-NEXT: nonisolated method
+// CHECK-NEXT: destroy ActorWithField
+  return 0;
+}
diff --git a/test/Interop/SwiftToCxx/class/swift-actor-in-cxx.swift b/test/Interop/SwiftToCxx/class/swift-actor-in-cxx.swift
@@ -0,0 +1,44 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -typecheck -module-name Actor -clang-header-expose-decls=has-expose-attr -emit-clang-header-path %t/actor.h -disable-availability-checking
+// RUN: %FileCheck %s < %t/actor.h
+
+// RUN: %check-interop-cxx-header-in-clang(%t/actor.h)
+
+// RUN: %target-swift-frontend %s -typecheck -module-name Actor -enable-library-evolution -clang-header-expose-decls=has-expose-attr -emit-clang-header-path %t/actor-evo.h -disable-availability-checking
+// RUN: %FileCheck %s < %t/actor-evo.h
+
+// RUN: %check-interop-cxx-header-in-clang(%t/actor-evo.h)
+
+// REQUIRES: concurrency
+
+@_expose(Cxx)
+public final actor ActorWithField {
+  var field: Int64
+
+  public init() {
+    field = 0
+    print("init ActorWithField")
+  }
+  deinit {
+    print("destroy ActorWithField")
+  }
+
+  public func isolatedMethod() {}
+
+  public nonisolated func method() {
+      print("nonisolated method")
+  }
+}
+
+// CHECK: namespace Actor {
+// CHECK: SWIFT_EXTERN void * _Nonnull $s5Actor0A9WithFieldCACycfC(SWIFT_CONTEXT void * _Nonnull _self) SWIFT_NOEXCEPT SWIFT_CALL; // init()
+// CHECK: SWIFT_EXTERN void $s5Actor0A9WithFieldC6methodyyF(SWIFT_CONTEXT void * _Nonnull _self) SWIFT_NOEXCEPT SWIFT_CALL; // method()
+
+// CHECK: class ActorWithField final : public swift::_impl::RefCountedClass {
+// CHECK:   static inline ActorWithField init();
+// CHECK:   inline void method();
+
+@_expose(Cxx)
+public func takeActorWithIntField(_ x: ActorWithField) {
+    print("takeActorWithIntField")
+}
diff --git a/test/Interop/SwiftToCxx/unsupported/unsupported-decls-in-cxx.swift b/test/Interop/SwiftToCxx/unsupported/unsupported-decls-in-cxx.swift
@@ -10,9 +10,49 @@
 // CHECK-NOT: Unsupported
 // CHECK: supported
 
+import Distributed
+
 public func supported() {}
 
-@_expose(Cxx) // expected-error {{actor 'ActorClassUnsupported' can not be exposed to C++}}
-public actor ActorClassUnsupported {
-    public func test() {}
+@_expose(Cxx)
+public actor ActorClass {
+    @_expose(Cxx) // expected-error {{actor-isolated instance method 'unsupported()' can not be exposed to C++}}
+    public func unsupported() {}
+
+    @_expose(Cxx) // expected-error {{actor-isolated property 'prop' can not be exposed to C++}}
+    public var prop: Int { 42 }
+
+    @_expose(Cxx) // ok
+    public init() {
+    }
+
+    @_expose(Cxx) // ok
+    nonisolated public func supported() {}
+
+    @_expose(Cxx) // ok
+    nonisolated public var prop2: Int { 42 }
+}
+
+@_expose(Cxx)
+public distributed actor DistributedActorClass {
+    public typealias ActorSystem = LocalTestingDistributedActorSystem
+
+    @_expose(Cxx) // expected-error {{actor-isolated instance method 'unsupported()' can not be exposed to C++}}
+    public func unsupported() {}
+
+    @_expose(Cxx) // expected-error {{actor-isolated property 'prop' can not be exposed to C++}}
+    public var prop: Int { 42 }
+
+    @_expose(Cxx) // expected-error {{actor-isolated distributed instance method 'dist()' can not be exposed to C++}}
+    distributed public func dist() {}
+
+    @_expose(Cxx) // ok
+    public init() {
+    }
+
+    @_expose(Cxx) // ok
+    nonisolated public func supported() {}
+
+    @_expose(Cxx) // ok
+    nonisolated public var prop2: Int { 42 }
 }
