Implement new Sequence associatedtype/requirement

This includes a default associated type for the BorrowingIterator
and a `NeverIterator` for types with noncopyable elements.

Author: natecook1000

stdlib/public/core/Optional.swift

@@ -1016,3 +1016,22 @@ extension Optional: _ObjectiveCBridgeable {
   }
 }
 #endif
+
+extension Optional where Wrapped: ~Copyable {
+  @available(SwiftStdlib 6.3, *)
+  @_alwaysEmitIntoClient
+  public var _span: Span<Wrapped> {
+    @_addressableSelf
+    @lifetime(borrow self)
+    get {
+      guard self != nil else {
+        return Span()
+      }
+      
+      let ptr = Builtin.unprotectedAddressOfBorrow(self)
+      return unsafe _overrideLifetime(
+        Span(_unsafeStart: UnsafePointer(ptr), count: 1),
+        borrowing: self)
+    }
+  }
+}

stdlib/public/core/Sequence.swift

@@ -322,14 +322,18 @@ public protocol IteratorProtocol<Element> {
 /// makes no other requirements about element access, so routines that
 /// traverse a sequence should be considered O(*n*) unless documented
 /// otherwise.
-public protocol Sequence<Element> {
+public protocol Sequence<Element> /* : ~Copyable, ~Escapable */ {
   /// A type representing the sequence's elements.
   associatedtype Element
 
   /// A type that provides the sequence's iteration interface and
   /// encapsulates its iteration state.
-  associatedtype Iterator: IteratorProtocol where Iterator.Element == Element
+  associatedtype Iterator: IteratorProtocol<Element>
 
+  @available(SwiftStdlib 6.3, *)
+  associatedtype BorrowingIterator: BorrowingIteratorProtocol & ~Copyable & ~Escapable /* where BorrowingIterator.Element == Element */
+    = BorrowingIteratorAdapter<Self>
+  
   // FIXME: <rdar://problem/34142121>
   // This typealias should be removed as it predates the source compatibility
   // guarantees of Swift 3, but it cannot due to a bug.
@@ -345,6 +349,10 @@ public protocol Sequence<Element> {
   /// Returns an iterator over the elements of this sequence.
   __consuming func makeIterator() -> Iterator
 
+  @available(SwiftStdlib 6.3, *)
+  @lifetime(borrow self)
+  func makeBorrowingIterator() -> BorrowingIterator
+  
   /// A value less than or equal to the number of elements in the sequence,
   /// calculated nondestructively.
   ///
@@ -451,6 +459,38 @@ public protocol Sequence<Element> {
   ) rethrows -> R?
 }
 
+@available(SwiftStdlib 6.3, *)
+public struct BorrowingIteratorAdapter<S: Sequence>: /* & ~Copyable & ~Escapable */
+  BorrowingIteratorProtocol where S.Element: Copyable
+{
+  var iterator: S.Iterator
+  var curValue: S.Element?
+  
+  @lifetime(&self)
+  public mutating func nextSpan(maximumCount: Int) -> Span<S.Element> {
+    curValue = iterator.next()
+    return curValue._span
+  }
+}
+
+@available(SwiftStdlib 6.3, *)
+public enum NeverIterator<Element: ~Copyable> {}
+
+@available(SwiftStdlib 6.3, *)
+extension NeverIterator: IteratorProtocol { /* where Element: ~Copyable */
+  public typealias Element = Element
+  public func next() -> Element? {
+    fatalError()
+  }
+}
+
+@available(SwiftStdlib 6.3, *)
+extension Sequence where BorrowingIterator == BorrowingIteratorAdapter<Self> {
+  public func makeBorrowingIterator() -> BorrowingIterator {
+    BorrowingIteratorAdapter(iterator: makeIterator())
+  }
+}
+
 // Provides a default associated type witness for Iterator when the
 // Self type is both a Sequence and an Iterator.
 extension Sequence where Self: IteratorProtocol {