[cxx-interop] Add support for SWIFT_RETURNS_(UN)RETAINED for ObjC APIs returning C++ FRT

rdar://135360972

Author: fahadnayyar

lib/SIL/IR/SILFunctionType.cpp

@@ -1298,6 +1298,25 @@ class Conventions {
     }
     llvm_unreachable("unhandled ownership");
   }
+
+  // Determines owned/unowned ResultConvention of the returned value based on
+  // returns_retained/returns_unretained attribute.
+  std::optional<ResultConvention>
+  getCxxRefConventionWithAttrs(const TypeLowering &tl,
+                               const clang::Decl *decl) const {
+    if (tl.getLoweredType().isForeignReferenceType() && decl->hasAttrs()) {
+      for (const auto *attr : decl->getAttrs()) {
+        if (const auto *swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr)) {
+          if (swiftAttr->getAttribute() == "returns_unretained") {
+            return ResultConvention::Unowned;
+          } else if (swiftAttr->getAttribute() == "returns_retained") {
+            return ResultConvention::Owned;
+          }
+        }
+      }
+    }
+    return std::nullopt;
+  }
 };
 
 /// A visitor for breaking down formal result types into a SILResultInfo
@@ -3340,8 +3359,11 @@ class ObjCMethodConventions : public Conventions {
     if (isImplicitPlusOneCFResult())
       return ResultConvention::Owned;
 
-    if (tl.getLoweredType().isForeignReferenceType())
+    if (tl.getLoweredType().isForeignReferenceType()) {
+      if (auto resultConventionOpt = getCxxRefConventionWithAttrs(tl, Method))
+        return *resultConventionOpt;
       return ResultConvention::Unowned;
+    }
 
     return ResultConvention::Autoreleased;
   }
@@ -3381,25 +3403,6 @@ class CFunctionTypeConventions : public Conventions {
                            const clang::FunctionType *type)
     : Conventions(kind), FnType(type) {}
 
-  // Determines owned/unowned ResultConvention of the returned value based on
-  // returns_retained/returns_unretained attribute.
-  std::optional<ResultConvention>
-  getForeignReferenceTypeResultConventionWithAttributes(
-      const TypeLowering &tl, const clang::FunctionDecl *decl) const {
-    if (tl.getLoweredType().isForeignReferenceType() && decl->hasAttrs()) {
-      for (const auto *attr : decl->getAttrs()) {
-        if (const auto *swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr)) {
-          if (swiftAttr->getAttribute() == "returns_unretained") {
-            return ResultConvention::Unowned;
-          } else if (swiftAttr->getAttribute() == "returns_retained") {
-            return ResultConvention::Owned;
-          }
-        }
-      }
-    }
-    return std::nullopt;
-  }
-
 public:
   CFunctionTypeConventions(const clang::FunctionType *type)
     : Conventions(ConventionsKind::CFunctionType), FnType(type) {}
@@ -3517,11 +3520,7 @@ class CFunctionConventions : public CFunctionTypeConventions {
       return ResultConvention::Indirect;
     }
 
-    // Explicitly setting the ownership of the returned FRT if the C++
-    // global/free function has either swift_attr("returns_retained") or
-    // ("returns_unretained") attribute.
-    if (auto resultConventionOpt =
-            getForeignReferenceTypeResultConventionWithAttributes(tl, TheDecl))
+    if (auto resultConventionOpt = getCxxRefConventionWithAttrs(tl, TheDecl))
       return *resultConventionOpt;
 
     if (isCFTypedef(tl, TheDecl->getReturnType())) {
@@ -3603,11 +3602,8 @@ class CXXMethodConventions : public CFunctionTypeConventions {
       return ResultConvention::Indirect;
     }
 
-    // Explicitly setting the ownership of the returned FRT if the C++ member
-    // method has either swift_attr("returns_retained") or
-    // ("returns_unretained") attribute.
     if (auto resultConventionOpt =
-            getForeignReferenceTypeResultConventionWithAttributes(resultTL, TheDecl))
+            getCxxRefConventionWithAttrs(resultTL, TheDecl))
       return *resultConventionOpt;
 
     if (TheDecl->hasAttr<clang::CFReturnsRetainedAttr>() &&

test/Interop/Cxx/foreign-reference/Inputs/cxx-functions-and-methods-returning-frt.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <Foundation/Foundation.h>
 #include <functional>
 
 // FRT or SWIFT_SHARED_REFERENCE type
@@ -326,3 +327,25 @@ struct Derived : Base {
   FRTStruct *_Nonnull VirtualMethodReturningFRTUnowned() override
       __attribute__((swift_attr("returns_unretained")));
 };
+
+@interface Bridge : NSObject
+
++ (struct FRTStruct *_Nonnull)objCMethodReturningFRTUnannotated;
++ (struct FRTStruct *_Nonnull)objCMethodReturningFRTUnowned
+    __attribute__((swift_attr("returns_unretained")));
++ (struct FRTStruct *_Nonnull)objCMethodReturningFRTOwned
+    __attribute__((swift_attr("returns_retained")));
+
+@end
+
+@implementation Bridge
++ (struct FRTStruct *_Nonnull)objCMethodReturningFRTUnannotated {
+};
++ (struct FRTStruct *_Nonnull)objCMethodReturningFRTUnowned
+    __attribute__((swift_attr("returns_unretained"))) {
+}
++ (struct FRTStruct *_Nonnull)objCMethodReturningFRTOwned
+    __attribute__((swift_attr("returns_retained"))) {
+}
+
+@end

test/Interop/Cxx/foreign-reference/frt-retained-unretained-attributes.swift

@@ -246,3 +246,13 @@ func testVirtualMethods(base: Base, derived: Derived) {
     // CHECK: function_ref @{{.*}}VirtualMethodReturningFRTOwned{{.*}} : $@convention(cxx_method) (@inout Derived) -> @owned FRTStruct
 }
 
+func testObjCMethods() {
+    var frt1 = Bridge.objCMethodReturningFRTUnannotated()
+    // CHECK: objc_method {{.*}} #Bridge.objCMethodReturningFRTUnannotated!foreign : (Bridge.Type) -> () -> FRTStruct, $@convention(objc_method) (@objc_metatype Bridge.Type) -> FRTStruct
+
+    var frt2 = Bridge.objCMethodReturningFRTUnowned()
+    // CHECK: objc_method {{.*}} #Bridge.objCMethodReturningFRTUnowned!foreign : (Bridge.Type) -> () -> FRTStruct, $@convention(objc_method) (@objc_metatype Bridge.Type) -> FRTStruct
+
+    var frt3 = Bridge.objCMethodReturningFRTOwned()
+    // CHECK: objc_method {{.*}} #Bridge.objCMethodReturningFRTOwned!foreign : (Bridge.Type) -> () -> FRTStruct, $@convention(objc_method) (@objc_metatype Bridge.Type) -> @owned FRTStruct
+ }