Generalize ContiguousBytes to be noncopyable and nonescapable for spans

Sources/FoundationEssentials/Data/ContiguousBytes.swift

@@ -12,6 +12,20 @@
 
 //===--- ContiguousBytes --------------------------------------------------===//
 
+#if compiler(>=6.2)
+/// Indicates that the conforming type is a contiguous collection of raw bytes
+/// whose underlying storage is directly accessible by withUnsafeBytes.
+@available(macOS 10.10, iOS 8.0, watchOS 2.0, tvOS 9.0, *)
+public protocol ContiguousBytes: ~Escapable, ~Copyable {
+    /// Calls the given closure with the contents of underlying storage.
+    ///
+    /// - note: Calling `withUnsafeBytes` multiple times does not guarantee that
+    ///         the same buffer pointer will be passed in every time.
+    /// - warning: The buffer argument to the body should not be stored or used
+    ///            outside of the lifetime of the call to the closure.
+    func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R
+}
+#else
 /// Indicates that the conforming type is a contiguous collection of raw bytes
 /// whose underlying storage is directly accessible by withUnsafeBytes.
 @available(macOS 10.10, iOS 8.0, watchOS 2.0, tvOS 9.0, *)
@@ -24,6 +38,7 @@ public protocol ContiguousBytes {
     ///            outside of the lifetime of the call to the closure.
     func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R
 }
+#endif
 
 //===--- Collection Conformances ------------------------------------------===//
 
@@ -109,3 +124,34 @@ extension Slice : ContiguousBytes where Base : ContiguousBytes {
         }
     }
 }
+
+#if compiler(>=6.2)
+
+//===--- Span Conformances -----------------------------------------===//
+
+@available(FoundationPreview 6.3, *)
+extension RawSpan: ContiguousBytes {
+}
+
+@available(FoundationPreview 6.3, *)
+extension MutableRawSpan: ContiguousBytes {
+}
+
+@available(FoundationPreview 6.3, *)
+extension Span: ContiguousBytes where Element == UInt8 {
+}
+
+@available(FoundationPreview 6.3, *)
+extension MutableSpan: ContiguousBytes where Element == UInt8 {
+}
+
+@available(FoundationPreview 6.3, *)
+@available(macOS 26.0, iOS 26.0, tvOS 26.0, watchOS 26.0, visionOS 26.0, *)
+extension InlineArray: ContiguousBytes where Element == UInt8 {
+    @_alwaysEmitIntoClient
+    public func withUnsafeBytes<R, E>(_ body: (UnsafeRawBufferPointer) throws(E) -> R) throws(E) -> R {
+        return try span.withUnsafeBytes(body)
+    }
+}
+
+#endif

Tests/FoundationEssentialsTests/ContiguousBytesTests.swift

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Testing
+
+#if canImport(FoundationEssentials)
+@testable import FoundationEssentials
+#else
+@testable import Foundation
+#endif
+
+#if compiler(>=6.2)
+
+func acceptContiguousBytes(_ bytes: borrowing some ContiguousBytes & ~Escapable & ~Copyable) { }
+
+@Suite("ContiguousBytesTests")
+private struct ContiguousBytesTests {
+    @available(macOS 26.0, iOS 26.0, tvOS 26.0, watchOS 26.0, visionOS 26.0, *)
+    @Test func span() throws {
+        if #available(FoundationPreview 6.3, *) {
+            var bytes: [UInt8] = [1, 2, 3]
+            acceptContiguousBytes(bytes.span)
+            acceptContiguousBytes(bytes.mutableSpan)
+            acceptContiguousBytes(bytes.span.bytes)
+
+            let ms = bytes.mutableSpan
+            acceptContiguousBytes(ms.bytes)
+        }
+    }
+}
+
+#endif