[interop][SwiftToCxx] report an error for attempts to explicitly expo…

include/swift/AST/DiagnosticsSema.def

@@ -1538,6 +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_async_decl_to_cxx,none,
+      "async %0 %1 can not be exposed to C++", (DescriptiveDeclKind, ValueDecl *))
 ERROR(expose_unsupported_actor_isolated_to_cxx,none,
       "actor-isolated %0 %1 can not be exposed to C++", (DescriptiveDeclKind, ValueDecl *))
 

include/swift/AST/SwiftNameTranslation.h

@@ -65,7 +65,10 @@ getNameForCxx(const ValueDecl *VD,
 
 enum RepresentationKind { Representable, Unsupported };
 
-enum RepresentationError { UnrepresentableIsolatedInActor };
+enum RepresentationError {
+  UnrepresentableAsync,
+  UnrepresentableIsolatedInActor
+};
 
 struct DeclRepresentation {
   RepresentationKind kind;

lib/AST/SwiftNameTranslation.cpp

@@ -169,6 +169,10 @@ swift::cxx_translation::DeclRepresentation
 swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
   if (getActorIsolation(const_cast<ValueDecl *>(VD)).isActorIsolated())
     return {Unsupported, UnrepresentableIsolatedInActor};
+  if (auto *AFD = dyn_cast<AbstractFunctionDecl>(VD)) {
+    if (AFD->hasAsync())
+      return {Unsupported, UnrepresentableAsync};
+  }
   return {Representable, llvm::None};
 }
 

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -1590,8 +1590,7 @@ class DeclAndTypePrinter::Implementation
     if (outputLang == OutputLanguageMode::Cxx) {
       // Don't expose async functions or @_alwaysEmitIntoClient functions
       // because they're currently unsupported
-      if (FD->hasAsync() ||
-          FD->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>()) {
+      if (FD->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>()) {
         return;
       }
 

lib/Sema/TypeCheckAttr.cpp

@@ -1957,6 +1957,10 @@ void AttributeChecker::visitExposeAttr(ExposeAttr *attr) {
   if (repr.isUnsupported()) {
     using namespace cxx_translation;
     switch (*repr.error) {
+    case UnrepresentableAsync:
+      diagnose(attr->getLocation(), diag::expose_unsupported_async_decl_to_cxx,
+               VD->getDescriptiveKind(), VD);
+      break;
     case UnrepresentableIsolatedInActor:
       diagnose(attr->getLocation(),
                diag::expose_unsupported_actor_isolated_to_cxx,

test/Interop/SwiftToCxx/functions/swift-no-expose-unsupported-async-func.swift

@@ -9,8 +9,6 @@
 // CHECK:       namespace Functions {
 // CHECK-EMPTY:
 // CHECK-EMPTY:
-// CHECK-EMPTY:
-// CHECK-EMPTY:
 // CHECK-NEXT:  } // namespace Functions
 
 // CHECK-NOT: inline double asyncFunc(double x) noexcept SWIFT_WARN_UNUSED_RESULT {

test/Interop/SwiftToCxx/unsupported/unsupported-decls-in-cxx.swift

@@ -31,12 +31,20 @@ public actor ActorClass {
 
     @_expose(Cxx) // ok
     nonisolated public var prop2: Int { 42 }
+
+    @_expose(Cxx) // expected-error {{async instance method 'methodAsync()' can not be exposed to C++}}
+    public nonisolated func methodAsync() async {
+    }
 }
 
 @_expose(Cxx)
 public distributed actor DistributedActorClass {
     public typealias ActorSystem = LocalTestingDistributedActorSystem
 
+    public init(actorSystem: LocalTestingDistributedActorSystem) {
+        self.actorSystem = actorSystem
+    }
+
     @_expose(Cxx) // expected-error {{actor-isolated instance method 'unsupported()' can not be exposed to C++}}
     public func unsupported() {}