Generalize ContiguousBytes to be noncopyable and nonescapable for spans

The ContiguousBytes protocol covers various types that can provide
unsafe access to their stored bytes. Generalize the ContiguousBytes
protocol by making it non-copyable and non-escapable, so that the Span
family of types and InlineArray can conform to it.

Fixes rdar://163716671.

Author: DougGregor

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