[cxx-interop] Reenable exporting Foreign Reference Types to C++

This feature worked prior 5.10 but the semantics was undefined. This PR
restores the behavior with the old semantics, and a separate PR will
update the documentation to describe the behavior.

Author: Gabor Horvath

lib/PrintAsClang/PrintClangFunction.cpp

@@ -289,25 +289,6 @@ class CFunctionSignatureTypePrinter
           os << " __strong";
         printInoutTypeModifier();
       }
-      if (isa<clang::CXXRecordDecl>(cd->getClangDecl())) {
-        if (std::find_if(
-                cd->getClangDecl()->getAttrs().begin(),
-                cd->getClangDecl()->getAttrs().end(), [](clang::Attr *attr) {
-                  if (auto *sa = dyn_cast<clang::SwiftAttrAttr>(attr)) {
-                    llvm::StringRef value = sa->getAttribute();
-                    if ((value.starts_with("retain:") ||
-                         value.starts_with("release:")) &&
-                        !value.ends_with(":immortal"))
-                      return true;
-                  }
-                  return false;
-                }) != cd->getClangDecl()->getAttrs().end()) {
-          // This is a shared FRT. Do not bridge it back to
-          // C++ as its ownership is not managed automatically
-          // in C++ yet.
-          return ClangRepresentation::unsupported;
-        }
-      }
       // FIXME: Mark that this is only ObjC representable.
       return ClangRepresentation::representable;
     }

test/Interop/CxxToSwiftToCxx/disallow-shared-frt-back-to-cxx.swift renamed to test/Interop/CxxToSwiftToCxx/allow-shared-frt-back-to-cxx.swift

@@ -29,6 +29,6 @@ import CxxTest
 public func consumeSharedFRT(_ x: consuming SharedFRT) {}
 public func takeSharedFRT(_ x: SharedFRT) {}
 
-// CHECK: Unavailable in C++: Swift global function 'consumeSharedFRT(_:)'.
+// CHECK: SWIFT_EXTERN void $s8UseCxxTy16consumeSharedFRTyySo0eF0VnF(SharedFRT *_Nonnull x) SWIFT_NOEXCEPT SWIFT_CALL; // consumeSharedFRT(_:)
 
-// CHECK: Unavailable in C++: Swift global function 'takeSharedFRT(_:)'.
+// CHECK: SWIFT_EXTERN void $s8UseCxxTy13takeSharedFRTyySo0eF0VF(SharedFRT *_Nonnull x) SWIFT_NOEXCEPT SWIFT_CALL; // takeSharedFRT(_:)

test/Interop/CxxToSwiftToCxx/consuming-cxx-struct-parameter-back-to-cxx-execution.cpp

@@ -51,6 +51,18 @@ class ImmortalFRT {
 __attribute__((swift_attr("retain:immortal")))
 __attribute__((swift_attr("release:immortal")));
 
+class SharedFRT {
+public:
+  SharedFRT() {}
+  SharedFRT(int x) : x(x) {}
+  int x;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retainShared")))
+__attribute__((swift_attr("release:releaseShared")));
+
+inline void retainShared(SharedFRT *r) { puts("retainShared"); }
+inline void releaseShared(SharedFRT *r) { puts("releaseShared"); }
+
 //--- module.modulemap
 module CxxTest {
     header "header.h"
@@ -74,7 +86,21 @@ public struct TakesNonTrivial {
 }
 
 public func consumeImmortalFRT(_ x: consuming ImmortalFRT) {
-    print("frt x \(x.x)")
+  print("immortal frt x \(x.x)")
+}
+
+public
+func consumeSharedFRT(_ x : consuming SharedFRT) {
+  print("consume shared frt x \(x.x)")
+}
+
+public
+func takeSharedFRT(_ x : SharedFRT) { print("take shared frt x \(x.x)") }
+
+public
+func returnSharedFRT(_ x : SharedFRT) -> SharedFRT {
+  print("return shared frt x \(x.x)")
+  return x
 }
 
 //--- use-swift-cxx-types.cpp
@@ -119,7 +145,22 @@ int main() {
     frt.x = 2;
     UseCxx::consumeImmortalFRT(&frt);
   }
-// CHECK-NEXT: frt x 2
+  // CHECK-NEXT: immortal frt x 2
+  {
+    SharedFRT sfrt;
+    sfrt.x = 2;
+    UseCxx::takeSharedFRT(&sfrt);
+    // CHECK-NEXT: retainShared
+    // CHECK-NEXT: releaseShared
+    // CHECK-NEXT: take shared frt x 2
+    UseCxx::consumeSharedFRT(&sfrt);
+    // CHECK-NEXT: retainShared
+    // CHECK-NEXT: releaseShared
+    // CHECK-NEXT: consume shared frt x 2
+    SharedFRT *sfrtptr = UseCxx::returnSharedFRT(&sfrt);
+    // CHECK-NEXT: retainShared
+    // CHECK-NEXT: return shared frt x 2
+  }
   puts("EndOfTest");
 // CHECK-NEXT: EndOfTest
   return 0;