[stdlib] Random: don't randomize FixedWidthIntegers by overwriting their raw memory

Custom FixedWidthInteger types may not support this.

Introduce a new (non-public) FixedWidthInteger requirement for generating random values; implement it using &<</+ in the generic case, and specialize it using RandomNumberGenerator._fill(bytes) for the builtin types.

(cherry picked from commit 54b3b8b)

Author: lorentey

stdlib/public/core/Integers.swift.gyb

@@ -2402,6 +2402,9 @@ ${assignmentOperatorComment(x.operator, False)}
   static func ${x.operator}=(_ lhs: inout Self, _ rhs: Self)
 % end
 
+  static func _random<R: RandomNumberGenerator>(
+    using generator: inout R
+  ) -> Self
 }
 
 extension FixedWidthInteger {
@@ -3022,6 +3025,26 @@ ${assignmentOperatorComment('&' + x.operator, True)}
 % end
 }
 
+extension FixedWidthInteger {
+  public static func _random<R: RandomNumberGenerator>(
+    using generator: inout R
+  ) -> Self {
+    if bitWidth <= UInt64.bitWidth {
+      return Self(truncatingIfNeeded: generator.next() as UInt64)
+    }
+
+    let (quotient, remainder) = bitWidth.quotientAndRemainder(
+      dividingBy: UInt64.bitWidth
+    )
+    var tmp: Self = 0
+    for i in 0 ..< quotient + remainder.signum() {
+      let next: UInt64 = generator.next()
+      tmp += Self(truncatingIfNeeded: next) &<< (UInt64.bitWidth * i)
+    }
+    return tmp
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //===--- UnsignedInteger --------------------------------------------------===//
 //===----------------------------------------------------------------------===//
@@ -4015,6 +4038,16 @@ public func _assumeNonNegative(_ x: ${Self}) -> ${Self} {
 }
 % end
 
+extension ${Self} {
+  public static func _random<R: RandomNumberGenerator>(
+    using generator: inout R
+  ) -> ${Self} {
+    var result: ${Self} = 0
+    withUnsafeMutableBytes(of: &result) { generator._fill(bytes: $0) }
+    return result
+  }
+}
+
 //===--- end of FIXME(integers) -------------------------------------------===//
 
 % end # end of concrete FixedWidthInteger section

stdlib/public/core/Random.swift

@@ -83,26 +83,7 @@ extension RandomNumberGenerator {
   ///   every value of `T` is equally likely to be returned.
   @inlinable
   public mutating func next<T: FixedWidthInteger & UnsignedInteger>() -> T {
-    if T.bitWidth <= UInt64.bitWidth {
-      return T(truncatingIfNeeded: next())
-    }
-
-    let (quotient, remainder) = T.bitWidth.quotientAndRemainder(
-      dividingBy: UInt64.bitWidth
-    )
-    var tmp: T = 0
-
-    for i in 0 ..< quotient {
-      tmp += T(truncatingIfNeeded: next()) &<< (UInt64.bitWidth * i)
-    }
-
-    if remainder != 0 {
-      let random = next()
-      let mask = UInt64.max &>> (UInt64.bitWidth - remainder)
-      tmp += T(truncatingIfNeeded: random & mask) &<< (UInt64.bitWidth * quotient)
-    }
-
-    return tmp
+    return T._random(using: &self)
   }
 
   /// Returns a random value that is less than the given upper bound.
@@ -167,16 +148,6 @@ public struct Random : RandomNumberGenerator {
     _stdlib_random(&random, MemoryLayout<UInt64>.size)
     return random
   }
-  
-  /// Returns a value from a uniform, independent distribution of binary data.
-  ///
-  /// - Returns: A random value of `T`. Bits are randomly distributed so that
-  ///   every value of `T` is equally likely to be returned.
-  public mutating func next<T: FixedWidthInteger & UnsignedInteger>() -> T {
-    var random: T = 0
-    _stdlib_random(&random, MemoryLayout<T>.size)
-    return random
-  }
 
   public mutating func _fill(bytes buffer: UnsafeMutableRawBufferPointer) {
     if !buffer.isEmpty {