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

1. Put the first region inside the if-else (same branch condition).
2. Use the forward distance in the highest region (as done in the middle).

Author: oscbyspro

stdlib/public/core/Flatten.swift

@@ -290,44 +290,42 @@ extension FlattenCollection: Collection {
   @inlinable // lazy-performance
   public func distance(from start: Index, to end: Index) -> Int {
     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 distanceIsNegative {
       _ = _base.distance(from: _base.endIndex, to: _base.startIndex)
     }
-    
+
     // This path handles indices belonging to the same collection.
     if start._outer == end._outer {
       guard let i = start._inner, let j = end._inner else { return 0 }
       return _base[start._outer].distance(from: i, to: j)
     }
-    
+
     // The following path combines the distances of three regions.
-    var distance: Int = 0
-    let step: Int
     let lowerBound: Index
     let upperBound: Index
-    
+
+    let step: Int
+    var distance: Int
+
+    // Note that lowerBound is a valid index because start != end.
     if distanceIsNegative {
       step = -1
       lowerBound = end
       upperBound = start
+      let lowest = _base[lowerBound._outer]
+      distance = lowest.distance(from: lowest.endIndex, to: lowerBound._inner!)
     } else {
       step = 01
       lowerBound = start
       upperBound = end
+      let lowest = _base[lowerBound._outer]
+      distance = lowest.distance(from: lowerBound._inner!, to: lowest.endIndex)
     }
-    
-    // This always unwraps because start._outer != end._outer.
-    if let inner = lowerBound._inner {
-      let collection = _base[lowerBound._outer]
-      distance += distanceIsNegative
-      ? collection.distance(from: collection.endIndex, to: inner)
-      : collection.distance(from: inner, to: collection.endIndex)
-    }
-    
+
     // We can use each collection's count in the middle region since the
     // fast path ensures that the other regions cover a nonzero distance,
     // which means that an extra Int.min distance should trap regardless.
@@ -337,15 +335,16 @@ extension FlattenCollection: Collection {
       distance += _base[outer].count &* step
       _base.formIndex(after: &outer)
     }
-    
-    /// This unwraps if start != endIndex and end != endIndex.
+
+    // This unwraps if start != endIndex and end != endIndex. We can use the
+    // positive distance for the same reason that we can use the collection's
+    // count in the middle region.
     if let inner = upperBound._inner {
-      let collection = _base[upperBound._outer]
-      distance += distanceIsNegative
-      ? collection.distance(from: inner, to: collection.startIndex)
-      : collection.distance(from: collection.startIndex, to: inner)
+      // 0 ... Int.max can always be negated.
+      let highest = _base[upperBound._outer]
+      distance += highest.distance(from: highest.startIndex, to: inner) &* step
     }
-    
+
     return distance
   }