Upgrade a few more _debugPreconditions to _boundsCheckPrecondition

Author: DougGregor

docs/StandardLibraryProgrammersManual.md

@@ -415,11 +415,15 @@ return
 This should be rarely used. It informs the SIL optimizer that any code dominated by it should be treated as the innermost loop of a performance critical section of code. It cranks optimizer heuristics to 11. Injudicious use of this will degrade performance and bloat binary size.
 
 
-#### <a name="precondition"></a>`_precondition`, `_debugPrecondition`, and `_internalInvariant`
+#### <a name="precondition"></a>`_precondition`, `_debugPrecondition`, `_boundsCheckPrecondition`, and `_internalInvariant`
 
-These three functions are assertions that will trigger a run time trap if violated.
+These four functions are assertions that will trigger a run time trap if violated.
 
 * `_precondition` executes in all build configurations. Use this for invariant enforcement in all user code build configurations
+* `_boundsCheckPrecondition` executes in **used code** is built in either a debug build, or when the upcoming feature `UnsafePointerBoundsSafety`
+    has been enabled. Use this only for `_debugPreconditions` that have
+    historically only been `_debugPrecondition`, but are being updated
+    for Swift 6.
 * `_debugPrecondition` will execute when **user code** is built with assertions enabled. Use this for invariant enforcement that's useful while debugging, but might be prohibitively expensive when user code is configured without assertions.
 * `_internalInvariant` will execute when **standard library code** is built with assertions enabled. Use this for internal only invariant checks that useful for debugging the standard library itself.
 

stdlib/public/core/Character.swift

@@ -174,7 +174,7 @@ extension Character :
   public init(_ s: String) {
     _precondition(!s.isEmpty,
       "Can't form a Character from an empty String")
-    _debugPrecondition(s.index(after: s.startIndex) == s.endIndex,
+    _boundsCheckPrecondition(s.index(after: s.startIndex) == s.endIndex,
       "Can't form a Character from a String containing more than one extended grapheme cluster")
 
     if _fastPath(s._guts._object.isPreferredRepresentation) {

stdlib/public/core/EmptyCollection.swift

@@ -110,12 +110,12 @@ extension EmptyCollection: RandomAccessCollection, MutableCollection {
   @inlinable // trivial-implementation
   public subscript(bounds: Range<Index>) -> SubSequence {
     get {
-      _debugPrecondition(bounds.lowerBound == 0 && bounds.upperBound == 0,
+      _boundsCheckPrecondition(bounds.lowerBound == 0 && bounds.upperBound == 0,
         "Index out of range")
       return self
     }
     set {
-      _debugPrecondition(bounds.lowerBound == 0 && bounds.upperBound == 0,
+      _boundsCheckPrecondition(bounds.lowerBound == 0 && bounds.upperBound == 0,
         "Index out of range")
     }
   }
@@ -128,39 +128,39 @@ extension EmptyCollection: RandomAccessCollection, MutableCollection {
 
   @inlinable // trivial-implementation
   public func index(_ i: Index, offsetBy n: Int) -> Index {
-    _debugPrecondition(i == startIndex && n == 0, "Index out of range")
+    _boundsCheckPrecondition(i == startIndex && n == 0, "Index out of range")
     return i
   }
 
   @inlinable // trivial-implementation
   public func index(
     _ i: Index, offsetBy n: Int, limitedBy limit: Index
   ) -> Index? {
-    _debugPrecondition(i == startIndex && limit == startIndex,
+    _boundsCheckPrecondition(i == startIndex && limit == startIndex,
       "Index out of range")
     return n == 0 ? i : nil
   }
 
   /// The distance between two indexes (always zero).
   @inlinable // trivial-implementation
   public func distance(from start: Index, to end: Index) -> Int {
-    _debugPrecondition(start == 0, "From must be startIndex (or endIndex)")
-    _debugPrecondition(end == 0, "To must be endIndex (or startIndex)")
+    _boundsCheckPrecondition(start == 0, "From must be startIndex (or endIndex)")
+    _boundsCheckPrecondition(end == 0, "To must be endIndex (or startIndex)")
     return 0
   }
 
   @inlinable // trivial-implementation
   public func _failEarlyRangeCheck(_ index: Index, bounds: Range<Index>) {
-    _debugPrecondition(index == 0, "out of bounds")
-    _debugPrecondition(bounds == indices, "invalid bounds for an empty collection")
+    _boundsCheckPrecondition(index == 0, "out of bounds")
+    _boundsCheckPrecondition(bounds == indices, "invalid bounds for an empty collection")
   }
 
   @inlinable // trivial-implementation
   public func _failEarlyRangeCheck(
     _ range: Range<Index>, bounds: Range<Index>
   ) {
-    _debugPrecondition(range == indices, "invalid range for an empty collection")
-    _debugPrecondition(bounds == indices, "invalid bounds for an empty collection")
+    _boundsCheckPrecondition(range == indices, "invalid range for an empty collection")
+    _boundsCheckPrecondition(bounds == indices, "invalid bounds for an empty collection")
   }
 }
 

stdlib/public/core/MutableCollection.swift

@@ -539,7 +539,7 @@ public func swap<T>(_ a: inout T, _ b: inout T) {
   let p1 = Builtin.addressof(&a)
   let p2 = Builtin.addressof(&b)
 #endif
-  _debugPrecondition(
+  _boundsCheckPrecondition(
     p1 != p2,
     "swapping a location with itself is not supported")
 

stdlib/public/core/Range.swift

@@ -301,8 +301,7 @@ where Bound: Strideable, Bound.Stride: SignedInteger
   ///   index.
   @inlinable
   public subscript(position: Index) -> Element {
-    // FIXME: swift-3-indexing-model: tests for the range check.
-    _debugPrecondition(self.contains(position), "Index out of range")
+    _boundsCheckPrecondition(self.contains(position), "Index out of range")
     return position
   }
 }

stdlib/public/core/UnsafeBufferPointer.swift.gyb

@@ -67,9 +67,9 @@ public struct Unsafe${Mutable}BufferPointer<Element>
   public init(
     @_nonEphemeral start: Unsafe${Mutable}Pointer<Element>?, count: Int
   ) {
-    _debugPrecondition(
+    _boundsCheckPrecondition(
       count >= 0, "Unsafe${Mutable}BufferPointer with negative count")
-    _debugPrecondition(
+    _boundsCheckPrecondition(
       count == 0 || start != nil,
       "Unsafe${Mutable}BufferPointer has a nil start and nonzero count")
     self.init(_uncheckedStart: start, count: _assumeNonNegative(count))
@@ -499,7 +499,7 @@ extension Unsafe${Mutable}BufferPointer {
   ) rethrows -> R? {
     let (oldBase, oldCount) = (self.baseAddress, self.count)
     defer { 
-      _debugPrecondition((oldBase, oldCount) == (self.baseAddress, self.count),
+      _boundsCheckPrecondition((oldBase, oldCount) == (self.baseAddress, self.count),
       "UnsafeMutableBufferPointer.withContiguousMutableStorageIfAvailable: replacing the buffer is not allowed")
     } 
     return try body(&self)
@@ -1140,7 +1140,7 @@ extension Unsafe${Mutable}BufferPointer {
       return try body(.init(start: nil, count: 0))
     }
 
-    _debugPrecondition(
+    _boundsCheckPrecondition(
       Int(bitPattern: .init(base)) & (MemoryLayout<T>.alignment-1) == 0,
       "baseAddress must be a properly aligned pointer for types Element and T"
     )
@@ -1150,7 +1150,7 @@ extension Unsafe${Mutable}BufferPointer {
       newCount = count
     } else {
       newCount = count * MemoryLayout<Element>.stride / MemoryLayout<T>.stride
-      _debugPrecondition(
+      _boundsCheckPrecondition(
         MemoryLayout<T>.stride > MemoryLayout<Element>.stride
         ? MemoryLayout<T>.stride % MemoryLayout<Element>.stride == 0
         : MemoryLayout<Element>.stride % MemoryLayout<T>.stride == 0,

test/stdlib/BoundsCheckTraps.swift

@@ -52,4 +52,26 @@ BoundsCheckTraps.test("UnsafeRawBufferPointer")
   _blackHole(array)
 }
 
+BoundsCheckTraps.test("EmptyCollection")
+  .skip(.custom(
+    { _isFastAssertConfiguration() || _isReleaseAssertConfiguration() },
+    reason: "this trap is not guaranteed to happen"))
+  .code {
+  expectCrashLater()
+  var empty = EmptyCollection<Int>()
+  print(empty[0])
+  _blackHole(empty)
+}
+
+BoundsCheckTraps.test("Character")
+  .skip(.custom(
+    { _isFastAssertConfiguration() || _isReleaseAssertConfiguration() },
+    reason: "this trap is not guaranteed to happen"))
+  .code {
+  expectCrashLater()
+  let twoChars = "ab"
+  let char = Character(twoChars)
+  _blackHole(char)
+}
+
 runAllTests()