[interop][SwiftToCxx] emit destructor that calls value witness destroy function for Swift structs

Author: hyp

lib/PrintAsClang/PrintClangValueType.cpp

@@ -61,16 +61,13 @@ printCValueTypeStorageStruct(raw_ostream &os, const NominalTypeDecl *typeDecl,
 }
 
 void printCTypeMetadataTypeFunction(raw_ostream &os,
-                                    const NominalTypeDecl *typeDecl) {
+                                    const NominalTypeDecl *typeDecl,
+                                    StringRef typeMetadataFuncName) {
   os << "// Type metadata accessor for " << typeDecl->getNameStr() << "\n";
-  auto entity = irgen::LinkEntity::forTypeMetadataAccessFunction(
-      typeDecl->getDeclaredType()->getCanonicalType());
   os << "SWIFT_EXTERN ";
   ClangSyntaxPrinter printer(os);
   printer.printSwiftImplQualifier();
-  os << "MetadataResponseTy ";
-  entity.mangle(os);
-  os << '(';
+  os << "MetadataResponseTy " << typeMetadataFuncName << '(';
   printer.printSwiftImplQualifier();
   os << "MetadataRequestTy)";
   os << " SWIFT_NOEXCEPT SWIFT_CALL;\n\n";
@@ -90,6 +87,10 @@ void ClangValueTypePrinter::printStructDecl(const StructDecl *SD) {
 
   ClangSyntaxPrinter printer(os);
 
+  auto typeMetadataFunc = irgen::LinkEntity::forTypeMetadataAccessFunction(
+      SD->getDeclaredType()->getCanonicalType());
+  std::string typeMetadataFuncName = typeMetadataFunc.mangleAsString();
+
   // Print out a forward declaration of the "hidden" _impl class.
   printer.printNamespace(cxx_synthesis::getCxxImplNamespaceName(),
                          [&](raw_ostream &os) {
@@ -99,13 +100,41 @@ void ClangValueTypePrinter::printStructDecl(const StructDecl *SD) {
 
                            // Print out special functions, like functions that
                            // access type metadata.
-                           printCTypeMetadataTypeFunction(os, SD);
+                           printCTypeMetadataTypeFunction(os, SD,
+                                                          typeMetadataFuncName);
                          });
 
   // Print out the C++ class itself.
   os << "class ";
   ClangSyntaxPrinter(os).printBaseName(SD);
   os << " final {\n";
+  os << "public:\n";
+
+  // Print out the destructor.
+  os << "  inline ~";
+  printer.printBaseName(SD);
+  os << "() {\n";
+  os << "    auto metadata = " << cxx_synthesis::getCxxImplNamespaceName()
+     << "::" << typeMetadataFuncName << "(0);\n";
+  os << "    auto *vwTable = "
+        "*(reinterpret_cast<swift::_impl::ValueWitnessTable **>(metadata._0) - "
+        "1);\n";
+  os << "    vwTable->destroy(_getOpaquePointer(), metadata._0);\n";
+  os << "  }\n";
+
+  os << "  inline ";
+  printer.printBaseName(SD);
+  os << "(const ";
+  printer.printBaseName(SD);
+  os << " &) = default;\n";
+
+  // FIXME: the move constructor should be hidden somehow.
+  os << "  inline ";
+  printer.printBaseName(SD);
+  os << "(";
+  printer.printBaseName(SD);
+  os << " &&) = default;\n";
+
   // FIXME: Print the other members of the struct.
   os << "private:\n";
 

test/Interop/SwiftToCxx/structs/struct-with-refcounted-member-execution.cpp

@@ -0,0 +1,26 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %S/struct-with-refcounted-member.swift -typecheck -module-name Structs -clang-header-expose-public-decls -emit-clang-header-path %t/structs.h
+
+// RUN: %target-interop-build-clangxx -c %s -I %t -o %t/swift-structs-execution.o
+// RUN: %target-interop-build-swift %S/struct-with-refcounted-member.swift -o %t/swift-structs-execution -Xlinker %t/swift-structs-execution.o -module-name Structs -Xfrontend -entry-point-function-name -Xfrontend swiftMain
+
+// RUN: %target-codesign %t/swift-structs-execution
+// RUN: %target-run %t/swift-structs-execution | %FileCheck %s
+
+// REQUIRES: executable_test
+
+#include <assert.h>
+#include "structs.h"
+
+int main() {
+  using namespace Structs;
+
+  // Ensure that the value destructor is called.
+  {
+    StructWithRefcountedMember value = returnNewStructWithRefcountedMember();
+  }
+// CHECK:      create RefCountedClass
+// CHECK-NEXT: destroy RefCountedClass
+  return 0;
+}

test/Interop/SwiftToCxx/structs/struct-with-refcounted-member.swift

@@ -0,0 +1,33 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -typecheck -module-name Structs -clang-header-expose-public-decls -emit-clang-header-path %t/structs.h
+// RUN: %FileCheck %s < %t/structs.h
+
+// RUN: %check-interop-cxx-header-in-clang(%t/structs.h -Wno-unused-function)
+
+class RefCountedClass {
+    init() {
+        print("create RefCountedClass")
+    }
+    deinit {
+        print("destroy RefCountedClass")
+    }
+}
+
+public struct StructWithRefcountedMember {
+    let x: RefCountedClass
+}
+
+public func returnNewStructWithRefcountedMember() -> StructWithRefcountedMember {
+    return StructWithRefcountedMember(x: RefCountedClass())
+}
+
+// CHECK:      class StructWithRefcountedMember final {
+// CHECK-NEXT: public:
+// CHECK-NEXT:   inline ~StructWithRefcountedMember() {
+// CHECK-NEXT:     auto metadata = _impl::$s7Structs26StructWithRefcountedMemberVMa(0);
+// CHECK-NEXT:     auto *vwTable = *(reinterpret_cast<swift::_impl::ValueWitnessTable **>(metadata._0) - 1);
+// CHECK-NEXT:     vwTable->destroy(_getOpaquePointer(), metadata._0);
+// CHECK-NEXT:   }
+// CHECK-NEXT:   inline StructWithRefcountedMember(const StructWithRefcountedMember &) = default;
+// CHECK-NEXT:   inline StructWithRefcountedMember(StructWithRefcountedMember &&) = default;
+// CHECK-NEXT: private:

test/Interop/SwiftToCxx/structs/swift-struct-in-cxx.swift

@@ -20,6 +20,10 @@
 // CHECK-NEXT: }
 
 // CHECK:      class StructWithIntField final {
+// CHECK-NEXT: public:
+// CHECK-NEXT:   inline ~StructWithIntField() {
+// CHECK:        inline StructWithIntField(const StructWithIntField &) = default;
+// CHECK-NEXT:   inline StructWithIntField(StructWithIntField &&) = default;
 // CHECK-NEXT: private:
 // CHECK-NEXT:   inline StructWithIntField() {}
 // CHECK-NEXT:   static inline StructWithIntField _make() { return StructWithIntField(); }