[cxx-interop] Allow retain/release operations to be methods

Some foreign reference types such as IUnknown define retain/release operations as methods of the type.

Previously Swift only supported retain/release operations as standalone functions.

The syntax for member functions would be `SWIFT_SHARED_REFERENCE(.doRetain, .doRelease)`.

rdar://160696723

Author: egorzhdan

lib/ClangImporter/ClangImporter.cpp

@@ -7915,10 +7915,27 @@ getRefParentDecls(const clang::RecordDecl *decl, ASTContext &ctx,
 }
 
 llvm::SmallVector<ValueDecl *, 1>
-importer::getValueDeclsForName(
-    const clang::Decl *decl, ASTContext &ctx, StringRef name) {
+importer::getValueDeclsForName(NominalTypeDecl *decl, StringRef name) {
+  // If the name is empty, don't try to find any decls.
+  if (name.empty())
+    return {};
+
+  auto &ctx = decl->getASTContext();
+  auto clangDecl = decl->getClangDecl();
   llvm::SmallVector<ValueDecl *, 1> results;
-  auto *clangMod = decl->getOwningModule();
+
+  if (name.starts_with(".")) {
+    // Look for a member of decl instead of a global.
+    StringRef memberName = name.drop_front(1);
+    if (memberName.empty())
+      return {};
+    auto declName = DeclName(ctx.getIdentifier(memberName));
+    auto allResults = evaluateOrDefault(
+        ctx.evaluator, ClangRecordMemberLookup({decl, declName}), {});
+    return SmallVector<ValueDecl *, 1>(allResults.begin(), allResults.end());
+  }
+
+  auto *clangMod = clangDecl->getOwningModule();
   if (clangMod && clangMod->isSubModule())
     clangMod = clangMod->getTopLevelModule();
   if (clangMod) {
@@ -8523,7 +8540,7 @@ CustomRefCountingOperationResult CustomRefCountingOperation::evaluate(
     return {CustomRefCountingOperationResult::immortal, nullptr, name};
 
   llvm::SmallVector<ValueDecl *, 1> results =
-      getValueDeclsForName(swiftDecl->getClangDecl(), ctx, name);
+      getValueDeclsForName(const_cast<ClassDecl*>(swiftDecl), name);
   if (results.size() == 1)
     return {CustomRefCountingOperationResult::foundOperation, results.front(),
             name};

lib/ClangImporter/ImportDecl.cpp

@@ -2801,17 +2801,24 @@ namespace {
         if (!operationFn)
           return RetainReleaseOperationKind::notAfunction;
 
-        if (operationFn->getParameters()->size() != 1)
+        if (operationFn->getParameters()->size() + operationFn->isInstanceMember() != 1)
           return RetainReleaseOperationKind::invalidParameters;
 
-        Type paramType =
-            operationFn->getParameters()->get(0)->getInterfaceType();
-        // Unwrap if paramType is an OptionalType
-        if (Type optionalType = paramType->getOptionalObjectType()) {
-          paramType = optionalType;
-        }
+        Type paramType;
+        NominalTypeDecl *paramDecl = nullptr;
+        if (!operationFn->isInstanceMember()) {
+          paramType =
+              operationFn->getParameters()->get(0)->getInterfaceType();
+          // Unwrap if paramType is an OptionalType
+          if (Type optionalType = paramType->getOptionalObjectType()) {
+            paramType = optionalType;
+          }
 
-        swift::NominalTypeDecl *paramDecl = paramType->getAnyNominal();
+          paramDecl = paramType->getAnyNominal();
+        } else {
+          paramDecl = cast<NominalTypeDecl>(operationFn->getParent());
+          paramType = paramDecl->getDeclaredInterfaceType();
+        }
 
         // The return type should be void (for release functions), or void
         // or the parameter type (for retain functions).

lib/ClangImporter/ImporterImpl.h

@@ -2200,7 +2200,7 @@ ImportedType findOptionSetEnum(clang::QualType type,
 ///
 /// The name we're looking for is the Swift name.
 llvm::SmallVector<ValueDecl *, 1>
-getValueDeclsForName(const clang::Decl *decl, ASTContext &ctx, StringRef name);
+getValueDeclsForName(NominalTypeDecl* decl, StringRef name);
 
 } // end namespace importer
 } // end namespace swift

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -2882,8 +2882,7 @@ FuncDecl *SwiftDeclSynthesizer::findExplicitDestroy(
     if (!destroyFuncName.consume_front("destroy:"))
       continue;
 
-    auto decls = getValueDeclsForName(
-        clangType, nominal->getASTContext(), destroyFuncName);
+    auto decls = getValueDeclsForName(nominal, destroyFuncName);
     for (auto decl : decls) {
       auto func = dyn_cast<FuncDecl>(decl);
       if (!func)

lib/IRGen/GenObjC.cpp

@@ -1724,6 +1724,11 @@ void IRGenFunction::emitBlockRelease(llvm::Value *value) {
 
 void IRGenFunction::emitForeignReferenceTypeLifetimeOperation(
     ValueDecl *fn, llvm::Value *value, bool needsNullCheck) {
+  if (auto originalDecl = fn->getASTContext()
+                              .getClangModuleLoader()
+                              ->getOriginalForClonedMember(fn))
+    fn = originalDecl;
+
   assert(fn->getClangDecl() && isa<clang::FunctionDecl>(fn->getClangDecl()));
 
   auto clangFn = cast<clang::FunctionDecl>(fn->getClangDecl());

test/Interop/Cxx/foreign-reference/Inputs/lifetime-operation-methods.h

@@ -0,0 +1,40 @@
+#include <swift/bridging>
+
+struct RefCountedBox {
+  int value;
+  int refCount = 1;
+
+  RefCountedBox(int value) : value(value) {}
+
+  static RefCountedBox *create(int value) { return new RefCountedBox(value); }
+
+  void doRetain() { refCount++; }
+  void doRelease() { refCount--; }
+} SWIFT_SHARED_REFERENCE(.doRetain, .doRelease);
+
+struct DerivedRefCountedBox : RefCountedBox {
+  int secondValue = 1;
+  DerivedRefCountedBox(int value, int secondValue)
+      : RefCountedBox(value), secondValue(secondValue) {}
+
+  static DerivedRefCountedBox *createDerived(int value, int secondValue) {
+    return new DerivedRefCountedBox(value, secondValue);
+  }
+};
+
+// MARK: Retain in a base type, release in derived
+
+struct BaseHasRetain {
+  mutable int refCount = 1;
+  void doRetainInBase() const { refCount++; }
+};
+
+struct DerivedHasRelease : BaseHasRetain {
+  int value;
+  DerivedHasRelease(int value) : value(value) {}
+  static DerivedHasRelease *create(int value) {
+    return new DerivedHasRelease(value);
+  }
+
+  void doRelease() const { refCount--; }
+} SWIFT_SHARED_REFERENCE(.doRetainInBase, .doRelease);

test/Interop/Cxx/foreign-reference/Inputs/module.modulemap

@@ -43,6 +43,11 @@ module ReferenceCountedObjCProperty {
   export *
 }
 
+module LifetimeOperationMethods {
+  header "lifetime-operation-methods.h"
+  requires cplusplus
+}
+
 module MemberLayout {
   header "member-layout.h"
   requires cplusplus

test/Interop/Cxx/foreign-reference/lifetime-operation-methods-module-interface.swift

@@ -0,0 +1,15 @@
+// RUN: %target-swift-ide-test -print-module -cxx-interoperability-mode=upcoming-swift -I %swift_src_root/lib/ClangImporter/SwiftBridging -module-to-print=LifetimeOperationMethods -I %S/Inputs -source-filename=x | %FileCheck %s
+
+// CHECK: class RefCountedBox {
+// CHECK:   func doRetain() 
+// CHECK:   func doRelease()
+// CHECK: }
+// CHECK: class DerivedRefCountedBox {
+// CHECK:   func doRetain()
+// CHECK:   func doRelease()
+// CHECK: }
+
+// CHECK: class DerivedHasRelease {
+// CHECK:   func doRelease()
+// CHECK:   func doRetainInBase()
+// CHECK: }

test/Interop/Cxx/foreign-reference/lifetime-operation-methods.swift

@@ -0,0 +1,37 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -cxx-interoperability-mode=upcoming-swift -I %swift_src_root/lib/ClangImporter/SwiftBridging -Xfrontend -disable-availability-checking)
+
+// Temporarily disable when running with an older runtime (rdar://128681137)
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
+import StdlibUnittest
+import LifetimeOperationMethods
+
+var LifetimeMethodsTestSuite = TestSuite("Lifetime operations that are instance methods")
+
+LifetimeMethodsTestSuite.test("retain/release methods") {
+  let a = RefCountedBox.create(123)!
+  expectEqual(a.value, 123)
+  expectTrue(a.refCount > 0)
+  expectTrue(a.refCount < 10) // optimizations would affect the exact number
+}
+
+LifetimeMethodsTestSuite.test("retain/release methods from base type") {
+  let a = DerivedRefCountedBox.createDerived(321, 456)!
+  expectEqual(a.value, 321)
+  expectEqual(a.secondValue, 456)
+  expectTrue(a.refCount > 0)
+  expectTrue(a.refCount < 10) // optimizations would affect the exact number
+
+  a.secondValue = 789
+  expectEqual(a.secondValue, 789)
+}
+
+LifetimeMethodsTestSuite.test("retain in base type, release in derived type") {
+  let a = DerivedHasRelease.create(321)!
+  expectEqual(a.value, 321)
+  expectTrue(a.refCount > 0)
+  expectTrue(a.refCount < 10) // optimizations would affect the exact number
+}
+
+runAllTests()