Optimize splitting of whitespace runs.

According to Time Profiler, a great deal of time was spent in
the `Collection.split` function, specifically allocating and
deallocating the small arrays that held the newline-delimited
whitespace runs. This has been replaced by a hand-written
sequence that lazily computes the runs and avoids all those
allocations. Even doing two passes over the whitespace (first
to compute the number of runs, then to lazily compute the runs
themselves) is significantly faster than hitting the heap.

Author: allevato

Sources/SwiftFormatWhitespaceLinter/LazySplitSequence.swift

@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 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
+//
+//===----------------------------------------------------------------------===//
+
+/// A sequence that lazily computes the longest possible subsequences of a collection, in order,
+/// around elements equal to a specific element.
+struct LazySplitSequence<Base: Collection>: Sequence where Base.Element: Equatable {
+  /// The base collection.
+  private let base: Base
+
+  /// The element around which to split.
+  private let separator: Base.Element
+
+  /// The number of subsequences, which is precomputed when the sequence is initialized.
+  let count: Int
+
+  var underestimatedCount: Int {
+    return count
+  }
+
+  /// Creates a new sequence that lazily computes the longest possible subsequences of a collection,
+  /// in order, around elements equal to the given element.
+  fileprivate init(base: Base, separator: Base.Element) {
+    self.base = base
+    self.separator = separator
+
+    // Precompute the number of subsequences.
+    var count = 1
+    for element in base where element == separator {
+      count += 1
+    }
+    self.count = count
+  }
+
+  func makeIterator() -> Iterator {
+    return Iterator(base: base, separator: separator)
+  }
+
+  struct Iterator: IteratorProtocol {
+    private let base: Base
+    private let separator: Base.Element
+
+    /// The start index of the current subsequence being computed.
+    private var subSequenceStart: Base.Index
+
+    /// The end index of the current subsequence being computed.
+    private var subSequenceEnd: Base.Index
+
+    /// The end index of the base collection.
+    private let endIndex: Base.Index
+
+    /// Indicates whether the last subsequence has been computed.
+    private var done: Bool
+
+    init(base: Base, separator: Base.Element) {
+      self.base = base
+      self.separator = separator
+
+      self.subSequenceStart = base.startIndex
+      self.subSequenceEnd = self.subSequenceStart
+      self.endIndex = base.endIndex
+      self.done = false
+    }
+
+    mutating func next() -> Base.SubSequence? {
+      while subSequenceEnd != endIndex {
+        if base[subSequenceEnd] == separator {
+          let next = base[subSequenceStart..<subSequenceEnd]
+          base.formIndex(after: &subSequenceEnd)
+          subSequenceStart = subSequenceEnd
+          return next
+        }
+        base.formIndex(after: &subSequenceEnd)
+      }
+
+      if !done {
+        done = true
+        return base[subSequenceStart..<endIndex]
+      }
+
+      return nil
+    }
+  }
+}
+
+extension Collection where Element: Equatable {
+  /// Returns a `Sequence` that lazily computes the longest possible subsequences of the collection,
+  /// in order, around elements equal to the given element.
+  ///
+  /// - Parameter separator: The element that should be split upon.
+  /// - Returns: A sequence of subsequences, split from this collection’s elements.
+  func lazilySplit(separator: Element) -> LazySplitSequence<Self> {
+    return LazySplitSequence(base: self, separator: separator)
+  }
+}

Sources/SwiftFormatWhitespaceLinter/RememberingIterator.swift

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 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
+//
+//===----------------------------------------------------------------------===//
+
+/// An iterator that persistently remembers the most recent element returned by `next()`.
+struct RememberingIterator<Base: IteratorProtocol>: IteratorProtocol {
+  /// The wrapped iterator.
+  private var base: Base
+
+  /// The element most recently returned by the `next()` method.
+  ///
+  /// This value will always remain equal to the last non-nil element returned by `next()`, even if
+  /// multiple calls to `next()` are made that return nil after the iterator has been exhausted.
+  /// Therefore, this property only evaluates to `nil` if the iterator had no elements in the first
+  /// place.
+  private(set) var latestElement: Base.Element?
+
+  /// Creates a new remembering iterator that wraps the specified iterator.
+  init(_ base: Base) {
+    self.base = base
+    self.latestElement = nil
+  }
+
+  mutating func next() -> Base.Element? {
+    let element = base.next()
+    if element != nil {
+      latestElement = element
+    }
+    return element
+  }
+}