[Clang importer] Allow noncopyable C structs to define "destroy" operation

DougGregor · DougGregor · commit 6ba560fb4b65 · 2025-07-28T00:02:31.000-07:00
A C struct can be imported as noncopyable, but C doesn't have
destructors, so there is no way to provide user-defined logic to
perform the destruction. Introduce a new swift_attr that applies to
imported noncopyable types and which provides such a "destroy"
operation. It can be used like this:

    typedef struct __attribute__((swift_attr("~Copyable")))
                   __attribute__((swift_attr("destroy:wgpuAdapterInfoFreeMembers")))
      WGPUAdapterInfo { /*...*/ } WGPUAdapterInfo;

    void wgpuAdapterInfoFreeMembers(WGPUAdapterInfo adapterInfo);

This will bring the WGPUAdapterInfo struct in as a noncopyable type
that will be cleaned up by calling wgpuAdapterInfoFreeMembers once it
is no longer in use.

Implements rdar://156889370.
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -7887,8 +7887,9 @@ getRefParentDecls(const clang::RecordDecl *decl, ASTContext &ctx,
   return matchingDecls;
 }
 
-static llvm::SmallVector<ValueDecl *, 1>
-getValueDeclsForName(const clang::Decl *decl, ASTContext &ctx, StringRef name) {
+llvm::SmallVector<ValueDecl *, 1>
+importer::getValueDeclsForName(
+    const clang::Decl *decl, ASTContext &ctx, StringRef name) {
   llvm::SmallVector<ValueDecl *, 1> results;
   auto *clangMod = decl->getOwningModule();
   if (clangMod && clangMod->isSubModule())
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
@@ -2687,10 +2687,103 @@ namespace {
         }
       }
 
+      // A type imported as noncopyable, check whether an explicit deinit
+      // should be introduced to call a user-defined "destroy" function.
+      if (recordHasMoveOnlySemantics(decl)) {
+        addExplicitDeinitIfRequired(result, decl);
+      }
+
       result->setMemberLoader(&Impl, 0);
       return result;
     }
 
+    /// Find an explicitly-provided "destroy" operation specified for the
+    /// given Clang type and return it.
+    static FuncDecl *findExplicitDestroy(
+        NominalTypeDecl *nominal, const clang::TypeDecl *clangType) {
+      if (!clangType->hasAttrs())
+        return nullptr;
+
+      llvm::TinyPtrVector<FuncDecl *> matchingDestroyFuncs;
+      for (auto attr : clangType->getAttrs()) {
+        auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr);
+        if (!swiftAttr)
+          continue;
+
+        auto attributeName = swiftAttr->getAttribute();
+        if (!attributeName.starts_with("destroy:"))
+          continue;
+
+        auto destroyFuncName = attributeName.drop_front(strlen("destroy:"));
+        auto decls = getValueDeclsForName(
+            clangType, nominal->getASTContext(), destroyFuncName);
+        for (auto decl : decls) {
+          auto func = dyn_cast<FuncDecl>(decl);
+          if (!func)
+            continue;
+
+          auto params = func->getParameters();
+          if (params->size() != 1)
+            continue;
+
+          if (!params->get(0)->getInterfaceType()->isEqual(
+                  nominal->getDeclaredInterfaceType()))
+            continue;
+
+          matchingDestroyFuncs.push_back(func);
+        }
+      }
+
+      if (matchingDestroyFuncs.size() == 1)
+        return matchingDestroyFuncs[0];
+
+      return nullptr;
+    }
+
+    /// Function body synthesizer for a deinit of a noncopyable type, which
+    /// passes "self" to the given "destroy" function.
+    static std::pair<BraceStmt *, bool>
+    synthesizeDeinitBodyForCustomDestroy(
+        AbstractFunctionDecl *deinitFunc, void *opaqueDestroyFunc) {
+      auto deinit = cast<DestructorDecl>(deinitFunc);
+      auto destroyFunc = static_cast<FuncDecl *>(opaqueDestroyFunc);
+
+      ASTContext &ctx = deinit->getASTContext();
+      auto funcRef = new (ctx) DeclRefExpr(
+          destroyFunc, DeclNameLoc(), /*Implicit=*/true);
+      auto selfRef = new (ctx) DeclRefExpr(
+          deinit->getImplicitSelfDecl(), DeclNameLoc(), /*Implicit=*/true);
+      auto callExpr = CallExpr::createImplicit(
+          ctx, funcRef,
+          ArgumentList::createImplicit(
+            ctx,
+            { Argument(SourceLoc(), Identifier(), selfRef)}
+          )
+      );
+
+      auto braceStmt = BraceStmt::createImplicit(ctx, { ASTNode(callExpr) });
+      return std::make_pair(braceStmt, /*typechecked=*/false);
+    }
+
+    /// For a type that is imported as noncopyable, look for an
+    /// explicitly-provided "destroy" operation. If present, introduce a deinit
+    /// that calls it.
+    void addExplicitDeinitIfRequired(
+        NominalTypeDecl *nominal, const clang::TypeDecl *clangType) {
+      auto destroyFunc = findExplicitDestroy(nominal, clangType);
+      if (!destroyFunc)
+        return;
+
+      ASTContext &ctx = Impl.SwiftContext;
+      auto destructor = new (ctx) DestructorDecl(SourceLoc(), nominal);
+      destructor->setSynthesized(true);
+      destructor->copyFormalAccessFrom(nominal, /*sourceIsParentContext*/true);
+      destructor->setBodySynthesizer(
+          synthesizeDeinitBodyForCustomDestroy, destroyFunc);
+
+      nominal->addMember(destructor);
+    }
+
     void validatePrivateFileIDAttributes(const clang::CXXRecordDecl *decl) {
       auto anns = importer::getPrivateFileIDAttrs(decl);
 
diff --git a/lib/ClangImporter/ImporterImpl.h b/lib/ClangImporter/ImporterImpl.h
@@ -2179,6 +2179,14 @@ inline clang::QualType desugarIfBoundsAttributed(clang::QualType type) {
 /// If \a type is an elaborated type, it should be desugared first.
 ImportedType findOptionSetEnum(clang::QualType type,
                                ClangImporter::Implementation &Impl);
+
+/// Find value declarations in the same module as the given Clang declaration
+/// and with the given name.
+///
+/// The name we're looking for is the Swift name.
+llvm::SmallVector<ValueDecl *, 1>
+getValueDeclsForName(const clang::Decl *decl, ASTContext &ctx, StringRef name);
+
 } // end namespace importer
 } // end namespace swift
 
diff --git a/lib/IRGen/GenStruct.cpp b/lib/IRGen/GenStruct.cpp
@@ -374,12 +374,14 @@ namespace {
                                 unsigned explosionSize, llvm::Type *storageType,
                                 Size size, SpareBitVector &&spareBits,
                                 Alignment align,
+                                IsTriviallyDestroyable_t isTriviallyDestroyable,
+                                IsCopyable_t isCopyable,
                                 const clang::RecordDecl *clangDecl)
         : StructTypeInfoBase(StructTypeInfoKind::LoadableClangRecordTypeInfo,
                              fields, explosionSize, FieldsAreABIAccessible,
                              storageType, size, std::move(spareBits), align,
-                             IsTriviallyDestroyable,
-                             IsCopyable,
+                             isTriviallyDestroyable,
+                             isCopyable,
                              IsFixedSize, IsABIAccessible),
           ClangDecl(clangDecl) {}
 
@@ -469,6 +471,7 @@ namespace {
     AddressOnlyPointerAuthRecordTypeInfo(ArrayRef<ClangFieldInfo> fields,
                                          llvm::Type *storageType, Size size,
                                          Alignment align,
+                                         IsCopyable_t isCopyable,
                                          const clang::RecordDecl *clangDecl)
         : StructTypeInfoBase(StructTypeInfoKind::AddressOnlyClangRecordTypeInfo,
                              fields, FieldsAreABIAccessible, storageType, size,
@@ -477,7 +480,7 @@ namespace {
                              SpareBitVector(std::optional<APInt>{
                                  llvm::APInt(size.getValueInBits(), 0)}),
                              align, IsNotTriviallyDestroyable,
-                             IsNotBitwiseTakable, IsCopyable, IsFixedSize,
+                             IsNotBitwiseTakable, isCopyable, IsFixedSize,
                              IsABIAccessible),
           clangDecl(clangDecl) {
       (void)clangDecl;
@@ -645,6 +648,7 @@ namespace {
     AddressOnlyCXXClangRecordTypeInfo(ArrayRef<ClangFieldInfo> fields,
                                       llvm::Type *storageType, Size size,
                                       Alignment align,
+                                      IsCopyable_t isCopyable,
                                       const clang::RecordDecl *clangDecl)
         : StructTypeInfoBase(StructTypeInfoKind::AddressOnlyClangRecordTypeInfo,
                              fields, FieldsAreABIAccessible, storageType, size,
@@ -654,9 +658,7 @@ namespace {
                                  llvm::APInt(size.getValueInBits(), 0)}),
                              align, IsNotTriviallyDestroyable,
                              IsNotBitwiseTakable,
-                             // TODO: Set this appropriately for the type's
-                             // C++ import behavior.
-                             IsCopyable, IsFixedSize, IsABIAccessible),
+                             isCopyable, IsFixedSize, IsABIAccessible),
           ClangDecl(clangDecl) {
       (void)ClangDecl;
     }
@@ -1342,15 +1344,26 @@ class ClangRecordLowering {
     llvmType->setBody(LLVMFields, /*packed*/ true);
     if (SwiftType.getStructOrBoundGenericStruct()->isCxxNonTrivial()) {
       return AddressOnlyCXXClangRecordTypeInfo::create(
-          FieldInfos, llvmType, TotalStride, TotalAlignment, ClangDecl);
+          FieldInfos, llvmType, TotalStride, TotalAlignment,
+          (SwiftDecl && !SwiftDecl->canBeCopyable())
+            ? IsNotCopyable : IsCopyable,
+          ClangDecl);
     }
     if (SwiftType.getStructOrBoundGenericStruct()->isNonTrivialPtrAuth()) {
       return AddressOnlyPointerAuthRecordTypeInfo::create(
-          FieldInfos, llvmType, TotalStride, TotalAlignment, ClangDecl);
+          FieldInfos, llvmType, TotalStride, TotalAlignment,
+          (SwiftDecl && !SwiftDecl->canBeCopyable())
+            ? IsNotCopyable : IsCopyable,
+          ClangDecl);
     }
     return LoadableClangRecordTypeInfo::create(
         FieldInfos, NextExplosionIndex, llvmType, TotalStride,
-        std::move(SpareBits), TotalAlignment, ClangDecl);
+        std::move(SpareBits), TotalAlignment,
+        (SwiftDecl && SwiftDecl->getValueTypeDestructor())
+          ? IsNotTriviallyDestroyable : IsTriviallyDestroyable,
+        (SwiftDecl && !SwiftDecl->canBeCopyable())
+          ? IsNotCopyable : IsCopyable,
+        ClangDecl);
   }
 
 private:
diff --git a/lib/SILGen/SILGen.h b/lib/SILGen/SILGen.h
@@ -84,6 +84,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   /// Set of delayed conformances that have already been forced.
   llvm::DenseSet<NormalProtocolConformance *> forcedConformances;
 
+  /// Imported noncopyable types that we have seen.
+  llvm::DenseSet<NominalTypeDecl *> importedNontrivialNoncopyableTypes;
+
   size_t anonymousSymbolCounter = 0;
 
   std::optional<SILDeclRef> StringToNSStringFn;
@@ -282,6 +285,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   void visitMacroDecl(MacroDecl *d);
   void visitMacroExpansionDecl(MacroExpansionDecl *d);
 
+  void visitImportedNontrivialNoncopyableType(NominalTypeDecl *nominal);
+
   // Same as AbstractStorageDecl::visitEmittedAccessors, but skips over skipped
   // (unavailable) decls.
   void visitEmittedAccessors(AbstractStorageDecl *D,
diff --git a/lib/SILGen/SILGenLazyConformance.cpp b/lib/SILGen/SILGenLazyConformance.cpp
@@ -110,6 +110,13 @@ void SILGenModule::useConformancesFromType(CanType type) {
     if (isa<ProtocolDecl>(decl))
       return;
 
+    // If this is an imported noncopyable type with a deinitializer, record it.
+    if (decl->hasClangNode() && !decl->canBeCopyable() &&
+        decl->getValueTypeDestructor() &&
+        importedNontrivialNoncopyableTypes.insert(decl).second) {
+      visitImportedNontrivialNoncopyableType(decl);
+    }
+
     auto genericSig = decl->getGenericSignature();
     if (!genericSig)
       return;
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -1577,6 +1577,13 @@ void SILGenModule::visitNominalTypeDecl(NominalTypeDecl *ntd) {
   SILGenType(*this, ntd).emitType();
 }
 
+void SILGenModule::visitImportedNontrivialNoncopyableType(
+  NominalTypeDecl *nominal) {
+  emitNonCopyableTypeDeinitTable(nominal);
+  SILGenType(*this, nominal)
+      .visitDestructorDecl(nominal->getValueTypeDestructor());
+}
+
 /// SILGenExtension - an ASTVisitor for generating SIL from method declarations
 /// and protocol conformances inside type extensions.
 class SILGenExtension : public TypeMemberVisitor<SILGenExtension> {
diff --git a/test/Interop/C/struct/Inputs/noncopyable-struct.h b/test/Interop/C/struct/Inputs/noncopyable-struct.h
@@ -3,3 +3,17 @@
 typedef struct __attribute__((swift_attr("~Copyable"))) NonCopyable {
   float x, y;
 } NonCopyable;
+
+typedef struct __attribute__((swift_attr("~Copyable"))) __attribute__((swift_attr("destroy:freeNonCopyableWithDeinit"))) NonCopyableWithDeinit {
+  void *storage;
+} NonCopyableWithDeinit;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void freeNonCopyableWithDeinit(NonCopyableWithDeinit ncd);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/test/Interop/C/struct/noncopyable_structs.swift b/test/Interop/C/struct/noncopyable_structs.swift
@@ -5,18 +5,22 @@
 // RUN: %target-swift-frontend -emit-sil -I %S/Inputs/ %s -verify -DERRORS
 // RUN: %target-swift-frontend -emit-sil -I %S/Inputs/ %s -verify -DERRORS -cxx-interoperability-mode=default
 
+// Check that we get the expected SIL
+// RUN: %target-swift-frontend -emit-sil -I %S/Inputs/ %s -o - | %FileCheck -check-prefix CHECK-SIL %s
+// RUN: %target-swift-frontend -emit-sil -I %S/Inputs/ %s -o - -cxx-interoperability-mode=default| %FileCheck  -check-prefix CHECK-SIL %s
+
 // Check that we get the expected IR
 
-// RUN: %target-swift-frontend -emit-ir -I %S/Inputs/ %s -o - | %FileCheck %s
-// RUN: %target-swift-frontend -emit-ir -I %S/Inputs/ %s -o - -cxx-interoperability-mode=default| %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -I %S/Inputs/ %s -o - | %FileCheck -check-prefix CHECK-IR %s
+// RUN: %target-swift-frontend -emit-ir -I %S/Inputs/ %s -o - -cxx-interoperability-mode=default | %FileCheck -check-prefix CHECK-IR %s
 
 import NoncopyableStructs
 
-// CHECK-LABEL: define hidden swiftcc void @"$s19noncopyable_structs9consumeNCyySo11NonCopyableVnF"(float %0, float %1) #0 {
-// CHECK: call ptr @"$sSo11NonCopyableVWOh"
-// CHECK: define linkonce_odr hidden ptr @"$sSo11NonCopyableVWOh"(ptr %0)
-// CHECK-NEXT: entry:
-// CHECK-NEXT: ret ptr
+// CHECK-IR-LABEL: define hidden swiftcc void @"$s19noncopyable_structs9consumeNCyySo11NonCopyableVnF"(float %0, float %1) #0 {
+// CHECK-IR: call ptr @"$sSo11NonCopyableVWOh"
+// CHECK-IR: define linkonce_odr hidden ptr @"$sSo11NonCopyableVWOh"(ptr %0)
+// CHECK-IR-NEXT: entry:
+// CHECK-IR-NEXT: ret ptr
 func consumeNC(_ nc: consuming NonCopyable) { }
 
 func testNC() {
@@ -27,3 +31,31 @@ func testNC() {
   consumeNC(nc) // expected-note{{consumed again here}}
   #endif
 }
+
+func consumeNCWithDeinit(_ nc: consuming NonCopyableWithDeinit) { }
+
+func testNCWithDeinit() {
+  let nc = NonCopyableWithDeinit() // expected-error{{'nc' consumed more than once}}
+  consumeNCWithDeinit(nc) // expected-note{{consumed here}}
+
+  #if ERRORS
+  consumeNCWithDeinit(nc) // expected-note{{consumed again here}}
+  #endif
+}
+
+// CHECK-SIL: sil shared @$sSo21NonCopyableWithDeinitVfD : $@convention(method) (@owned NonCopyableWithDeinit) -> () {
+// CHECK-SIL: bb0([[SELF:%[0-9]+]] : $NonCopyableWithDeinit):
+// CHECK-SIL: [[SELF_ALLOC:%[0-9]+]] = alloc_stack $NonCopyableWithDeinit
+// CHECK-SIL:  store [[SELF]] to [[SELF_ALLOC]]
+// CHECK-SIL: [[SELF_RELOAD:%[0-9]+]] = load [[SELF_ALLOC]]
+// CHECK-SIL: [[FN:%[0-9]+]] = function_ref @{{.*}}freeNonCopyableWithDeinit : $@convention(c) (NonCopyableWithDeinit) -> ()
+// CHECK-SIL:  apply [[FN]]([[SELF_RELOAD]]) : $@convention(c) (NonCopyableWithDeinit) -> ()
+
+// CHECK-IR-LABEL: define hidden swiftcc void @"$s19noncopyable_structs19consumeNCWithDeinityySo015NonCopyableWithE0VnF"
+// CHECK-IR: call swiftcc void @"$sSo21NonCopyableWithDeinitVfD"
+
+// CHECK-IR-LABEL: define {{.*}} swiftcc void @"$sSo21NonCopyableWithDeinitVfD"
+// CHECK-IR: {{(call|invoke)}} void @{{.*}}freeNonCopyableWithDeinit
+
+// CHECK-SIL-LABEL: sil_moveonlydeinit NonCopyableWithDeinit {
+// CHECK-SIL: @$sSo21NonCopyableWithDeinitVfD
