[stdlib] _stdlibAssert => _debugPrecondition

Author: Max Moiseev

Diff for: stdlib/public/core/Arrays.swift.gyb

@@ -955,12 +955,12 @@ internal func _arrayOutOfPlaceReplace<
   )
 }
 
-/// A _stdlibAssert check that `i` has exactly reached the end of
+/// A _debugPrecondition check that `i` has exactly reached the end of
 /// `s`.  This test is never used to ensure memory safety; that is
 /// always guaranteed by measuring `s` once and re-using that value.
 // FIXME(ABI): add argument labels.
 internal func _expectEnd<C : Collection>(i: C.Index, _ s: C) {
-  _stdlibAssert(
+  _debugPrecondition(
     i == s.endIndex,
     "invalid Collection: count differed in successive traversals")
 }

Diff for: stdlib/public/core/Assert.swift

@@ -209,7 +209,7 @@ public func _overflowChecked<T>(
 /// They are meant to be used when the check is not comprehensively checking for
 /// all possible errors.
 @_transparent
-public func _stdlibAssert(
+public func _debugPrecondition(
   @autoclosure condition: () -> Bool, _ message: StaticString = StaticString(),
   file: StaticString = #file, line: UInt = #line
 ) {
@@ -223,7 +223,7 @@ public func _stdlibAssert(
 }
 
 @_transparent @noreturn
-public func _stdlibAssertionFailure(
+public func _debugPreconditionFailure(
   message: StaticString = StaticString(),
   file: StaticString = #file, line: UInt = #line) {
   if _isDebugAssertConfiguration() {

Diff for: stdlib/public/core/BridgeObjectiveC.swift

@@ -395,7 +395,7 @@ public struct AutoreleasingUnsafeMutablePointer<Pointee /* TODO : class */>
   public var pointee: Pointee {
     /// Retrieve the value the pointer points to.
     @_transparent get {
-      _stdlibAssert(!_isNull)
+      _debugPrecondition(!_isNull)
       // We can do a strong load normally.
       return UnsafeMutablePointer<Pointee>(self).pointee
     }
@@ -406,7 +406,7 @@ public struct AutoreleasingUnsafeMutablePointer<Pointee /* TODO : class */>
     /// in ARC. This autoreleases the argument before trivially
     /// storing it to the referenced memory.
     @_transparent nonmutating set {
-      _stdlibAssert(!_isNull)
+      _debugPrecondition(!_isNull)
       // Autorelease the object reference.
       typealias OptionalAnyObject = AnyObject?
       Builtin.retain(unsafeBitCast(newValue, to: OptionalAnyObject.self))
@@ -427,7 +427,7 @@ public struct AutoreleasingUnsafeMutablePointer<Pointee /* TODO : class */>
   public subscript(i: Int) -> Pointee {
     @_transparent
     get {
-      _stdlibAssert(!_isNull)
+      _debugPrecondition(!_isNull)
       // We can do a strong load normally.
       return (UnsafePointer<Pointee>(self) + i).pointee
     }

Diff for: stdlib/public/core/Builtin.swift

@@ -236,7 +236,7 @@ public func _unsafeReferenceCast<T, U>(x: T, to: U.Type) -> U {
 @_transparent
 @warn_unused_result
 public func unsafeDowncast<T : AnyObject>(x: AnyObject, to: T.Type) -> T {
-  _stdlibAssert(x is T, "invalid unsafeDowncast")
+  _debugPrecondition(x is T, "invalid unsafeDowncast")
   return Builtin.castReference(x)
 }
 

Diff for: stdlib/public/core/ManagedBuffer.swift

@@ -360,15 +360,15 @@ public struct ManagedBufferPointer<Value, Element> : Equatable {
   internal static func _checkValidBufferClass(
     bufferClass: AnyClass, creating: Bool = false
   ) {
-    _stdlibAssert(
+    _debugPrecondition(
       _class_getInstancePositiveExtentSize(bufferClass) == sizeof(_HeapObject.self)
       || (
         !creating
         && _class_getInstancePositiveExtentSize(bufferClass)
           == _valueOffset + sizeof(Value.self)),
       "ManagedBufferPointer buffer class has illegal stored properties"
     )
-    _stdlibAssert(
+    _debugPrecondition(
       _usesNativeSwiftReferenceCounting(bufferClass),
       "ManagedBufferPointer buffer class must be non-@objc"
     )

Diff for: stdlib/public/core/Optional.swift

@@ -67,7 +67,7 @@ public enum Optional<Wrapped> : NilLiteralConvertible {
       if let x = self {
         return x
       }
-      _stdlibAssertionFailure("unsafelyUnwrapped of nil optional")
+      _debugPreconditionFailure("unsafelyUnwrapped of nil optional")
     }
   }
 

Diff for: stdlib/public/core/Pointer.swift

@@ -55,7 +55,7 @@ func _convertMutableArrayToPointerArgument<
 
   // Call reserve to force contiguous storage.
   a.reserveCapacity(0)
-  _stdlibAssert(a._baseAddressIfContiguous != nil || a.isEmpty)
+  _debugPrecondition(a._baseAddressIfContiguous != nil || a.isEmpty)
 
   return (a._owner, ToPointer(a._baseAddressIfContiguous._rawValue))
 }

Diff for: stdlib/public/core/Range.swift

@@ -94,7 +94,7 @@ public struct Range<
   /// - Precondition: `position` is a valid position in `self` and
   ///   `position != endIndex`.
   public subscript(position: Element) -> Element {
-    _stdlibAssert(position != endIndex, "Index out of range")
+    _debugPrecondition(position != endIndex, "Index out of range")
     return position
   }
 

Diff for: stdlib/public/core/Sort.swift.gyb

@@ -312,7 +312,7 @@ public func swap<T>(a: inout T, _ b: inout T) {
   // Microoptimized to avoid retain/release traffic.
   let p1 = Builtin.addressof(&a)
   let p2 = Builtin.addressof(&b)
-  _stdlibAssert(
+  _debugPrecondition(
     p1 != p2,
     "swapping a location with itself is not supported")
 

Diff for: stdlib/public/core/Unmanaged.swift

@@ -31,7 +31,7 @@ public struct Unmanaged<Instance : AnyObject> {
   public static func fromOpaque(value: OpaquePointer) -> Unmanaged {
     // Null pointer check is a debug check, because it guards only against one
     // specific bad pointer value.
-    _stdlibAssert(
+    _debugPrecondition(
       value != nil,
       "attempt to create an Unmanaged instance from a null pointer")
 

Diff for: stdlib/public/core/UnsafeBufferPointer.swift.gyb

@@ -55,14 +55,14 @@ public struct Unsafe${Mutable}BufferPointer<Element>
   /// Access the `i`th element in the buffer.
   public subscript(i: Int) -> Element {
     get {
-      _stdlibAssert(i >= 0)
-      _stdlibAssert(i < endIndex)
+      _debugPrecondition(i >= 0)
+      _debugPrecondition(i < endIndex)
       return _position[i]
     }
 %if Mutable:
     nonmutating set {
-      _stdlibAssert(i >= 0)
-      _stdlibAssert(i < endIndex)
+      _debugPrecondition(i >= 0)
+      _debugPrecondition(i < endIndex)
       _position[i] = newValue
     }
 %end

Diff for: stdlib/public/core/UnsafePointer.swift.gyb

@@ -144,7 +144,7 @@ public struct ${Self}<Pointee>
   ///   be destroyed or moved from to avoid leaks.
   // FIXME: add tests (since the `count` has been added)
   public func initialize(with newValue: Pointee, count: Int = 1) {
-    _stdlibAssert(count >= 0,
+    _debugPrecondition(count >= 0,
       "${Self}.initialize(with:): negative count")
     // Must not use `initializeFrom` with a `Collection` as that will introduce
     // a cycle.
@@ -179,9 +179,9 @@ public struct ${Self}<Pointee>
   /// - Precondition: The `Pointee`s at `self..<self + count` and
   ///   `source..<source + count` are initialized.
   public func assignFrom(source: ${Self}, count: Int) {
-    _stdlibAssert(
+    _debugPrecondition(
       count >= 0, "${Self}.assignFrom with negative count")
-    _stdlibAssert(
+    _debugPrecondition(
       self < source || self >= source + count,
       "assignFrom non-following overlapping range; use assignBackwardFrom")
     for i in 0..<count {
@@ -204,9 +204,9 @@ public struct ${Self}<Pointee>
   /// - Precondition: The `Pointee`s at `self..<self + count` and
   ///   `source..<source + count` are initialized.
   public func assignBackwardFrom(source: ${Self}, count: Int) {
-    _stdlibAssert(
+    _debugPrecondition(
       count >= 0, "${Self}.assignBackwardFrom with negative count")
-    _stdlibAssert(
+    _debugPrecondition(
       source < self || source >= self + count,
       "${Self}.assignBackwardFrom non-preceding overlapping range; use assignFrom instead")
     var i = count-1
@@ -234,9 +234,9 @@ public struct ${Self}<Pointee>
   ///   initialized and the memory at `source..<source + count` is
   ///   uninitialized.
   public func moveInitializeFrom(source: ${Self}, count: Int) {
-    _stdlibAssert(
+    _debugPrecondition(
       count >= 0, "${Self}.moveInitializeFrom with negative count")
-    _stdlibAssert(
+    _debugPrecondition(
       self < source || self >= source + count,
       "${Self}.moveInitializeFrom non-following overlapping range; use moveInitializeBackwardFrom")
     Builtin.takeArrayFrontToBack(
@@ -265,9 +265,9 @@ public struct ${Self}<Pointee>
   ///   initialized and the memory at `source..<source + count` is
   ///   uninitialized.
   public func moveInitializeBackwardFrom(source: ${Self}, count: Int) {
-    _stdlibAssert(
+    _debugPrecondition(
       count >= 0, "${Self}.moveInitializeBackwardFrom with negative count")
-    _stdlibAssert(
+    _debugPrecondition(
       source < self || source >= self + count,
       "${Self}.moveInitializeBackwardFrom non-preceding overlapping range; use moveInitializeFrom instead")
     Builtin.takeArrayBackToFront(
@@ -296,9 +296,9 @@ public struct ${Self}<Pointee>
   /// - Postcondition: The `Pointee`s at `self..<self + count` and
   ///   `source..<source + count` are initialized.
   public func initializeFrom(source: ${Self}, count: Int) {
-    _stdlibAssert(
+    _debugPrecondition(
       count >= 0, "${Self}.initializeFrom with negative count")
-    _stdlibAssert(
+    _debugPrecondition(
       self + count <= source || source + count <= self,
       "${Self}.initializeFrom non-following overlapping range")
     Builtin.copyArray(
@@ -337,9 +337,9 @@ public struct ${Self}<Pointee>
   ///   initialized and the `Pointees` at `source..<source + count`
   ///   are uninitialized.
   public func moveAssignFrom(source: ${Self}, count: Int) {
-    _stdlibAssert(
+    _debugPrecondition(
       count >= 0, "${Self}.moveAssignFrom with negative count")
-    _stdlibAssert(
+    _debugPrecondition(
       self + count <= source || source + count <= self,
       "moveAssignFrom overlapping range")
     Builtin.destroyArray(Pointee.self, self._rawValue, count._builtinWordValue)
@@ -359,7 +359,7 @@ public struct ${Self}<Pointee>
   ///
   /// - Postcondition: The memory is uninitialized.
   public func deinitialize(count count: Int = 1) {
-    _stdlibAssert(count >= 0, "${Self}.deinitialize with negative count")
+    _debugPrecondition(count >= 0, "${Self}.deinitialize with negative count")
     // FIXME: optimization should be implemented, where if the `count` value
     // is 1, the `Builtin.destroy(Pointee.self, _rawValue)` gets called.
     Builtin.destroyArray(Pointee.self, _rawValue, count._builtinWordValue)

Diff for: test/1_stdlib/Unmanaged.swift

@@ -27,7 +27,7 @@ var UnmanagedTests = TestSuite("Unmanaged")
 UnmanagedTests.test("fromOpaque()/trap")
   .skip(.custom(
     { !_isDebugAssertConfiguration() },
-    reason: "init(bitPattern:) does a _stdlibAssert() for null pointers"))
+    reason: "init(bitPattern:) does a _debugPrecondition() for null pointers"))
   .code {
   let null: OpaquePointer = getPointer(nil)
   expectCrashLater()

Diff for: test/1_stdlib/UnsafePointer.swift.gyb

@@ -192,7 +192,7 @@ UnsafeMutablePointerTestSuite.test("moveInitializeBackwardFrom") {
   check(Check.RightOverlap)
   check(Check.Disjoint)
 
-  // This check relies on _stdlibAssert() so will only trigger in -Onone mode.
+  // This check relies on _debugPrecondition() so will only trigger in -Onone mode.
   if _isDebugAssertConfiguration() {
     expectCrashLater()
     check(Check.LeftOverlap)
@@ -202,7 +202,7 @@ UnsafeMutablePointerTestSuite.test("moveInitializeBackwardFrom") {
 UnsafeMutablePointerTestSuite.test("moveAssignFrom") {
   let check = checkPtr(UnsafeMutablePointer.moveAssignFrom, true)
   check(Check.Disjoint)
-  // This check relies on _stdlibAssert() so will only trigger in -Onone mode.
+  // This check relies on _debugPrecondition() so will only trigger in -Onone mode.
   if _isDebugAssertConfiguration() {
     expectCrashLater()
     check(Check.LeftOverlap)
@@ -211,7 +211,7 @@ UnsafeMutablePointerTestSuite.test("moveAssignFrom") {
 
 UnsafeMutablePointerTestSuite.test("moveAssignFrom.Right") {
   let check = checkPtr(UnsafeMutablePointer.moveAssignFrom, true)
-  // This check relies on _stdlibAssert() so will only trigger in -Onone mode.
+  // This check relies on _debugPrecondition() so will only trigger in -Onone mode.
   if _isDebugAssertConfiguration() {
     expectCrashLater()
     check(Check.RightOverlap)
@@ -222,7 +222,7 @@ UnsafeMutablePointerTestSuite.test("assignFrom") {
   let check = checkPtr(UnsafeMutablePointer.assignFrom, true)
   check(Check.LeftOverlap)
   check(Check.Disjoint)
-  // This check relies on _stdlibAssert() so will only trigger in -Onone mode.
+  // This check relies on _debugPrecondition() so will only trigger in -Onone mode.
   if _isDebugAssertConfiguration() {
     expectCrashLater()
     check(Check.RightOverlap)
@@ -233,7 +233,7 @@ UnsafeMutablePointerTestSuite.test("assignBackwardFrom") {
   let check = checkPtr(UnsafeMutablePointer.assignBackwardFrom, true)
   check(Check.RightOverlap)
   check(Check.Disjoint)
-  // This check relies on _stdlibAssert() so will only trigger in -Onone mode.
+  // This check relies on _debugPrecondition() so will only trigger in -Onone mode.
   if _isDebugAssertConfiguration() {
     expectCrashLater()
     check(Check.LeftOverlap)
@@ -244,7 +244,7 @@ UnsafeMutablePointerTestSuite.test("moveInitializeFrom") {
   let check = checkPtr(UnsafeMutablePointer.moveInitializeFrom, false)
   check(Check.LeftOverlap)
   check(Check.Disjoint)
-  // This check relies on _stdlibAssert() so will only trigger in -Onone mode.
+  // This check relies on _debugPrecondition() so will only trigger in -Onone mode.
   if _isDebugAssertConfiguration() {
     expectCrashLater()
     check(Check.RightOverlap)
@@ -254,7 +254,7 @@ UnsafeMutablePointerTestSuite.test("moveInitializeFrom") {
 UnsafeMutablePointerTestSuite.test("initializeFrom") {
   let check = checkPtr(UnsafeMutablePointer.initializeFrom, false)
   check(Check.Disjoint)
-  // This check relies on _stdlibAssert() so will only trigger in -Onone mode.
+  // This check relies on _debugPrecondition() so will only trigger in -Onone mode.
   if _isDebugAssertConfiguration() {
     expectCrashLater()
     check(Check.LeftOverlap)
@@ -263,7 +263,7 @@ UnsafeMutablePointerTestSuite.test("initializeFrom") {
 
 UnsafeMutablePointerTestSuite.test("initializeFrom.Right") {
   let check = checkPtr(UnsafeMutablePointer.initializeFrom, false)
-  // This check relies on _stdlibAssert() so will only trigger in -Onone mode.
+  // This check relies on _debugPrecondition() so will only trigger in -Onone mode.
   if _isDebugAssertConfiguration() {
     expectCrashLater()
     check(Check.RightOverlap)

Diff for: test/Frontend/OptimizationOptions-with-stdlib-checks.swift

@@ -25,7 +25,7 @@ func test_precondition_check(x: Int, y: Int) -> Int {
 }
 
 func test_partial_safety_check(x: Int, y: Int) -> Int {
-  _stdlibAssert(x > y, "test partial safety check")
+  _debugPrecondition(x > y, "test partial safety check")
   return x + y
 }
 

Diff for: test/Frontend/OptimizationOptions-without-stdlib-checks.swift

@@ -25,7 +25,7 @@ func test_precondition_check(x: Int, y: Int) -> Int {
 }
 
 func test_partial_safety_check(x: Int, y: Int) -> Int {
-  _stdlibAssert(x > y, "test partial safety check")
+  _debugPrecondition(x > y, "test partial safety check")
   return x + y
 }
 

Diff for: validation-test/stdlib/Assert.swift

@@ -34,7 +34,7 @@ func testTrapsAreNoreturn(i: Int) -> Int {
   case 3:
     _preconditionFailure("cannot happen")
   case 4:
-    _stdlibAssertionFailure("cannot happen")
+    _debugPreconditionFailure("cannot happen")
   case 5:
     _sanityCheckFailure("cannot happen")
 
@@ -176,26 +176,26 @@ Assert.test("_preconditionFailure")
   _preconditionFailure("this should fail")
 }
 
-Assert.test("_stdlibAssert")
+Assert.test("_debugPrecondition")
   .xfail(.custom(
     { !_isDebugAssertConfiguration() },
     reason: "debug preconditions are disabled in Release and Unchecked mode"))
   .crashOutputMatches(_isDebugAssertConfiguration() ? "this should fail" : "")
   .code {
   var x = 2
-  _stdlibAssert(x * 21 == 42, "should not fail")
+  _debugPrecondition(x * 21 == 42, "should not fail")
   expectCrashLater()
-  _stdlibAssert(x == 42, "this should fail")
+  _debugPrecondition(x == 42, "this should fail")
 }
 
-Assert.test("_stdlibAssertionFailure")
+Assert.test("_debugPreconditionFailure")
   .skip(.custom(
     { !_isDebugAssertConfiguration() },
     reason: "optimizer assumes that the code path is unreachable"))
   .crashOutputMatches("this should fail")
   .code {
   expectCrashLater()
-  _stdlibAssertionFailure("this should fail")
+  _debugPreconditionFailure("this should fail")
 }
 
 Assert.test("_sanityCheck")