Expand index traversal tests, remove formIndex(_:offsetBy:)

The current index traversal tests didn't invoke every single index
method, so we need a few additional tests. Also run them all on the
`Deque.Indices` collection too.

`formIndex(_:offsetBy:)` turns out not to actually be declared in any
stdlib collection protocol, instead it's just an extension on
`Collection`. Remove our implementations of it in favor of just using
the standard extension. This way the same code is invoked when calling
it on the `Deque` directly as when calling it on a generic type bound by
`Collection`.

Author: lilyball

Diff for: Sources/Deque/Deque.swift

@@ -189,10 +189,8 @@ public struct Deque<Element>: RandomAccessCollection, MutableCollection {
         return _storage.header.index(before: i)
     }
 
-    @inlinable
-    public func formIndex(_ i: inout Index, offsetBy distance: Int) {
-        _storage.header.formIndex(&i, offsetBy: distance)
-    }
+    // Note: formIndex(_:offsetBy:) is not actually declared in any collection protocol, it's
+    // instead provided as an extension using index(_:offsetBy:), so we can skip it.
 
     @inlinable
     public func index(_ i: Index, offsetBy distance: Int) -> Index {
@@ -854,11 +852,6 @@ public struct Deque<Element>: RandomAccessCollection, MutableCollection {
             return _header.index(before: i)
         }
 
-        @inlinable
-        public func formIndex(_ i: inout Index, offsetBy distance: Int) {
-            _header.formIndex(&i, offsetBy: distance)
-        }
-        
         @inlinable
         public func index(_ i: Index, offsetBy distance: Int) -> Index {
             return _header.index(i, offsetBy: distance)
@@ -1267,36 +1260,31 @@ internal struct _DequeHeader {
     }
 
     @inlinable
-    func formIndex(_ i: inout Index, offsetBy distance: Int) {
+    func index(_ i: Index, offsetBy distance: Int) -> Index {
+        var rawValue = i._rawValue
         if distance > 0 {
-            let wasHead = i._rawValue < Index._tailFlag
-            i._rawValue += UInt(bitPattern: distance)
-            if wasHead && i._rawValue >= UInt(bitPattern: capacity) && tailCount > 0 {
+            let wasHead = rawValue < Index._tailFlag
+            rawValue += UInt(bitPattern: distance)
+            if wasHead && rawValue >= UInt(bitPattern: capacity) && tailCount > 0 {
                 // Wrap around
-                i._rawValue = (i._rawValue &- UInt(bitPattern: capacity)) | Index._tailFlag
+                rawValue = (rawValue &- UInt(bitPattern: capacity)) | Index._tailFlag
             }
         } else if distance < 0 {
-            if i._rawValue >= Index._tailFlag {
-                i._rawValue &+= UInt(bitPattern: distance) // equivalent to signed addition
-                if i._rawValue < Index._tailFlag {
+            if rawValue >= Index._tailFlag {
+                rawValue &+= UInt(bitPattern: distance) // equivalent to signed addition
+                if rawValue < Index._tailFlag {
                     // We subtracted past the beginning of the tail
-                    let result = UInt(bitPattern: capacity).subtractingReportingOverflow(Index._tailFlag &- i._rawValue)
+                    let result = UInt(bitPattern: capacity).subtractingReportingOverflow(Index._tailFlag &- rawValue)
                     precondition(!result.overflow, "Attempted to create invalid index") // Report better error on overflow
-                    i._rawValue = result.partialValue
+                    rawValue = result.partialValue
                 }
             } else {
-                let newValue = i._rawValue &+ UInt(bitPattern: distance) // equivalent to signed addition
-                precondition(newValue < i._rawValue, "Attempted to create invalid index") // Report error on overflow
-                i._rawValue = newValue
+                let newValue = rawValue &+ UInt(bitPattern: distance) // equivalent to signed addition
+                precondition(newValue < rawValue, "Attempted to create invalid index") // Report error on overflow
+                rawValue = newValue
             }
         }
-    }
-    
-    @inlinable
-    func index(_ i: Index, offsetBy distance: Int) -> Index {
-        var i = i
-        formIndex(&i, offsetBy: distance)
-        return i
+        return Index(_rawValue: rawValue)
     }
 
     @inlinable

Diff for: Tests/DequeTests/DequeTests.swift

@@ -236,13 +236,33 @@ final class DequeTests: XCTestCase {
             XCTAssertEqual(buf.count, buf.capacity, "buffer count should equal capacity")
         })
 
-        // call this function multiple times so we know which input produced which errors
-        validateIndexTraversals(emptyDeque)
-        validateIndexTraversals(oneElemDeque)
-        validateIndexTraversals(dequeWithCapacity)
-        validateIndexTraversals(dequeWithLeadingCapacity)
-        validateIndexTraversals(dequeWithTail)
-        validateIndexTraversals(dequeWithTailNoGap)
+        func runTests(_ deque: Deque<IntClass>, line: UInt = #line) {
+            func validate<C: RandomAccessCollection>(_ collection: C, line: UInt) {
+                validateIndexTraversals(collection, line: line)
+                // validateIndexTraversals doesn't test all index methods. In particular, for every
+                // nonmutating/mutating pair (such as index(before:) and formIndex(before:)) it only
+                // picks one of them. Add a few tests of our own to ensure coverage.
+                if !collection.isEmpty {
+                    var idx = collection.startIndex
+                    collection.formIndex(after: &idx)
+                    XCTAssertEqual(idx, collection.index(after: collection.startIndex), "formIndex(after:) vs index(after:)", line: line)
+                    idx = collection.endIndex
+                    collection.formIndex(before: &idx)
+                    XCTAssertEqual(idx, collection.index(before: collection.endIndex), "formIndex(before:) vs index(before:)", line: line)
+                    // formIndex(_:offsetBy:) is not actually part of the protocol (it's an
+                    // extension) so we can skip it.
+                }
+            }
+            validate(deque, line: line)
+            validate(deque.indices, line: line)
+        }
+        
+        runTests(emptyDeque)
+        runTests(oneElemDeque)
+        runTests(dequeWithCapacity)
+        runTests(dequeWithLeadingCapacity)
+        runTests(dequeWithTail)
+        runTests(dequeWithTailNoGap)
     }
 
     func testAppendReallocation() {