From 0061d89efada47d059bc9de7ba1ac66cbc1ef9dc Mon Sep 17 00:00:00 2001
From: Ben Rimmington <me@benrimmington.com>
Date: Sun, 10 May 2020 12:44:34 +0100
Subject: [PATCH] [stdlib] Regenerate Slice_Of_*_* validation-tests

---
 ..._DefaultedBidirectionalCollection_FullWidth.swift | 12 ++++++------
 ...DefaultedBidirectionalCollection_WithPrefix.swift | 12 ++++++------
 ...BidirectionalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...DefaultedBidirectionalCollection_WithSuffix.swift | 12 ++++++------
 .../Slice_Of_DefaultedCollection_FullWidth.swift     | 12 ++++++------
 .../Slice_Of_DefaultedCollection_WithPrefix.swift    | 12 ++++++------
 ..._Of_DefaultedCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 .../Slice_Of_DefaultedCollection_WithSuffix.swift    | 12 ++++++------
 ...tedMutableBidirectionalCollection_FullWidth.swift | 12 ++++++------
 ...edMutableBidirectionalCollection_WithPrefix.swift | 12 ++++++------
 ...BidirectionalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...edMutableBidirectionalCollection_WithSuffix.swift | 12 ++++++------
 ...ice_Of_DefaultedMutableCollection_FullWidth.swift | 12 ++++++------
 ...ce_Of_DefaultedMutableCollection_WithPrefix.swift | 12 ++++++------
 ...aultedMutableCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...ce_Of_DefaultedMutableCollection_WithSuffix.swift | 12 ++++++------
 ...ltedMutableRandomAccessCollection_FullWidth.swift | 12 ++++++------
 ...tedMutableRandomAccessCollection_WithPrefix.swift | 12 ++++++------
 ...eRandomAccessCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...tedMutableRandomAccessCollection_WithSuffix.swift | 12 ++++++------
 ...eplaceableBidirectionalCollection_FullWidth.swift | 12 ++++++------
 ...placeableBidirectionalCollection_WithPrefix.swift | 12 ++++++------
 ...BidirectionalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...placeableBidirectionalCollection_WithSuffix.swift | 12 ++++++------
 ...MutableRangeReplaceableCollection_FullWidth.swift | 12 ++++++------
 ...utableRangeReplaceableCollection_WithPrefix.swift | 12 ++++++------
 ...geReplaceableCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...utableRangeReplaceableCollection_WithSuffix.swift | 12 ++++++------
 ...ReplaceableRandomAccessCollection_FullWidth.swift | 12 ++++++------
 ...eplaceableRandomAccessCollection_WithPrefix.swift | 12 ++++++------
 ...eRandomAccessCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...eplaceableRandomAccessCollection_WithSuffix.swift | 12 ++++++------
 ...f_DefaultedRandomAccessCollection_FullWidth.swift | 12 ++++++------
 ..._DefaultedRandomAccessCollection_WithPrefix.swift | 12 ++++++------
 ...dRandomAccessCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ..._DefaultedRandomAccessCollection_WithSuffix.swift | 12 ++++++------
 ...eplaceableBidirectionalCollection_FullWidth.swift | 12 ++++++------
 ...placeableBidirectionalCollection_WithPrefix.swift | 12 ++++++------
 ...BidirectionalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...placeableBidirectionalCollection_WithSuffix.swift | 12 ++++++------
 ...faultedRangeReplaceableCollection_FullWidth.swift | 12 ++++++------
 ...aultedRangeReplaceableCollection_WithPrefix.swift | 12 ++++++------
 ...geReplaceableCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...aultedRangeReplaceableCollection_WithSuffix.swift | 12 ++++++------
 ...ReplaceableRandomAccessCollection_FullWidth.swift | 12 ++++++------
 ...eplaceableRandomAccessCollection_WithPrefix.swift | 12 ++++++------
 ...eRandomAccessCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...eplaceableRandomAccessCollection_WithSuffix.swift | 12 ++++++------
 ...Of_MinimalBidirectionalCollection_FullWidth.swift | 12 ++++++------
 ...f_MinimalBidirectionalCollection_WithPrefix.swift | 12 ++++++------
 ...BidirectionalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...f_MinimalBidirectionalCollection_WithSuffix.swift | 12 ++++++------
 .../Slice/Slice_Of_MinimalCollection_FullWidth.swift | 12 ++++++------
 .../Slice_Of_MinimalCollection_WithPrefix.swift      | 12 ++++++------
 ...ce_Of_MinimalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 .../Slice_Of_MinimalCollection_WithSuffix.swift      | 12 ++++++------
 ...malMutableBidirectionalCollection_FullWidth.swift | 12 ++++++------
 ...alMutableBidirectionalCollection_WithPrefix.swift | 12 ++++++------
 ...BidirectionalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...alMutableBidirectionalCollection_WithSuffix.swift | 12 ++++++------
 ...Slice_Of_MinimalMutableCollection_FullWidth.swift | 12 ++++++------
 ...lice_Of_MinimalMutableCollection_WithPrefix.swift | 12 ++++++------
 ...inimalMutableCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...lice_Of_MinimalMutableCollection_WithSuffix.swift | 12 ++++++------
 ...imalMutableRandomAccessCollection_FullWidth.swift | 12 ++++++------
 ...malMutableRandomAccessCollection_WithPrefix.swift | 12 ++++++------
 ...eRandomAccessCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...malMutableRandomAccessCollection_WithSuffix.swift | 12 ++++++------
 ...eplaceableBidirectionalCollection_FullWidth.swift | 12 ++++++------
 ...placeableBidirectionalCollection_WithPrefix.swift | 12 ++++++------
 ...BidirectionalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...placeableBidirectionalCollection_WithSuffix.swift | 12 ++++++------
 ...MutableRangeReplaceableCollection_FullWidth.swift | 12 ++++++------
 ...utableRangeReplaceableCollection_WithPrefix.swift | 12 ++++++------
 ...geReplaceableCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...utableRangeReplaceableCollection_WithSuffix.swift | 12 ++++++------
 ...ReplaceableRandomAccessCollection_FullWidth.swift | 12 ++++++------
 ...eplaceableRandomAccessCollection_WithPrefix.swift | 12 ++++++------
 ...eRandomAccessCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...eplaceableRandomAccessCollection_WithSuffix.swift | 12 ++++++------
 ..._Of_MinimalRandomAccessCollection_FullWidth.swift | 12 ++++++------
 ...Of_MinimalRandomAccessCollection_WithPrefix.swift | 12 ++++++------
 ...lRandomAccessCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...Of_MinimalRandomAccessCollection_WithSuffix.swift | 12 ++++++------
 ...eplaceableBidirectionalCollection_FullWidth.swift | 12 ++++++------
 ...placeableBidirectionalCollection_WithPrefix.swift | 12 ++++++------
 ...BidirectionalCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...placeableBidirectionalCollection_WithSuffix.swift | 12 ++++++------
 ...MinimalRangeReplaceableCollection_FullWidth.swift | 12 ++++++------
 ...inimalRangeReplaceableCollection_WithPrefix.swift | 12 ++++++------
 ...geReplaceableCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...inimalRangeReplaceableCollection_WithSuffix.swift | 12 ++++++------
 ...ReplaceableRandomAccessCollection_FullWidth.swift | 12 ++++++------
 ...eplaceableRandomAccessCollection_WithPrefix.swift | 12 ++++++------
 ...eRandomAccessCollection_WithPrefixAndSuffix.swift | 12 ++++++------
 ...eplaceableRandomAccessCollection_WithSuffix.swift | 12 ++++++------
 96 files changed, 576 insertions(+), 576 deletions(-)

diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_FullWidth.swift
index ae7117d0efd..d77d027a10d 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithPrefix.swift
index 480cf9153db..69509ba4016 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithPrefixAndSuffix.swift
index 85b19b006e5..1cd887229d7 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithSuffix.swift
index 9083986035d..39138b6db3c 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedBidirectionalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_FullWidth.swift
index 128b5e17ae4..67a8827ca5a 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithPrefix.swift
index 31ca96c4941..8460b714cc0 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithPrefixAndSuffix.swift
index 4447d9b32a8..9224d863623 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithSuffix.swift
index b7e05dce646..e47b10b4b29 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_FullWidth.swift
index 78868cce010..b4221c32568 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithPrefix.swift
index 31c25e3f660..e22d0a6f86e 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithPrefixAndSuffix.swift
index a59167b504f..306bcadbdb4 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithSuffix.swift
index 69b89b611db..c3484c9452a 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableBidirectionalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_FullWidth.swift
index 44302d57b93..37b35cba817 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithPrefix.swift
index f5c4cd29b39..a665ee6a8b4 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithPrefixAndSuffix.swift
index 1f94ff97567..0696be5455e 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithSuffix.swift
index b4dc601b8f0..3ceab4add8a 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_FullWidth.swift
index f5fc573276d..af570f8a425 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithPrefix.swift
index 992361e8398..16a1244e249 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithPrefixAndSuffix.swift
index d5c1444c684..e25c9ede106 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithSuffix.swift
index 69f6cf7aad6..6ba2dbeff26 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRandomAccessCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_FullWidth.swift
index defa773d41f..824fe7f43a3 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithPrefix.swift
index 578a8715195..75b2d324ceb 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift
index f919c43e491..caaffb3fcb3 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithSuffix.swift
index 609e5e56785..5b693af3721 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableBidirectionalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_FullWidth.swift
index 49e7baff8af..faed63aa724 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithPrefix.swift
index 9f0669b4b66..04b3deaba41 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithPrefixAndSuffix.swift
index dbcd95cb2f6..7e10279c543 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithSuffix.swift
index ad659e75c52..fc2760e6aa9 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_FullWidth.swift
index a0e5f7dff2f..cac71f84f54 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithPrefix.swift
index 73555edab13..5499e3737fe 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift
index 155e1204d9a..d5b776e3fd3 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithSuffix.swift
index 3a581ce3113..a9ec5d1831c 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedMutableRangeReplaceableRandomAccessCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_FullWidth.swift
index feed9dac97a..c1c1e31aca4 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithPrefix.swift
index f607312ab21..6a2de162d16 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithPrefixAndSuffix.swift
index 905c4f7f08e..517c4ea7576 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithSuffix.swift
index 26238e3395e..136aa1c9e83 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRandomAccessCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_FullWidth.swift
index 8c58af97c87..0089e063b4b 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithPrefix.swift
index abe2e8f97f4..c66faa2b29d 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift
index 3c63a2a4e5c..759700ea5b5 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithSuffix.swift
index fdcc20d66e2..920bd547a77 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableBidirectionalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_FullWidth.swift
index 4b6e61ea582..d7bb3112974 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithPrefix.swift
index 1dab0c3c444..ca88720e5d1 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithPrefixAndSuffix.swift
index 3aa23d5b202..743d134ace4 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithSuffix.swift
index 6418c1584c4..3f23f40d664 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_FullWidth.swift
index 2c4e9545609..548dfc96921 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithPrefix.swift
index 52ea03ceb23..7c026820da8 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift
index d3dbf0dae44..179d21a67dd 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithSuffix.swift
index 75c2c7cb23d..09e17131d50 100644
--- a/validation-test/stdlib/Slice/Slice_Of_DefaultedRangeReplaceableRandomAccessCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_FullWidth.swift
index 357008fcfc7..8b3202f5fe0 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithPrefix.swift
index d155848aa1b..beac5fd606f 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithPrefixAndSuffix.swift
index db77428106a..1247bcccb21 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithSuffix.swift
index b3ae32ee887..d8513ff3041 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalBidirectionalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_FullWidth.swift
index 0062f1c1ff3..7f10ca8e5b1 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithPrefix.swift
index aa52a685de3..21f0f776317 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithPrefixAndSuffix.swift
index 3e3e0120d23..47986e9333a 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithSuffix.swift
index 28ab2b8b7e6..4a30032f2e6 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_FullWidth.swift
index 7251221774b..1d257573f7e 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithPrefix.swift
index b3d1baee593..d97c928e757 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithPrefixAndSuffix.swift
index ce463763e3f..b5b864cb749 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithSuffix.swift
index fc5e9403643..6d2456567d3 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableBidirectionalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_FullWidth.swift
index b816052ca81..9b5a5deb8bf 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithPrefix.swift
index 39f16afbc4b..fd06599746f 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithPrefixAndSuffix.swift
index 1d668ee8083..3e5f9722c25 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithSuffix.swift
index b46bcaf3be9..d494ed4d455 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_FullWidth.swift
index 9765c04eee4..87a22e2712a 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithPrefix.swift
index 0f98e7e0fb7..a2d8917875d 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithPrefixAndSuffix.swift
index 3505c6cbfb2..dfb6c791ad6 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithSuffix.swift
index 53e3ac40ede..feb534128ff 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRandomAccessCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_FullWidth.swift
index 5239a22a74e..22ae919f866 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithPrefix.swift
index 456215e6789..79c15845083 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift
index 700270e73d4..17a9159b685 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithSuffix.swift
index ef5d5c52fdf..ef25dc34550 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableBidirectionalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_FullWidth.swift
index d41a10eb3b1..67fdb5c48cf 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithPrefix.swift
index 0f91959a903..ccf75700a9b 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithPrefixAndSuffix.swift
index dd4523bbc2b..60d2c8fa5b6 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithSuffix.swift
index e1e6507d00b..bef2282e404 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_FullWidth.swift
index c5a7c43acdd..e0fd37fa81f 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithPrefix.swift
index 1572163bd24..dd98bd71f64 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift
index 354e9adb945..ad0ab33ab36 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithSuffix.swift
index bd4f1c37ad1..cc0d2ff7561 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalMutableRangeReplaceableRandomAccessCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_FullWidth.swift
index 1537aa928ab..56d274af2a5 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithPrefix.swift
index dc625b1dc76..d9e124ad8b9 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithPrefixAndSuffix.swift
index 257edfd08c4..54b0dc2c2b8 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithSuffix.swift
index 4d024917c06..43ace6070c0 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRandomAccessCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_FullWidth.swift
index 278d9d0a4a2..1a6619b82df 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithPrefix.swift
index 08a34a65131..b350f4e238a 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift
index 780ff876bf8..31253cb53b9 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithSuffix.swift
index 9fba2af0df6..616191f95d1 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableBidirectionalCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_FullWidth.swift
index d0ccadae34a..9bb601e621f 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithPrefix.swift
index d01f639680e..2da653c12f7 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithPrefixAndSuffix.swift
index bda8fd6d197..8a0926577a8 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithSuffix.swift
index b01ed44de42..39e36397702 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableCollection_WithSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_FullWidth.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_FullWidth.swift
index d16d701b2e6..f88f865cf2a 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_FullWidth.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithPrefix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithPrefix.swift
index 07560e6af71..1bf30eeddee 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithPrefix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift
index fd2395e47bc..b77cb6742f4 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithPrefixAndSuffix.swift
+++ b/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)
 }
 
diff --git a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithSuffix.swift b/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithSuffix.swift
index 32002b8cc1f..824f748a0b1 100644
--- a/validation-test/stdlib/Slice/Slice_Of_MinimalRangeReplaceableRandomAccessCollection_WithSuffix.swift
+++ b/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)
 }