FlattenSequence/distance(from:to:) untrapping Int.min (v5).

1. FlattenSequence/distance(from:to:) cleanup.
2. FlattenDistanceFromToTests cleanup.
3. FlattenDistanceFromToTests availability checks.

Author: oscbyspro

stdlib/public/core/Flatten.swift

@@ -289,12 +289,12 @@ extension FlattenCollection: Collection {
 
   @inlinable // lazy-performance
   public func distance(from start: Index, to end: Index) -> Int {
-    let minus = start > end
+    let distanceIsNegative = start > end
 
     // The following check ensures that distance(from:to:) is invoked on
     // the _base at least once, to trigger a _precondition in forward only
     // collections.
-    if minus {
+    if distanceIsNegative {
       _ = _base.distance(from: _base.endIndex, to: _base.startIndex)
     }
 
@@ -310,20 +310,20 @@ extension FlattenCollection: Collection {
     let lowerBound: Index
     let upperBound: Index
 
-    if minus {
+    if distanceIsNegative {
+      step = -1
       lowerBound = end
       upperBound = start
-      step = -1
     } else {
+      step = 01
       lowerBound = start
       upperBound = end
-      step = 01
     }
-        
+    
     // This always unwraps because start._outer != end._outer.
     if let inner = lowerBound._inner {
       let collection = _base[lowerBound._outer]
-      distance += minus
+      distance += distanceIsNegative
       ? collection.distance(from: collection.endIndex, to: inner)
       : collection.distance(from: inner, to: collection.endIndex)
     }
@@ -341,7 +341,7 @@ extension FlattenCollection: Collection {
     /// This unwraps if start != endIndex and end != endIndex.
     if let inner = upperBound._inner {
       let collection = _base[upperBound._outer]
-      distance += minus
+      distance += distanceIsNegative
       ? collection.distance(from: inner, to: collection.startIndex)
       : collection.distance(from: collection.startIndex, to: inner)
     }

test/stdlib/FlattenDistanceFromTo.swift

@@ -25,7 +25,10 @@ final class FlattenDistanceFromToTests {
     let tests = FlattenDistanceFromToTests()
     let suite = TestSuite("FlattenDistanceFromToTests")
     suite.test("EachIndexPair", tests.testEachIndexPair)
-    suite.test("MinMaxOutputs", tests.testMinMaxOutputs)
+    if #available(SwiftStdlib 6.0, *) {
+      // The random access time complexity was fixed in Swift 6.0.
+      suite.test("MinMaxRandomAccess", tests.testMinMaxRandomAccess)
+    }
     runAllTests()
   }
 }
@@ -50,7 +53,7 @@ extension FlattenDistanceFromToTests {
   ///     ─────────────────
   ///     [][1][2,2][3,3,3]
   ///
-  func forEachLaneSizeCase(
+  private func forEachLaneSizeCase(
     through limits: [Int],
     perform action: ([[Int]]) -> Void
   ) {
@@ -61,19 +64,18 @@ extension FlattenDistanceFromToTests {
 
       if array[index].count < limits[index] {
         array[index].append(index)
-        continue
-      }
-      
-      while index < limits.endIndex, array[index].count == limits[index] {
-        array.formIndex(after: &index)
-      }
-      
-      if index < limits.endIndex {
-        array[index].append(index)
+      } else {
+        while index < limits.endIndex, array[index].count == limits[index] {
+          array.formIndex(after: &index)
+        }
 
-        while index > array.startIndex {
-          array.formIndex(before: &index)
-          array[index].removeAll(keepingCapacity: true)
+        if index < limits.endIndex {
+          array[index].append(index)
+          
+          while index > array.startIndex {
+            array.formIndex(before: &index)
+            array[index].removeAll(keepingCapacity: true)
+          }
         }
       }
     }
@@ -88,10 +90,10 @@ extension FlattenDistanceFromToTests {
   ///     offset: 2, index: 1,1
   ///     offset: 3, index: 2
   ///
-  func forEachEnumeratedIndexIncludingEndIndex<T: Collection>(
+  private func forEachEnumeratedIndexIncludingEndIndex<T>(
     in collection: T,
     perform action: ((offset: Int, index: T.Index)) -> Void
-  ) {
+  ) where T: Collection {
     var state = (offset: 0, index: collection.startIndex)
     while true {
       action(state)
@@ -148,11 +150,15 @@ extension FlattenDistanceFromToTests {
 
 extension FlattenDistanceFromToTests {
 
-  /// Checks some `Int.min` and `Int.max` distances.
+  /// Checks some `Int.min` and `Int.max` distances with random access.
+  ///
+  /// It needs Swift 6.0+ because prior versions find the distance by
+  /// iterating from one index to the other, which takes way too long.
   ///
   /// - Note: A distance of `Int.min` requires more than `Int.max` elements.
   ///
-  func testMinMaxOutputs() {
+  @available(SwiftStdlib 6.0, *)
+  func testMinMaxRandomAccess() {
     for s: FlattenSequence in [
 
       [-1..<Int.max/1],