Fix file cloning in attachments broken by #1547. (#1552)

I broke file cloning in #1547, but I did it in a bunch of different ways
that mostly cancelled each other out, so tests ended up passing
spuriously.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: grynspan

Sources/Overlays/_Testing_Foundation/Attachments/_AttachableURLWrapper.swift

@@ -116,6 +116,11 @@ extension _AttachableURLWrapper: AttachableWrapper {
 
 #if !SWT_NO_FILE_CLONING
 extension _AttachableURLWrapper: FileClonable {
+#if os(FreeBSD)
+  /// An integer encoding the FreeBSD version number.
+  private static let _freeBSDVersion = getosreldate()
+#endif
+
   public borrowing func clone(toFileAtPath filePath: String) -> Bool {
 #if SWT_TARGET_OS_APPLE || os(Linux) || os(FreeBSD)
     guard let srcFD = _fileHandle?.fileDescriptor else {
@@ -134,16 +139,22 @@ extension _AttachableURLWrapper: FileClonable {
       close(dstFD)
     }
 #if os(Linux)
-    return -1 != ioctl(dstFD, swt_FICLONE(), srcFD)
+    let fileCloned = -1 != ioctl(dstFD, swt_FICLONE(), srcFD)
 #elseif os(FreeBSD)
     var flags = CUnsignedInt(0)
     if Self._freeBSDVersion >= 1500000 {
       // `COPY_FILE_RANGE_CLONE` was introduced in FreeBSD 15.0, but on 14.3
       // we can still benefit from an in-kernel copy instead.
       flags |= swt_COPY_FILE_RANGE_CLONE()
     }
-    return -1 != copy_file_range(srcFD, nil, dstFD, nil, Int(SSIZE_MAX), flags)
+    let fileCloned = -1 != copy_file_range(srcFD, nil, dstFD, nil, Int(SSIZE_MAX), flags)
 #endif
+    if !fileCloned {
+      // Failed to clone, but we already created the file, so we must unlink it
+      // so the fallback path works.
+      _ = unlink(filePath)
+    }
+    return fileCloned
 #elseif os(Windows)
     // TODO: Windows implementation
     // Block cloning on Windows is only supported by ReFS which is not in

Sources/Testing/Attachments/Attachment.swift

@@ -137,6 +137,9 @@ public struct AnyAttachable: AttachableWrapper, Sendable, Copyable {
     _estimatedAttachmentByteCount = { attachment.attachableValue.estimatedAttachmentByteCount }
     _withUnsafeBytes = { try attachment.withUnsafeBytes($0) }
     _preferredName = { attachment.attachableValue.preferredName(for: attachment, basedOn: $0) }
+#if !SWT_NO_FILE_CLONING
+    _clone = { attachment.attachableValue.clone(toFileAtPath: $0, for: attachment) }
+#endif
   }
 
   /// The implementation of ``estimatedAttachmentByteCount`` borrowed from the
@@ -166,8 +169,22 @@ public struct AnyAttachable: AttachableWrapper, Sendable, Copyable {
   public borrowing func preferredName(for attachment: borrowing Attachment<Self>, basedOn suggestedName: String) -> String {
     _preferredName(suggestedName)
   }
+
+#if !SWT_NO_FILE_CLONING
+  /// The implementation of ``clone(toFileAtPath:)`` borrowed from the original
+  /// attachment.
+  private var _clone: @Sendable (String) -> Bool
+
+  package func clone(toFileAtPath filePath: String) -> Bool {
+    _clone(filePath)
+  }
+#endif
 }
 
+#if !SWT_NO_FILE_CLONING
+extension AnyAttachable: FileClonable {}
+#endif
+
 // MARK: - Describing an attachment
 
 @_preInverseGenerics
@@ -376,6 +393,25 @@ extension Attachment where AttachableValue: ~Copyable {
 // MARK: - Writing
 
 extension Attachable where Self: ~Copyable {
+#if !SWT_NO_FILE_CLONING
+  /// Clone the file this instance represents to the given file path if it
+  /// conforms to ``FileClonable``.
+  ///
+  /// - Parameters:
+  ///   - filePath: The path to clone this instance to.
+  ///
+  /// - Returns: Whether or not the file was successfully cloned.
+  ///
+  /// See ``FileClonable`` for more information.
+  fileprivate func clone(toFileAtPath filePath: String, for attachment: borrowing Attachment<Self>) -> Bool {
+    if #available(_castingWithNonCopyableGenerics, *),
+       let self = makeExistential(self) as? any FileClonable {
+      return self.clone(toFileAtPath: filePath)
+    }
+    return false
+  }
+#endif
+
   /// Write this instance to the given file system path.
   ///
   /// - Parameters:
@@ -390,9 +426,7 @@ extension Attachable where Self: ~Copyable {
   /// then passes it to `_write(toFILE:for:)`.
   borrowing func write(toFileAtPath filePath: String, for attachment: borrowing Attachment<Self>) throws {
 #if !SWT_NO_FILE_CLONING
-    if #available(_castingWithNonCopyableGenerics, *),
-       let self = makeExistential(self) as? any FileClonable,
-       self.clone(toFileAtPath: filePath) {
+    if clone(toFileAtPath: filePath, for: attachment) {
       return
     }
 #endif

Tests/TestingTests/AttachmentTests.swift

@@ -202,6 +202,31 @@ struct AttachmentTests {
   }
 #endif
 
+  @Test func cloneAttachment() async throws {
+    struct MyFileClonable: Attachable, FileClonable {
+      var withUnsafeBytesCalled: Confirmation
+
+      func withUnsafeBytes<R>(for attachment: borrowing Attachment<Self>, _ body: (UnsafeRawBufferPointer) throws -> R) throws -> R {
+        withUnsafeBytesCalled()
+        return try Array<UInt8>().withUnsafeBytes(body)
+      }
+
+      var cloneCalled: Confirmation
+
+      func clone(toFileAtPath filePath: String) -> Bool {
+        cloneCalled()
+        return true // don't actually write anything
+      }
+    }
+
+    try await confirmation("withUnsafeBytes(for:_:) called", expectedCount: 0) { withUnsafeBytesCalled in
+      try await confirmation("clone(toFileAtPath:) called") { cloneCalled in
+        let attachableValue = MyFileClonable(withUnsafeBytesCalled: withUnsafeBytesCalled, cloneCalled: cloneCalled)
+        _ = try Attachment(attachableValue).write(toFileInDirectoryAtPath: "/not/real/directory/")
+      }
+    }
+  }
+
   @Test func attachValue() async {
     await confirmation("Attachment detected", expectedCount: 2) { valueAttached in
       var configuration = Configuration()