Generalize Sequence to be ~Copyable & ~Escapable

This change allows noncopyable and nonescapable Sequence types, with
room for generalizing the Element type to be ~Copyable in the future.
The new prototype adds a BorrowingIterator associated type to Sequence

This commit adds a BorrowingIteratorProtocol for generalized bulk
iteration, a BorrowingIteratorAdapter as an implementation of the new
Sequence requirement for existing sequences, and a NeverIterator for
new noncopyable/nonescapable sequence types. Conformance to Sequence
for Span and InlineArray is also included.

Issues:
- Availability checking must be off due to the availability
  requirements on the new Sequence.BorrowingIterator associated type
- Several existing sequences needed an explicit Element type alias to
  compile (note that this was during experimentation, so it may be
  possible to back out these changes)
- Some of the default implementations for generalized sequences simply
  fatal error
- InlineArray is a tricky case, due to its conditionally copyable
  design. It conforms to Sequence unconditionally, so it needs an
  unconditional implementation of (the original) Iterator associated
  type. However, when Sequence can use ~Copyable elements, that
  implementation won't be workable, since (a) it copies the inline
  array, and (b) it implements the `next() -> Element?` method, which
  can't return a noncopyable element.

Author: natecook1000

benchmark/single-source/DataBenchmarks.swift

@@ -327,14 +327,20 @@ let large = sampleData(.large)
 let array809 = byteArray(size: 809)
 
 struct Count0<S: Sequence> : Sequence {
+  @available(macOS 9999, *)
+  public typealias BorrowingIterator = BorrowingIteratorAdapter<S.Iterator>
+
   let base: S
   init (_ base:S) { self.base = base }
   func makeIterator() -> S.Iterator { return base.makeIterator() }
   var underestimatedCount: Int { return 0 }
 }
 
 struct Bytes: Sequence, IteratorProtocol {
-    let count: Int
+  @available(macOS 9999, *)
+  public typealias BorrowingIterator = BorrowingIteratorAdapter<Self>
+
+  let count: Int
     let exact: Bool
     var  i: Int = 0
     init(count: Int, exact: Bool) {

stdlib/private/StdlibCollectionUnittest/MinimalCollections.swift

@@ -83,6 +83,8 @@ public enum UnderestimatedCountBehavior {
 ///
 /// This sequence is consumed when its generator is advanced.
 public struct MinimalSequence<T> : Sequence, CustomDebugStringConvertible {
+  public typealias Element = T
+  
   public init<S : Sequence>(
     elements: S,
     underestimatedCount: UnderestimatedCountBehavior = .value(0)

stdlib/private/StdlibUnittest/StdlibUnittest.swift

@@ -2241,7 +2241,8 @@ public enum StdLibVersion: String {
   case stdlib_6_0  = "6.0"
   case stdlib_6_1  = "6.1"
   case stdlib_6_2  = "6.2"
-  
+  case stdlib_6_3  = "6.3"
+
   var isAvailable: Bool {
     switch self {
     case .stdlib_5_7:
@@ -2258,6 +2259,8 @@ public enum StdLibVersion: String {
       return if #available(SwiftStdlib 6.1, *)  { true } else { false }
     case .stdlib_6_2:
       return if #available(SwiftStdlib 6.2, *)  { true } else { false }
+    case .stdlib_6_3:
+      return if #available(SwiftStdlib 6.3, *)  { true } else { false }
     }
   }
 }

stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift

@@ -226,6 +226,10 @@ internal struct Section {
 
 /// Holds the addresses and sizes of sections related to reflection.
 internal struct ReflectionInfo : Sequence {
+  internal typealias Element = Section?
+  @available(macOS 9999, *)
+  internal typealias BorrowingIterator = BorrowingIteratorAdapter<AnyIterator<Section?>>
+  
   /// The name of the loaded image.
   internal let imageName: String
 

stdlib/public/Concurrency/Deque/Deque+Collection.swift

@@ -19,6 +19,8 @@ extension _Deque: Sequence {
   // This custom implementation performs direct storage access to eliminate any
   // and all index validation overhead. It also optimizes away repeated
   // conversions from indices to storage slots.
+  @available(macOS 9999, *)
+  internal typealias BorrowingIterator = BorrowingIteratorAdapter<Iterator>
 
   /// An iterator over the members of a deque.
   struct Iterator: IteratorProtocol {

stdlib/public/RuntimeModule/Base64.swift

@@ -217,6 +217,8 @@ public struct Base64Encoder<S: Sequence>: Sequence
 public struct Base64Decoder<S: Sequence>: Sequence
   where S.Element == UTF8.CodeUnit
 {
+  @available(macOS 9999, *)
+  public typealias BorrowingIterator = BorrowingIteratorAdapter<Iterator>
   public typealias Element = UInt8
 
   var source: S

stdlib/public/RuntimeModule/Elf.swift

@@ -1266,6 +1266,8 @@ final class ElfImage<SomeElfTraits: ElfTraits>
   }
 
   struct Notes: Sequence {
+    typealias Element = Note
+    
     var image: ElfImage<Traits>
 
     struct NoteIterator: IteratorProtocol {

stdlib/public/RuntimeModule/FramePointerUnwinder.swift

@@ -21,6 +21,7 @@ public struct FramePointerUnwinder<C: Context, M: MemoryReader>: Sequence, Itera
   public typealias Context = C
   public typealias MemoryReader = M
   public typealias Address = Context.Address
+  public typealias Element = RichFrame<Address>
 
   var pc: Address
   var fp: Address

stdlib/public/StringProcessing/CMakeLists.txt

@@ -20,6 +20,7 @@ set(swift_string_processing_compile_flags)
 # will be built with library evolution.
 list(APPEND swift_string_processing_compile_flags
   "-DRESILIENT_LIBRARIES")
+list(APPEND swift_string_processing_compile_flags "-Xfrontend" "-disable-availability-checking")
 
 if(SWIFT_BUILD_STATIC_STDLIB)
   # Explicitly autolink swift_RegexParser because it's imported with @_implementationOnly

stdlib/public/core/BorrowIteratorProtocol.swift renamed to stdlib/public/core/BorrowingIteratorProtocol.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 6.3, *)
-public protocol BorrowIteratorProtocol<Element>: ~Copyable, ~Escapable {
+public protocol BorrowingIteratorProtocol<Element>: ~Copyable, ~Escapable {
   associatedtype Element: ~Copyable
 
   // FIXME: This ought to be a core requirement, but `Ref` is not a thing yet.
@@ -90,7 +90,7 @@ public protocol BorrowIteratorProtocol<Element>: ~Copyable, ~Escapable {
 }
 
 @available(SwiftStdlib 6.3, *)
-extension BorrowIteratorProtocol where Self: ~Copyable & ~Escapable {
+extension BorrowingIteratorProtocol where Self: ~Copyable & ~Escapable {
   @_alwaysEmitIntoClient
   @_lifetime(&self)
   @_lifetime(self: copy self)
@@ -101,7 +101,7 @@ extension BorrowIteratorProtocol where Self: ~Copyable & ~Escapable {
 }
 
 @available(SwiftStdlib 6.3, *)
-extension BorrowIteratorProtocol where Self: ~Copyable & ~Escapable {
+extension BorrowingIteratorProtocol where Self: ~Copyable & ~Escapable {
   @_alwaysEmitIntoClient
   @_lifetime(self: copy self)
   public mutating func skip(by offset: Int) -> Int {
@@ -115,29 +115,29 @@ extension BorrowIteratorProtocol where Self: ~Copyable & ~Escapable {
   }
 }
 
-@available(SwiftStdlib 6.3, *)
-extension Span: Iterable where Element: ~Copyable {
-  // FIXME: This simple definition cannot also be a backward (or bidirectional)
-  // iterator, nor a random-access iterator. If we want to go in that direction,
-  // we'll need to rather introduce a type more like `RigidArray.BorrowIterator`.
-  public typealias BorrowIterator = Self
-
-  @_alwaysEmitIntoClient
-  @_transparent
-  public var estimatedCount: EstimatedCount {
-    .exactly(count)
-  }
-
-  @_alwaysEmitIntoClient
-  @_lifetime(copy self)
-  @_transparent
-  public func startBorrowIteration() -> Span<Element> {
-    self
-  }
-}
+//@available(SwiftStdlib 6.3, *)
+//extension Span: Iterable where Element: ~Copyable {
+//  // FIXME: This simple definition cannot also be a backward (or bidirectional)
+//  // iterator, nor a random-access iterator. If we want to go in that direction,
+//  // we'll need to rather introduce a type more like `RigidArray.BorrowIterator`.
+//  public typealias BorrowIterator = Self
+//
+//  @_alwaysEmitIntoClient
+//  @_transparent
+//  public var estimatedCount: EstimatedCount {
+//    .exactly(count)
+//  }
+//
+//  @_alwaysEmitIntoClient
+//  @_lifetime(copy self)
+//  @_transparent
+//  public func startBorrowIteration() -> Span<Element> {
+//    self
+//  }
+//}
 
 @available(SwiftStdlib 6.3, *)
-extension Span: BorrowIteratorProtocol where Element: ~Copyable {
+extension Span: BorrowingIteratorProtocol where Element: ~Copyable {
   @_alwaysEmitIntoClient
   @_lifetime(&self)
   @_lifetime(self: copy self)
@@ -149,37 +149,79 @@ extension Span: BorrowIteratorProtocol where Element: ~Copyable {
 }
 
 @available(SwiftStdlib 6.3, *)
-extension MutableSpan: Iterable where Element: ~Copyable {
-  public typealias BorrowIterator = Span<Element>.BorrowIterator
-
-  @_alwaysEmitIntoClient
-  @_transparent
-  public var estimatedCount: EstimatedCount {
-    .exactly(count)
-  }
-
+extension Span: Sequence /* where Element: ~Copyable */ {
+  public typealias Iterator = NeverIterator<Element>
+  
   @_alwaysEmitIntoClient
   @_lifetime(borrow self)
-  @_transparent
-  public func startBorrowIteration() -> Span<Element> {
-    span
+  public func makeBorrowingIterator() -> Span<Element> {
+    self
   }
 }
 
-@available(SwiftStdlib 6.3, *)
-extension OutputSpan: Iterable where Element: ~Copyable {
-  public typealias BorrowIterator = Span<Element>.BorrowIterator
-
-  @_alwaysEmitIntoClient
-  @_transparent
-  public var estimatedCount: EstimatedCount {
-    .exactly(count)
+extension InlineArray: Sequence /* where Element: ~Copyable */ {
+  public typealias Element = Element
+//  public typealias Iterator = NeverIterator<Element>
+  public typealias BorrowingIterator = Span<Element>
+  
+  // This will NOT work once `Element: ~Copyable` is in the works
+  // Problematic because we can only conform to `Sequence` once, so we
+  // need to provide a single iterator type, but it can't handle both
+  // ~Copyable and copyable elements (I think)
+  public struct Iterator: IteratorProtocol {
+    var array: [count of Element]
+    var index: Int = 0
+    
+    public mutating func next() -> Element? {
+      guard index < array.count else { return nil }
+      defer { index &+= 1 }
+      return array[index]
+    }
   }
-
+  
+  public func makeIterator() -> Iterator {
+    .init(array: self)
+  }
+  
   @_alwaysEmitIntoClient
   @_lifetime(borrow self)
-  @_transparent
-  public func startBorrowIteration() -> Span<Element> {
+  public func makeBorrowingIterator() -> Span<Element> {
     self.span
   }
 }
+
+//@available(SwiftStdlib 6.3, *)
+//extension MutableSpan: Iterable where Element: ~Copyable {
+//  public typealias BorrowIterator = Span<Element>.BorrowIterator
+//
+//  @_alwaysEmitIntoClient
+//  @_transparent
+//  public var estimatedCount: EstimatedCount {
+//    .exactly(count)
+//  }
+//
+//  @_alwaysEmitIntoClient
+//  @_lifetime(borrow self)
+//  @_transparent
+//  public func startBorrowIteration() -> Span<Element> {
+//    span
+//  }
+//}
+//
+//@available(SwiftStdlib 6.3, *)
+//extension OutputSpan: Iterable where Element: ~Copyable {
+//  public typealias BorrowIterator = Span<Element>.BorrowIterator
+//
+//  @_alwaysEmitIntoClient
+//  @_transparent
+//  public var estimatedCount: EstimatedCount {
+//    .exactly(count)
+//  }
+//
+//  @_alwaysEmitIntoClient
+//  @_lifetime(borrow self)
+//  @_transparent
+//  public func startBorrowIteration() -> Span<Element> {
+//    self.span
+//  }
+//}