Merge pull request #2218 from swiftlang/automerge/merge-main-2026-08-30_09-07

Author: jmschonfeld

Sources/FoundationEssentials/Data/Data.swift

@@ -768,9 +768,6 @@ public struct Data : RandomAccessCollection, MutableCollection, RangeReplaceable
     /// - parameter range: The range in the data to set to `0`.
     @inlinable // This is @inlinable as trivially forwarding.
     public mutating func resetBytes(in range: Range<Index>) {
-        // it is worth noting that the range here may be out of bounds of the Data itself (which triggers a growth)
-        precondition(range.lowerBound >= 0, "Ranges must not be negative bounds")
-        precondition(range.upperBound >= 0, "Ranges must not be negative bounds")
         _representation.resetBytes(in: range)
     }
 

Sources/FoundationEssentials/Data/Representations/Data+Inline.swift

@@ -257,7 +257,7 @@ extension Data {
         mutating func resetBytes(in range: Range<Index>) {
             assert(range.lowerBound <= MemoryLayout<Buffer>.size)
             assert(range.upperBound <= MemoryLayout<Buffer>.size)
-            precondition(range.lowerBound <= length, "index \(range.lowerBound) is out of bounds of 0..<\(length)")
+            precondition(range.lowerBound >= 0 && range.lowerBound <= length, "index \(range.lowerBound) is out of bounds of 0..<\(length)")
             if length < range.upperBound {
                 length = UInt8(range.upperBound)
             }

Sources/FoundationEssentials/Data/Representations/Data+InlineSlice.swift

@@ -261,7 +261,7 @@ extension Data {
         mutating func resetBytes(in range: Range<Index>) {
             assert(range.lowerBound < HalfInt.max)
             assert(range.upperBound < HalfInt.max)
-            precondition(range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
+            precondition(range.lowerBound >= startIndex && range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
             ensureUniqueReference()
             storage.resetBytes(in: range)
             if slice.upperBound < range.upperBound {

Sources/FoundationEssentials/Data/Representations/Data+LargeSlice.swift

@@ -244,7 +244,7 @@ extension Data {
 
         @inlinable // This is @inlinable as reasonably small.
         mutating func resetBytes(in range: Range<Int>) {
-            precondition(range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
+            precondition(range.lowerBound >= startIndex && range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
             ensureUniqueReference()
             storage.resetBytes(in: range)
             if slice.range.upperBound < range.upperBound {

Sources/FoundationEssentials/Data/Representations/Data+LegacyRepresentation.swift

@@ -517,16 +517,14 @@ extension Data {
         mutating func resetBytes(in range: Range<Index>) {
             switch self {
             case .empty:
+                precondition(range.lowerBound == 0, "index \(range.lowerBound) is out of bounds of 0..<0)")
                 if range.upperBound == 0 {
                     self = .empty
                 } else if InlineData.canStore(count: range.upperBound) {
-                    precondition(range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
                     self = .inline(InlineData(count: range.upperBound))
                 } else if InlineSlice.canStore(count: range.upperBound) {
-                    precondition(range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
                     self = .slice(InlineSlice(count: range.upperBound))
                 } else {
-                    precondition(range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
                     self = .large(LargeSlice(count: range.upperBound))
                 }
             case .inline(var inline):

Sources/FoundationEssentials/Data/Representations/Data+Representation.swift

@@ -187,7 +187,7 @@ extension Data {
 
         @export(implementation)
         mutating func resetBytes(in range: Range<Index>) {
-            precondition(range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
+            precondition(range.lowerBound >= startIndex && range.lowerBound <= endIndex, "index \(range.lowerBound) is out of bounds of \(startIndex)..<\(endIndex)")
             ensureUniqueReference()
             _storage.resetBytes(in: range)
             if _slice.upperBound < range.upperBound {

Tests/FoundationEssentialsTests/DataTests.swift

@@ -2329,10 +2329,35 @@ private final class DataTests {
     }
 
     @Test func bounding_failure_reset_range() async {
+        await #expect(processExitsWith: .failure) {
+            var data = Data()
+            data.resetBytes(in: -1..<0)
+        }
+
+        await #expect(processExitsWith: .failure) {
+            var data = Data()
+            data.resetBytes(in: 2..<3)
+        }
+
+        await #expect(processExitsWith: .failure) {
+            var data = try #require("Hello World".data(using: .utf8))
+            data.resetBytes(in: -1..<2)
+        }
+
         await #expect(processExitsWith: .failure) {
             var data = try #require("Hello World".data(using: .utf8))
             data.resetBytes(in: 100..<200)
         }
+
+        await #expect(processExitsWith: .failure) {
+            var data = Data(count: 128)
+            data.resetBytes(in: -1..<2)
+        }
+
+        await #expect(processExitsWith: .failure) {
+            var data = Data(count: 128)
+            data.resetBytes(in: 200..<201)
+        }
     }
 
     @Test func bounding_failure_append_bad_length() async {
@@ -3846,6 +3871,20 @@ struct LargeDataTests {
         #expect(large[1] == 0xBB)
         #expect(large[2] == 0xCC)
     }
+
+    #if FOUNDATION_EXIT_TESTS
+    @Test func resetBytesBounds() async {
+        await #expect(processExitsWith: .failure) {
+            var data = Data(count: largeCount)
+            data.resetBytes(in: -1..<2)
+        }
+
+        await #expect(processExitsWith: .failure) {
+            var data = Data(count: largeCount)
+            data.resetBytes(in: (data.endIndex + 1) ..< (data.endIndex + 2))
+        }
+    }
+    #endif
 }
 
 private func expectLargeIfLegacyABI(_ data: Data, sourceLocation: SourceLocation = #_sourceLocation) {