Eliminate Sequence.SubSequence + Use @_borrowed

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -261,8 +261,12 @@ bool SILPerformanceInliner::isProfitableToInline(
   int BaseBenefit = RemovedCallBenefit;
 
   // Osize heuristic.
+  //
+  // As a hack, don't apply this at all to coroutine inlining; avoiding
+  // coroutine allocation overheads is extremely valuable.  There might be
+  // more principled ways of getting this effect.
   bool isClassMethodAtOsize = false;
-  if (OptMode == OptimizationMode::ForSize) {
+  if (OptMode == OptimizationMode::ForSize && !isa<BeginApplyInst>(AI)) {
     // Don't inline into thunks.
     if (AI.getFunction()->isThunk())
       return false;

stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift

@@ -1643,14 +1643,6 @@ extension TestSuite {
 
     testNamePrefix += String(describing: S.Type.self)
 
-    let isMultiPass = makeSequence([])
-      ._preprocessingPass { true } ?? false
-    let isEquatableMultiPass = makeSequenceOfEquatable([])
-      ._preprocessingPass { true } ?? false
-    expectEqual(
-      isMultiPass, isEquatableMultiPass,
-      "Two sequence types are of different kinds?")
-
     // FIXME: swift-3-indexing-model: add tests for `underestimatedCount`
     // Check that it is non-negative, and an underestimate of the actual
     // element count.
@@ -1667,12 +1659,6 @@ self.test("\(testNamePrefix).contains()/WhereElementIsEquatable/semantics") {
       test.expected != nil,
       s.contains(wrapValueIntoEquatable(test.element)),
       stackTrace: SourceLocStack().with(test.loc))
-
-    if !isMultiPass {
-      expectEqualSequence(
-        test.expectedLeftoverSequence, s.map(extractValueFromEquatable),
-        stackTrace: SourceLocStack().with(test.loc))
-    }
   }
 }
 

stdlib/private/StdlibCollectionUnittest/LoggingWrappers.swift

@@ -83,7 +83,6 @@ public class SequenceLog {
   public static var prefixWhile = TypeIndexed(0)
   public static var prefixMaxLength = TypeIndexed(0)
   public static var suffixMaxLength = TypeIndexed(0)
-  public static var split = TypeIndexed(0)
   public static var _customContainsEquatableElement = TypeIndexed(0)
   public static var _preprocessingPass = TypeIndexed(0)
   public static var _copyToContiguousArray = TypeIndexed(0)
@@ -202,7 +201,6 @@ extension LoggingSequence: LoggingType {
 extension LoggingSequence: Sequence {
   public typealias Element = Base.Element
   public typealias Iterator = LoggingIterator<Base.Iterator>
-  public typealias SubSequence = Base.SubSequence
 
   public func makeIterator() -> Iterator {
     SequenceLog.makeIterator[selfType] += 1
@@ -214,52 +212,6 @@ extension LoggingSequence: Sequence {
     return base.underestimatedCount
   }
 
-  public func dropFirst(_ n: Int) -> SubSequence {
-    SequenceLog.dropFirst[selfType] += 1
-    return base.dropFirst(n)
-  }
-
-  public func dropLast(_ n: Int) -> SubSequence {
-    SequenceLog.dropLast[selfType] += 1
-    return base.dropLast(n)
-  }
-
-  public func drop(
-    while predicate: (Element) throws -> Bool
-  ) rethrows -> SubSequence {
-    SequenceLog.dropWhile[selfType] += 1
-    return try base.drop(while: predicate)
-  }
-
-  public func prefix(_ maxLength: Int) -> SubSequence {
-    SequenceLog.prefixMaxLength[selfType] += 1
-    return base.prefix(maxLength)
-  }
-
-  public func prefix(
-    while predicate: (Element) throws -> Bool
-  ) rethrows -> SubSequence {
-    SequenceLog.prefixWhile[selfType] += 1
-    return try base.prefix(while: predicate)
-  }
-
-  public func suffix(_ maxLength: Int) -> SubSequence {
-    SequenceLog.suffixMaxLength[selfType] += 1
-    return base.suffix(maxLength)
-  }
-
-  public func split(
-    maxSplits: Int = Int.max,
-    omittingEmptySubsequences: Bool = true,
-    whereSeparator isSeparator: (Element) throws -> Bool
-  ) rethrows -> [SubSequence] {
-    SequenceLog.split[selfType] += 1
-    return try base.split(
-      maxSplits: maxSplits,
-      omittingEmptySubsequences: omittingEmptySubsequences,
-      whereSeparator: isSeparator)
-  }
-
   public func _customContainsEquatableElement(_ element: Element) -> Bool? {
     SequenceLog._customContainsEquatableElement[selfType] += 1
     return base._customContainsEquatableElement(element)
@@ -297,6 +249,7 @@ public typealias LoggingCollection<Base: Collection> = LoggingSequence<Base>
 extension LoggingCollection: Collection {  
   public typealias Index = Base.Index
   public typealias Indices = Base.Indices
+  public typealias SubSequence = Base.SubSequence
 
   public var startIndex: Index {
     CollectionLog.startIndex[selfType] += 1

stdlib/private/StdlibUnittest/StdlibUnittest.swift

@@ -499,8 +499,7 @@ public func expectMutableSliceType<X : MutableCollection>(
 /// to be.
 public func expectSequenceAssociatedTypes<X : Sequence>(
   sequenceType: X.Type,
-  iteratorType: X.Iterator.Type,
-  subSequenceType: X.SubSequence.Type
+  iteratorType: X.Iterator.Type
 ) {}
 
 /// Check that all associated types of a `Collection` are what we expect them

stdlib/public/SDK/CoreAudio/CoreAudio.swift

@@ -151,16 +151,17 @@ extension UnsafeMutableAudioBufferListPointer
   }
 
   /// Access an indexed `AudioBuffer` (`mBuffers[i]`).
+  @_borrowed
   public subscript(index: Index) -> Element {
-    get {
+    _read {
       precondition(index >= 0 && index < self.count,
         "subscript index out of range")
-      return (_audioBuffersPointer + index).pointee
+      yield ((_audioBuffersPointer + index).pointee)
     }
-    nonmutating set(newValue) {
+    nonmutating _modify {
       precondition(index >= 0 && index < self.count,
         "subscript index out of range")
-      (_audioBuffersPointer + index).pointee = newValue
+      yield (&(_audioBuffersPointer + index).pointee)
     }
   }
 }

stdlib/public/core/CMakeLists.txt

@@ -122,7 +122,6 @@ set(SWIFTLIB_ESSENTIAL
   SipHash.swift
   Sequence.swift
   SequenceAlgorithms.swift
-  SequenceWrapper.swift
   Set.swift
   SetAlgebra.swift
   SetAnyHashableExtensions.swift

stdlib/public/core/Collection.swift

@@ -332,7 +332,7 @@ extension IndexingIterator: IteratorProtocol, Sequence {
 /// or bidirectional collection must traverse the entire collection to count
 /// the number of contained elements, accessing its `count` property is an
 /// O(*n*) operation.
-public protocol Collection: Sequence where SubSequence: Collection {
+public protocol Collection: Sequence {
   // FIXME: ideally this would be in MigrationSupport.swift, but it needs
   // to be on the protocol instead of as an extension
   @available(*, deprecated/*, obsoleted: 5.0*/, message: "all index distances are now of type Int")
@@ -390,7 +390,10 @@ public protocol Collection: Sequence where SubSequence: Collection {
   /// This associated type appears as a requirement in the `Sequence`
   /// protocol, but it is restated here with stricter constraints. In a
   /// collection, the subsequence should also conform to `Collection`.
-  associatedtype SubSequence = Slice<Self> where SubSequence.Index == Index
+  associatedtype SubSequence: Collection = Slice<Self>
+  where SubSequence.Index == Index,
+        Element == SubSequence.Element,
+        SubSequence.SubSequence == SubSequence
 
   /// Accesses the element at the specified position.
   ///
@@ -411,6 +414,7 @@ public protocol Collection: Sequence where SubSequence: Collection {
   ///   `endIndex` property.
   ///
   /// - Complexity: O(1)
+  @_borrowed
   subscript(position: Index) -> Element { get }
 
   /// Accesses a contiguous subrange of the collection's elements.
@@ -1226,7 +1230,7 @@ extension Collection {
   ///   `RandomAccessCollection`; otherwise, O(*k*), where *k* is the number of
   ///   elements to drop from the beginning of the collection.
   @inlinable
-  public __consuming func dropFirst(_ k: Int) -> SubSequence {
+  public __consuming func dropFirst(_ k: Int = 1) -> SubSequence {
     _precondition(k >= 0, "Can't drop a negative number of elements from a collection")
     let start = index(startIndex, offsetBy: k, limitedBy: endIndex) ?? endIndex
     return self[start..<endIndex]
@@ -1253,15 +1257,15 @@ extension Collection {
   ///   `RandomAccessCollection`; otherwise, O(*n*), where *n* is the length of
   ///   the collection.
   @inlinable
-  public __consuming func dropLast(_ k: Int) -> SubSequence {
+  public __consuming func dropLast(_ k: Int = 1) -> SubSequence {
     _precondition(
       k >= 0, "Can't drop a negative number of elements from a collection")
     let amount = Swift.max(0, count - k)
     let end = index(startIndex,
       offsetBy: amount, limitedBy: endIndex) ?? endIndex
     return self[startIndex..<end]
   }
-
+    
   /// Returns a subsequence by skipping elements while `predicate` returns
   /// `true` and returning the remaining elements.
   ///

stdlib/public/core/Dictionary.swift

@@ -618,6 +618,8 @@ extension Dictionary {
 }
 
 extension Dictionary: Collection {
+  public typealias SubSequence = Slice<Dictionary>
+
   /// The position of the first element in a nonempty dictionary.
   ///
   /// If the collection is empty, `startIndex` is equal to `endIndex`.
@@ -1321,6 +1323,7 @@ extension Dictionary {
     : Collection, Equatable,
       CustomStringConvertible, CustomDebugStringConvertible {
     public typealias Element = Key
+    public typealias SubSequence = Slice<Dictionary.Keys>
 
     @usableFromInline
     internal var _variant: Dictionary<Key, Value>._Variant

stdlib/public/core/DropWhile.swift

@@ -78,8 +78,6 @@ extension LazyDropWhileSequence.Iterator: IteratorProtocol {
 }
 
 extension LazyDropWhileSequence: Sequence {
-  public typealias SubSequence = AnySequence<Element> // >:(
-
   /// Returns an iterator over the elements of this sequence.
   ///
   /// - Complexity: O(1).
@@ -119,140 +117,43 @@ extension LazySequenceProtocol {
 ///   performance given by the `Collection` protocol. Be aware, therefore,
 ///   that general operations on lazy collections may not have the
 ///   documented complexity.
-@_fixed_layout // lazy-performance
-public struct LazyDropWhileCollection<Base: Collection> {
-  public typealias Element = Base.Element
-
-  @inlinable // lazy-performance
-  internal init(_base: Base, predicate: @escaping (Element) -> Bool) {
-    self._base = _base
-    self._predicate = predicate
-  }
-
-  @usableFromInline // lazy-performance
-  internal var _base: Base
-  @usableFromInline // lazy-performance
-  internal let _predicate: (Element) -> Bool
-}
+public typealias LazyDropWhileCollection<T: Collection> = LazyDropWhileSequence<T>
 
-extension LazyDropWhileCollection: Sequence {
-  public typealias Iterator = LazyDropWhileSequence<Base>.Iterator
-
-  /// Returns an iterator over the elements of this sequence.
-  ///
-  /// - Complexity: O(1).
-  @inlinable // lazy-performance
-  public __consuming func makeIterator() -> Iterator {
-    return Iterator(_base: _base.makeIterator(), predicate: _predicate)
-  }
-}
-
-extension LazyDropWhileCollection {
+extension LazyDropWhileCollection: Collection {
   public typealias SubSequence = Slice<LazyDropWhileCollection<Base>>
+  public typealias Index = Base.Index
 
-  /// A position in a `LazyDropWhileCollection` or
-  /// `LazyDropWhileBidirectionalCollection` instance.
-  @_fixed_layout // lazy-performance
-  public struct Index {
-    /// The position corresponding to `self` in the underlying collection.
-    public let base: Base.Index
-
-    @inlinable // lazy-performance
-    internal init(_base: Base.Index) {
-      self.base = _base
-    }
-  }
-}
-
-extension LazyDropWhileCollection.Index: Equatable, Comparable {
-  @inlinable // lazy-performance
-  public static func == (
-    lhs: LazyDropWhileCollection<Base>.Index,
-    rhs: LazyDropWhileCollection<Base>.Index
-  ) -> Bool {
-    return lhs.base == rhs.base
-  }
-
-  @inlinable // lazy-performance
-  public static func < (
-    lhs: LazyDropWhileCollection<Base>.Index,
-    rhs: LazyDropWhileCollection<Base>.Index
-  ) -> Bool {
-    return lhs.base < rhs.base
-  }
-}
-
-extension LazyDropWhileCollection.Index: Hashable where Base.Index: Hashable {
-  /// The hash value.
-  @inlinable
-  public var hashValue: Int {
-    return base.hashValue
-  }
-
-  /// Hashes the essential components of this value by feeding them into the
-  /// given hasher.
-  ///
-  /// - Parameter hasher: The hasher to use when combining the components
-  ///   of this instance.
-  @inlinable
-  public func hash(into hasher: inout Hasher) {
-    hasher.combine(base)
-  }
-}
-
-extension LazyDropWhileCollection: Collection {
   @inlinable // lazy-performance
   public var startIndex: Index {
     var index = _base.startIndex
     while index != _base.endIndex && _predicate(_base[index]) {
       _base.formIndex(after: &index)
     }
-    return Index(_base: index)
+    return index
   }
 
   @inlinable // lazy-performance
   public var endIndex: Index {
-    return Index(_base: _base.endIndex)
+    return _base.endIndex
   }
 
   @inlinable // lazy-performance
   public func index(after i: Index) -> Index {
-    _precondition(i.base < _base.endIndex, "Can't advance past endIndex")
-    return Index(_base: _base.index(after: i.base))
+    _precondition(i < _base.endIndex, "Can't advance past endIndex")
+    return _base.index(after: i)
   }
 
-
   @inlinable // lazy-performance
   public subscript(position: Index) -> Element {
-    return _base[position.base]
+    return _base[position]
   }
 }
 
-extension LazyDropWhileCollection: LazyCollectionProtocol { }
-
 extension LazyDropWhileCollection: BidirectionalCollection 
 where Base: BidirectionalCollection {
   @inlinable // lazy-performance
   public func index(before i: Index) -> Index {
     _precondition(i > startIndex, "Can't move before startIndex")
-    return Index(_base: _base.index(before: i.base))
+    return _base.index(before: i)
   }
 }
-
-extension LazyCollectionProtocol {
-  /// Returns a lazy collection that skips any initial elements that satisfy
-  /// `predicate`.
-  ///
-  /// - Parameter predicate: A closure that takes an element of the collection
-  ///   as its argument and returns `true` if the element should be skipped or
-  ///   `false` otherwise. Once `predicate` returns `false` it will not be
-  ///   called again.
-  @inlinable // lazy-performance
-  public __consuming func drop(
-    while predicate: @escaping (Elements.Element) -> Bool
-  ) -> LazyDropWhileCollection<Self.Elements> {
-    return LazyDropWhileCollection(
-      _base: self.elements, predicate: predicate)
-  }
-}
-