From a46a543febba846be5dde856ccf0ca7ce7677bde Mon Sep 17 00:00:00 2001 From: Sandeep Vijayarao Date: Wed, 11 Nov 2026 00:24:31 -0800 Subject: [PATCH 1/2] [TrailingElements] Don't deinitialize elements when the initializer throws `TrailingArray.init(header:initializingTrailingElementsWith:)` created the value with just its header, then ran the initializer. If the initializer threw, the half-built value was destroyed, so `deinit` deinitialized all `trailingCount` elements, even though the output span had already deinitialized the ones it had initialized and the rest were never initialized. `withTemporaryValue(header:initializingTrailingElementsWith:body:)` had the same problem through the `defer` in `_withTemporaryValue`. With non-trivial elements (e.g. class references) both crashed. Initialize the trailing elements before creating the `TrailingArray`, and if the initializer throws, only deinitialize the header (and free the heap storage) before rethrowing. --- .../TrailingArray.swift | 71 +++++++++++++--- .../TrailingElementsTests.swift | 82 +++++++++++++++++++ 2 files changed, 140 insertions(+), 13 deletions(-) diff --git a/Sources/TrailingElementsModule/TrailingArray.swift b/Sources/TrailingElementsModule/TrailingArray.swift index 53a840f6..7b04c994 100644 --- a/Sources/TrailingElementsModule/TrailingArray.swift +++ b/Sources/TrailingElementsModule/TrailingArray.swift @@ -58,15 +58,23 @@ where Header: ~Copyable unsafe _pointer.initialize(to: header) } + /// Initialize the trailing elements that follow the header at `pointer`. + /// + /// If `initializer` throws, the output span deinitializes the elements it + /// has initialized so far, so the caller only needs to clean up the header. @available(SwiftStdlib 5.1, *) @_alwaysEmitIntoClient - mutating func _initializeTrailingElements( + @unsafe + static func _initializeTrailingElements( + after pointer: UnsafeMutablePointer
, initializer: (inout OutputSpan) throws(E) -> Void ) throws(E) { - var output = unsafe OutputSpan(buffer: rawElements, initializedCount: 0) + let elements = unsafe _elements(after: pointer) + var output = unsafe OutputSpan(buffer: elements, initializedCount: 0) try initializer(&output) - let initialized = unsafe output.finalize(for: rawElements) - precondition(count == initialized, "TrailingArray initialization underflow") + let initialized = unsafe output.finalize(for: elements) + precondition( + elements.count == initialized, "TrailingArray initialization underflow") } /// Allocate an intrusive managed buffer with the given header and calling @@ -77,8 +85,22 @@ where Header: ~Copyable header: consuming Header, initializingTrailingElementsWith initializer: (inout OutputSpan) throws(E) -> Void ) throws(E) { - self.init(_headerOnly: header) - try _initializeTrailingElements(initializer: initializer) + let (bytes, alignment) = Self.allocationSize(header: header) + let storage = unsafe UnsafeMutableRawPointer.allocate( + byteCount: bytes, + alignment: alignment) + let pointer = unsafe Self.headerPointer(fromStorage: storage) + unsafe pointer.initialize(to: header) + do throws(E) { + try unsafe Self._initializeTrailingElements( + after: pointer, initializer: initializer) + } catch { + // The trailing elements aren't initialized, so don't let `deinit` run. + unsafe pointer.deinitialize(count: 1) + unsafe storage.deallocate() + throw error + } + unsafe self._storage = storage } /// Allocate an intrusive managed buffer with the given header and @@ -184,10 +206,18 @@ where Header: ~Copyable @_alwaysEmitIntoClient @unsafe var rawElements: UnsafeMutableBufferPointer { + unsafe Self._elements(after: _pointer) + } + + @_alwaysEmitIntoClient + @unsafe + static func _elements( + after pointer: UnsafeMutablePointer
+ ) -> UnsafeMutableBufferPointer { unsafe UnsafeMutableBufferPointer( - start: UnsafeMutableRawPointer(_pointer.advanced(by: 1)) + start: UnsafeMutableRawPointer(pointer.advanced(by: 1)) .assumingMemoryBound(to: Element.self), - count: header.trailingCount + count: pointer.pointee.trailingCount ) } @@ -334,11 +364,13 @@ extension TrailingArray where Header: Copyable { body: (inout TrailingArray
) throws(E) -> R ) throws(E) -> R { return unsafe try _withTemporaryValue( - header: header, uninitializedTrailingElements: () - ) { (value) throws(E) in - try value._initializeTrailingElements(initializer: initializer) - return try body(&value) - } + header: header, + uninitializedTrailingElements: (), + initializingTrailingElements: { (pointer) throws(E) in + try unsafe _initializeTrailingElements( + after: pointer, initializer: initializer) + }, + body: body) } } @@ -353,6 +385,9 @@ extension TrailingArray { static func _withTemporaryValue( header: Header, uninitializedTrailingElements: (), + initializingTrailingElements: ( + UnsafeMutablePointer
+ ) throws(E) -> Void = { _ in }, body: (inout TrailingArray
) throws(E) -> R ) throws(E) -> R { let (numBytes, alignment) = allocationSize(header: header) @@ -367,6 +402,16 @@ extension TrailingArray { let headerPointer = unsafe TrailingArray.headerPointer(fromStorage: storagePointer) unsafe headerPointer.initialize(to: header) + // Initialize the trailing elements, if requested, before creating the + // trailing array, so a throwing initializer doesn't leave behind + // a value whose elements aren't initialized. + do throws(E) { + try initializingTrailingElements(headerPointer) + } catch { + unsafe headerPointer.deinitialize(count: 1) + throw error + } + /// Create a trailing array over that temporary storage. var managedBuffer: Optional = unsafe TrailingArray( consuming: headerPointer, diff --git a/Tests/TrailingElementsTests/TrailingElementsTests.swift b/Tests/TrailingElementsTests/TrailingElementsTests.swift index 9c12fe3f..c165a970 100644 --- a/Tests/TrailingElementsTests/TrailingElementsTests.swift +++ b/Tests/TrailingElementsTests/TrailingElementsTests.swift @@ -59,6 +59,28 @@ struct ManyBytesWithPointers: @unsafe TrailingElements { var trailingCount: Int { Int(bytes.0) } } +final class LiveCounter { + var count = 0 +} + +final class Tracked { + let counter: LiveCounter + + init(_ counter: LiveCounter) { + self.counter = counter + counter.count += 1 + } + + deinit { counter.count -= 1 } +} + +struct TrackedList: TrailingElements { + typealias Element = Tracked + var trailingCount: Int +} + +struct InitializationError: Error {} + @Suite("Trailing elements tests") struct TrailingElementsTests { @Test func simpleCoordinates() { @@ -183,4 +205,64 @@ struct TrailingElementsTests { } } } + + @Test(arguments: 0 ... 3) + func throwingInitializerOnHeap(initializedCount: Int) { + let counter = LiveCounter() + #expect(throws: InitializationError.self) { + _ = try TrailingArray( + header: TrackedList(trailingCount: 3) + ) { (outputSpan) throws(InitializationError) in + for _ in 0 ..< initializedCount { + outputSpan.append(Tracked(counter)) + } + throw InitializationError() + } + } + #expect(counter.count == 0) + } + + @Test(arguments: 0 ... 3) + func throwingInitializerOnStack(initializedCount: Int) { + let counter = LiveCounter() + let initializer: (inout OutputSpan) throws(InitializationError) -> Void = { + outputSpan throws(InitializationError) in + for _ in 0 ..< initializedCount { + outputSpan.append(Tracked(counter)) + } + throw InitializationError() + } + let body: (inout TrailingArray) throws(InitializationError) -> Void = { _ in + Issue.record("body shouldn't be called") + } + #expect(throws: InitializationError.self) { + try TrailingArray.withTemporaryValue( + header: TrackedList(trailingCount: 3), + initializingTrailingElementsWith: initializer, + body: body) + } + #expect(counter.count == 0) + } + + @Test func trackedElementsAreReleased() { + let counter = LiveCounter() + do { + let tracked = TrailingArray(header: TrackedList(trailingCount: 3)) { outputSpan in + for _ in 0 ..< 3 { + outputSpan.append(Tracked(counter)) + } + } + #expect(counter.count == 3) + #expect(tracked.count == 3) + } + #expect(counter.count == 0) + + TrailingArray.withTemporaryValue(header: TrackedList(trailingCount: 2)) { outputSpan in + outputSpan.append(Tracked(counter)) + outputSpan.append(Tracked(counter)) + } body: { tracked in + #expect(counter.count == 2) + } + #expect(counter.count == 0) + } } From 0165c6e71c076cf043aabc846a6202f451fe6f38 Mon Sep 17 00:00:00 2001 From: Sandeep Vijayarao Date: Mon, 16 Nov 2026 18:10:52 -0800 Subject: [PATCH 2/2] Use LifetimeTracked in the trailing elements tests --- Package.swift | 2 +- Package@swift-6.2.swift | 2 +- .../TrailingElementsTests.swift | 49 +++++++------------ 3 files changed, 20 insertions(+), 33 deletions(-) diff --git a/Package.swift b/Package.swift index 7e33be35..2d2ca1e9 100644 --- a/Package.swift +++ b/Package.swift @@ -344,7 +344,7 @@ let targets: [CustomTarget] = [ .target( kind: .test, name: "TrailingElementsTests", - dependencies: ["TrailingElementsModule"]), + dependencies: ["TrailingElementsModule", "_CollectionsTestSupport"]), .target( kind: .exported, diff --git a/Package@swift-6.2.swift b/Package@swift-6.2.swift index efb8ed3a..c4d3ce20 100644 --- a/Package@swift-6.2.swift +++ b/Package@swift-6.2.swift @@ -342,7 +342,7 @@ let targets: [CustomTarget] = [ .target( kind: .test, name: "TrailingElementsTests", - dependencies: ["TrailingElementsModule"]), + dependencies: ["TrailingElementsModule", "_CollectionsTestSupport"]), .target( kind: .exported, diff --git a/Tests/TrailingElementsTests/TrailingElementsTests.swift b/Tests/TrailingElementsTests/TrailingElementsTests.swift index c165a970..94ac712d 100644 --- a/Tests/TrailingElementsTests/TrailingElementsTests.swift +++ b/Tests/TrailingElementsTests/TrailingElementsTests.swift @@ -16,6 +16,7 @@ import Testing #if COLLECTIONS_SINGLE_MODULE import Collections #else +import _CollectionsTestSupport import TrailingElementsModule #endif @@ -59,23 +60,8 @@ struct ManyBytesWithPointers: @unsafe TrailingElements { var trailingCount: Int { Int(bytes.0) } } -final class LiveCounter { - var count = 0 -} - -final class Tracked { - let counter: LiveCounter - - init(_ counter: LiveCounter) { - self.counter = counter - counter.count += 1 - } - - deinit { counter.count -= 1 } -} - struct TrackedList: TrailingElements { - typealias Element = Tracked + typealias Element = LifetimeTracked var trailingCount: Int } @@ -208,27 +194,28 @@ struct TrailingElementsTests { @Test(arguments: 0 ... 3) func throwingInitializerOnHeap(initializedCount: Int) { - let counter = LiveCounter() + let tracker = LifetimeTracker() #expect(throws: InitializationError.self) { _ = try TrailingArray( header: TrackedList(trailingCount: 3) ) { (outputSpan) throws(InitializationError) in for _ in 0 ..< initializedCount { - outputSpan.append(Tracked(counter)) + outputSpan.append(tracker.instance(for: 0)) } throw InitializationError() } } - #expect(counter.count == 0) + #expect(tracker.instances == 0) } @Test(arguments: 0 ... 3) func throwingInitializerOnStack(initializedCount: Int) { - let counter = LiveCounter() - let initializer: (inout OutputSpan) throws(InitializationError) -> Void = { + let tracker = LifetimeTracker() + let initializer: + (inout OutputSpan>) throws(InitializationError) -> Void = { outputSpan throws(InitializationError) in for _ in 0 ..< initializedCount { - outputSpan.append(Tracked(counter)) + outputSpan.append(tracker.instance(for: 0)) } throw InitializationError() } @@ -241,28 +228,28 @@ struct TrailingElementsTests { initializingTrailingElementsWith: initializer, body: body) } - #expect(counter.count == 0) + #expect(tracker.instances == 0) } @Test func trackedElementsAreReleased() { - let counter = LiveCounter() + let tracker = LifetimeTracker() do { let tracked = TrailingArray(header: TrackedList(trailingCount: 3)) { outputSpan in for _ in 0 ..< 3 { - outputSpan.append(Tracked(counter)) + outputSpan.append(tracker.instance(for: 0)) } } - #expect(counter.count == 3) + #expect(tracker.instances == 3) #expect(tracked.count == 3) } - #expect(counter.count == 0) + #expect(tracker.instances == 0) TrailingArray.withTemporaryValue(header: TrackedList(trailingCount: 2)) { outputSpan in - outputSpan.append(Tracked(counter)) - outputSpan.append(Tracked(counter)) + outputSpan.append(tracker.instance(for: 0)) + outputSpan.append(tracker.instance(for: 0)) } body: { tracked in - #expect(counter.count == 2) + #expect(tracker.instances == 2) } - #expect(counter.count == 0) + #expect(tracker.instances == 0) } }