[stdlib] Regenerate Slice_Of_*_* validation-tests

validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = DefaultedRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalMutableRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableBidirectionalCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_FullWidth.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithPrefix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 

validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithSuffix.swift

@@ -27,10 +27,10 @@ func makeCollection(elements: [OpaqueValue<Int>])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -42,10 +42,10 @@ func makeCollectionOfEquatable(elements: [MinimalEquatableValue])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }
 
@@ -57,10 +57,10 @@ func makeCollectionOfComparable(elements: [MinimalComparableValue])
   let base = MinimalRangeReplaceableRandomAccessCollection(elements: baseElements)
   let startIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count))
+    offsetBy: prefix.count)
   let endIndex = base.index(
     base.startIndex,
-    offsetBy: numericCast(prefix.count + elements.count))
+    offsetBy: prefix.count + elements.count)
   return Slice(base: base, bounds: startIndex..<endIndex)
 }