Use prefix and suffix when getting the first and last n children.

Offsetting indices only works for collections which implement `BidirectionalCollection`, while `suffix(_:)` is available for all collections.
This prevent crashes when e.g. generating a `LogEntry` for instances of `Set`.

This addresses <rdar://problem/39791397>.

Author: cwakamo

PlaygroundLogger/PlaygroundLogger/LogEntry+Reflection.swift

@@ -222,17 +222,11 @@ extension Mirror {
                 numberOfChildren = count
             }
 
-            let start = children.startIndex
-            let max = children.index(start, offsetBy: numberOfChildren)
-
-            return superclassEntries + children[start..<max].map(logEntry(forChild:))
+            return superclassEntries + children.prefix(numberOfChildren).map(logEntry(forChild:))
         }
 
         func logEntries(forLastChildren count: Int) -> [LogEntry] {
-            let max = children.endIndex
-            let start = children.index(max, offsetBy: -count)
-
-            return children[start..<max].map(logEntry(forChild:))
+            return children.suffix(count).map(logEntry(forChild:))
         }
 
         // Ensure that our children are loggable (i.e. their depth is not prohibited by our current policy).

PlaygroundLogger/PlaygroundLoggerTests/LogEntryTests.swift

@@ -30,4 +30,42 @@ class LogEntryTests: XCTestCase {
         XCTAssertEqual(totalChildrenCount, 0)
         XCTAssert(children.isEmpty)
     }
+
+    func testLargeSet() throws {
+        let set = Set(1...1000)
+
+        let logEntry = try LogEntry(describing: set, name: "set", policy: .default)
+
+        guard case let .structured(name, _, _, totalChildrenCount, children, disposition) = logEntry else {
+            XCTFail("Expected a structured log entry")
+            return
+        }
+
+        XCTAssertEqual(name, "set")
+        XCTAssertEqual(totalChildrenCount, 1000)
+        XCTAssertEqual(children.count, 101)
+
+        for (index, childEntry) in children.enumerated() {
+            if index == 80 {
+                // We expect the 81st child to be a gap based on the default logging policy for containers.
+                guard case .gap = childEntry else {
+                    XCTFail("Expected this entry to be a gap entry!")
+                    return
+                }
+            }
+            else {
+                // We expect all other children to be opaque entries representing the Ints in the set.
+                guard case let .opaque(_, _, _, _, representation) = childEntry else {
+                    XCTFail("Expected this entry to be an opaque entry!")
+                    return
+                }
+
+                // We don't know the precise value, due to hashing in the set.
+                // But we *do* know that the value should be an Int64, so check that at least.
+                XCTAssert(representation is Int64)
+            }
+        }
+
+        XCTAssertEqual(disposition, .membershipContainer)
+    }
 }