Make Span conform to Sequence

Still only with copyable elements, but this allows Span iteration,
along with generic sequence algorithms (provided they use the new
borrowing iterator).

Author: natecook1000

stdlib/public/core/BorrowingIteratorProtocol.swift

@@ -149,7 +149,9 @@ extension Span: BorrowingIteratorProtocol where Element: ~Copyable {
 }
 
 @available(SwiftStdlib 6.3, *)
-extension Span /*: Sequence /* where Element: ~Copyable */ */ {
+extension Span: Sequence /* where Element: ~Copyable */ {
+  public typealias Iterator = NeverIterator<Element>
+  
   @_alwaysEmitIntoClient
   @_lifetime(borrow self)
   public func makeBorrowingIterator() -> Span<Element> {

stdlib/public/core/Sequence.swift

@@ -493,7 +493,7 @@ extension Sequence where BorrowingIterator == BorrowingIteratorAdapter<Iterator>
 }
 
 @available(SwiftStdlib 6.3, *)
-extension Sequence where Iterator == NeverIterator<Element> {
+extension Sequence where Iterator == NeverIterator<Element>, Self: ~Copyable & ~Escapable {
   public func makeIterator() -> Iterator {
     fatalError("Attempt to iterate using a NeverIterator")
   }
@@ -711,6 +711,40 @@ extension DropWhileSequence: Sequence {
 // Default implementations for Sequence
 //===----------------------------------------------------------------------===//
 
+extension Sequence where Self: ~Copyable & ~Escapable {
+  @inlinable
+  public var underestimatedCount: Int {
+    return 0
+  }
+  
+  @inlinable
+  @inline(__always)
+  public func _customContainsEquatableElement(
+    _ element: Iterator.Element
+  ) -> Bool? {
+    return nil
+  }
+  
+  @inlinable
+  @safe
+  public func withContiguousStorageIfAvailable<R>(
+    _ body: (UnsafeBufferPointer<Element>) throws -> R
+  ) rethrows -> R? {
+    return nil
+  }
+
+  public __consuming func _copyContents(
+    initializing buffer: UnsafeMutableBufferPointer<Element>
+  ) -> (Iterator, UnsafeMutableBufferPointer<Element>.Index) {
+    fatalError("_copyContents on a ~Copyable/~Copyable sequence")
+  }
+  
+  @inlinable
+  public __consuming func _copyToContiguousArray() -> ContiguousArray<Element> {
+    fatalError("_copyToContiguousArray on a ~Copyable/~Escapable sequence")
+  }
+}
+
 extension Sequence {
   /// Returns an array containing the results of mapping the given closure
   /// over the sequence's elements.

test/stdlib/Span/SpanTests.swift

@@ -609,7 +609,7 @@ suite.test("Span Sendability")
 }
 
 @available(SwiftStdlib 6.3, *)
-extension Sequence { // Copyable only
+extension Sequence where Self: ~Copyable & ~Escapable { // Copyable elements only
   func collectViaBorrowing() -> [Element] {
     var borrowIterator = makeBorrowingIterator()
     var result: [Element] = []
@@ -624,6 +624,25 @@ extension Sequence { // Copyable only
   }
 }
 
+@available(SwiftStdlib 6.3, *)
+func elementsEqual<S1: Sequence, S2: Sequence>(
+  _ lhs: borrowing S1,
+  _ rhs: borrowing S2
+) -> Bool
+  where S1.Element: Equatable, S2.Element == S1.Element,
+        S1: ~Escapable & ~Copyable, S2: ~Escapable & ~Copyable
+{
+  var iter1 = lhs.makeBorrowingIterator()
+  var iter2 = rhs.makeBorrowingIterator()
+  while true {
+    let el1 = iter1.nextSpan(maximumCount: 1)
+    let el2 = iter2.nextSpan(maximumCount: 1)
+    if el1.isEmpty && el2.isEmpty { return true }
+    if el1.isEmpty || el2.isEmpty { return false }
+    if el1[0] != el2[0] { return false }
+  }
+}
+
 suite.test("BORROWING")
 .require(.stdlib_6_3).code {
   guard #available(SwiftStdlib 6.3, *) else {
@@ -635,7 +654,11 @@ suite.test("BORROWING")
   let arrayCollected = array.collectViaBorrowing()
   expectEqual(array, arrayCollected)
 
+  let span = array.span
+  let spanCollected = span.collectViaBorrowing()
+  expectTrue(elementsEqual(span, spanCollected))
+
   let inline: [8 of Int] = [1, 2, 3, 4, 5, 6, 7, 8]
   let inlineCollected = inline.collectViaBorrowing()
-  expectEqualSequence(inline, inlineCollected)
+  expectTrue(elementsEqual(inline, inlineCollected))
 }