[stdlib] extendingOrTruncating: => truncatingIfNeeded:

Author: Maxim Moiseev

stdlib/private/StdlibUnicodeUnittest/Collation.swift

@@ -338,13 +338,13 @@ public struct StringComparisonTest {
 
 public func sortKey(forCollationElements ces: [UInt64]) -> ([UInt16], [UInt16], [UInt16]) {
   func L1(_ ce: UInt64) -> UInt16 {
-    return UInt16(extendingOrTruncating: ce &>> 32)
+    return UInt16(truncatingIfNeeded: ce &>> 32)
   }
   func L2(_ ce: UInt64) -> UInt16 {
-    return UInt16(extendingOrTruncating: ce &>> 16)
+    return UInt16(truncatingIfNeeded: ce &>> 16)
   }
   func L3(_ ce: UInt64) -> UInt16 {
-    return UInt16(extendingOrTruncating: ce)
+    return UInt16(truncatingIfNeeded: ce)
   }
 
   var result1: [UInt16] = []

stdlib/public/core/ASCII.swift

@@ -41,7 +41,7 @@ extension Unicode.ASCII : Unicode.Encoding {
     _ source: Unicode.Scalar
   ) -> EncodedScalar? {
     guard source.value < (1&<<7) else { return nil }
-    return EncodedScalar(UInt8(extendingOrTruncating: source.value))
+    return EncodedScalar(UInt8(truncatingIfNeeded: source.value))
   }
 
   @inline(__always)
@@ -80,7 +80,7 @@ extension Unicode.ASCII.Parser : Unicode.Parser {
   where I.Element == Encoding.CodeUnit {
     let n = input.next()
     if _fastPath(n != nil), let x = n {
-      guard _fastPath(Int8(extendingOrTruncating: x) >= 0)
+      guard _fastPath(Int8(truncatingIfNeeded: x) >= 0)
       else { return .error(length: 1) }
       return .valid(Unicode.ASCII.EncodedScalar(x))
     }

stdlib/public/core/ArrayBody.swift

@@ -32,7 +32,7 @@ internal struct _ArrayBody {
     _storage = _SwiftArrayBodyStorage(
       count: count,
       _capacityAndFlags:
-        (UInt(extendingOrTruncating: capacity) &<< 1) |
+        (UInt(truncatingIfNeeded: capacity) &<< 1) |
         (elementTypeIsBridgedVerbatim ? 1 : 0))
   }
 

stdlib/public/core/Builtin.swift

@@ -90,8 +90,7 @@ func _canBeClass<T>(_: T.Type) -> Int8 {
 /// - Value conversion from one integer type to another. Use the destination
 ///   type's initializer or the `numericCast(_:)` function.
 /// - Bitwise conversion from one integer type to another. Use the destination
-///   type's `init(extendingOrTruncating:)` or `init(bitPattern:)`
-///   initializer.
+///   type's `init(truncatingIfNeeded:)` or `init(bitPattern:)` initializer.
 /// - Conversion from a pointer to an integer value with the bit pattern of the
 ///   pointer's address in memory, or vice versa. Use the `init(bitPattern:)`
 ///   initializer for the destination type.

stdlib/public/core/Character.swift

@@ -130,7 +130,7 @@ public struct Character :
           shift += 16
         }
       }
-      guard _fastPath(Int64(extendingOrTruncating: bits) >= 0) else {
+      guard _fastPath(Int64(truncatingIfNeeded: bits) >= 0) else {
         break FastPath
       }
       _representation = .smallUTF16(Builtin.trunc_Int64_Int63(bits._value))
@@ -224,7 +224,7 @@ public struct Character :
 
     if _fastPath(s._core.count <= 4) {
       let b = _UIntBuffer<UInt64, Unicode.UTF16.CodeUnit>(s._core)
-      if _fastPath(Int64(extendingOrTruncating: b._storage) >= 0) {
+      if _fastPath(Int64(truncatingIfNeeded: b._storage) >= 0) {
         _representation = .smallUTF16(
           Builtin.trunc_Int64_Int63(b._storage._value))
         return
@@ -300,7 +300,7 @@ extension Character {
     return _UIntBuffer<UInt64, Unicode.UTF16.CodeUnit>(
       _storage: bits,
       _bitCount: UInt8(
-        extendingOrTruncating: 16 * Swift.max(1, (minBitWidth + 15) / 16))
+        truncatingIfNeeded: 16 * Swift.max(1, (minBitWidth + 15) / 16))
     )
   }
 

stdlib/public/core/CharacterUnicodeScalars.swift

@@ -101,7 +101,7 @@ extension Character.UnicodeScalarView : Collection {
     case .valid(let s):
       return Index(
         _encodedOffset: startOfNextScalar, _scalar: s,
-        _stride: UInt8(extendingOrTruncating: s.count))
+        _stride: UInt8(truncatingIfNeeded: s.count))
     case .error:
       return Index(
         _encodedOffset: startOfNextScalar,
@@ -138,7 +138,7 @@ extension Character.UnicodeScalarView : BidirectionalCollection {
     case .valid(let s):
       return Index(
         _encodedOffset: i._encodedOffset - s.count, _scalar: s,
-        _stride: UInt8(extendingOrTruncating: s.count))
+        _stride: UInt8(truncatingIfNeeded: s.count))
     case .error:
       return Index(
         _encodedOffset: i._encodedOffset - 1,

stdlib/public/core/DoubleWidth.swift.gyb

@@ -289,7 +289,7 @@ public struct DoubleWidth<Base : FixedWidthInteger> :
     by rhs: DoubleWidth
   ) -> (partialValue: DoubleWidth, overflow: ArithmeticOverflow) {
     let (carry, product) = multipliedFullWidth(by: rhs)
-    let result = DoubleWidth(extendingOrTruncating: product)
+    let result = DoubleWidth(truncatingIfNeeded: product)
 
     let isNegative = (self < (0 as DoubleWidth)) != (rhs < (0 as DoubleWidth))
     let didCarry = isNegative
@@ -447,7 +447,7 @@ public struct DoubleWidth<Base : FixedWidthInteger> :
 
     // Shift is exactly the width of `Base`, so low -> high.
     if rhs._storage.low == Base.bitWidth {
-      lhs = DoubleWidth((High(extendingOrTruncating: lhs._storage.low), 0))
+      lhs = DoubleWidth((High(truncatingIfNeeded: lhs._storage.low), 0))
       return
     }
 
@@ -472,7 +472,7 @@ public struct DoubleWidth<Base : FixedWidthInteger> :
     if rhs._storage.low == Base.bitWidth {
       lhs = DoubleWidth((
         lhs < (0 as DoubleWidth) ? ~0 : 0,
-        Low(extendingOrTruncating: lhs._storage.high)
+        Low(truncatingIfNeeded: lhs._storage.high)
       ))
       return
     }
@@ -485,10 +485,10 @@ public struct DoubleWidth<Base : FixedWidthInteger> :
 
     lhs._storage.high <<= High(rhs._storage.low)
     if Base.bitWidth > rhs._storage.low {
-      lhs._storage.high |= High(extendingOrTruncating: lhs._storage.low >>
+      lhs._storage.high |= High(truncatingIfNeeded: lhs._storage.low >>
         (numericCast(Base.bitWidth) - rhs._storage.low))
     } else {
-      lhs._storage.high |= High(extendingOrTruncating: lhs._storage.low <<
+      lhs._storage.high |= High(truncatingIfNeeded: lhs._storage.low <<
         (rhs._storage.low - numericCast(Base.bitWidth)))
     }
     lhs._storage.low <<= rhs._storage.low
@@ -500,14 +500,14 @@ public struct DoubleWidth<Base : FixedWidthInteger> :
     lhs._storage.low >>= rhs._storage.low
     if Base.bitWidth > rhs._storage.low {
       lhs._storage.low |= Low(
-        extendingOrTruncating:
+        truncatingIfNeeded:
         lhs._storage.high << (numericCast(Base.bitWidth) - rhs._storage.low))
     } else {
       lhs._storage.low |= Low(
-        extendingOrTruncating: lhs._storage.high >>
+        truncatingIfNeeded: lhs._storage.high >>
         (rhs._storage.low - numericCast(Base.bitWidth)))
     }
-    lhs._storage.high >>= High(extendingOrTruncating: rhs._storage.low)
+    lhs._storage.high >>= High(truncatingIfNeeded: rhs._storage.low)
   }
 
 %{
@@ -578,8 +578,8 @@ binaryOperators = [
 
   @_transparent
   public var byteSwapped: DoubleWidth {
-    return DoubleWidth((High(extendingOrTruncating: low.byteSwapped),
-      Low(extendingOrTruncating: high.byteSwapped)))
+    return DoubleWidth((High(truncatingIfNeeded: low.byteSwapped),
+      Low(truncatingIfNeeded: high.byteSwapped)))
   }
 }
 

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -754,11 +754,11 @@ extension ${Self} : Hashable {
     %if bits <= word_bits:
       return Int(bitPattern: UInt(bitPattern))
     %elif bits == 64: # Double -> 32-bit Int
-      return Int(extendingOrTruncating: bitPattern &>> 32) ^
-             Int(extendingOrTruncating: bitPattern)
+      return Int(truncatingIfNeeded: bitPattern &>> 32) ^
+             Int(truncatingIfNeeded: bitPattern)
     %elif word_bits == 32: # Float80 -> 32-bit Int
-      return Int(extendingOrTruncating: significandBitPattern &>> 32) ^
-             Int(extendingOrTruncating: significandBitPattern) ^
+      return Int(truncatingIfNeeded: significandBitPattern &>> 32) ^
+             Int(truncatingIfNeeded: significandBitPattern) ^
              Int(_representation.signAndExponent)
     %else: # Float80 -> 64-bit Int
       return Int(bitPattern: UInt(significandBitPattern)) ^

stdlib/public/core/IntegerParsing.swift

@@ -18,14 +18,14 @@ internal func _asciiDigit<CodeUnit : UnsignedInteger, Result : BinaryInteger>(
   let lower = _ascii16("a")..._ascii16("z")
   let upper = _ascii16("A")..._ascii16("Z")
 
-  let u = UInt16(extendingOrTruncating: u_)
+  let u = UInt16(truncatingIfNeeded: u_)
   let d: UInt16
   if _fastPath(digit ~= u) { d = u &- digit.lowerBound }
   else if _fastPath(upper ~= u) { d = u &- upper.lowerBound &+ 10 }
   else if _fastPath(lower ~= u) { d = u &- lower.lowerBound &+ 10 }
   else { return nil }
   guard _fastPath(d < radix) else { return nil }
-  return Result(extendingOrTruncating: d)
+  return Result(truncatingIfNeeded: d)
 }
 
 @inline(__always)