[stdlib][SE-0206] Use distinct hash encodings for standard integer types

Fix Hashable conformance of standard integer types so that the number of bits they feed into hasher is exactly Self.bitWidth.

This was intended to be part of SE-0206. However, it would have introduced additional issues with AnyHashable. The custom AnyHashable representations introduced in the previous commit unify hashing for numeric types, eliminating the problem.

Author: lorentey

stdlib/public/core/Integers.swift.gyb

@@ -3885,37 +3885,20 @@ extension ${Self} : Hashable {
   ///   of this instance.
   @inlinable
   public func hash(into hasher: inout Hasher) {
-    // FIXME(hasher): To correctly bridge `Set`s/`Dictionary`s containing
-    // `AnyHashable`-boxed integers, all integer values are currently required
-    // to hash exactly the same way as the corresponding (U)Int64 value.  To fix
-    // this, we should introduce a custom AnyHashable box for integer values
-    // that sign-extends values to 64 bits.
-    % if bits <= word_bits:
-    hasher._combine(_lowWord)
-    % elif bits == 2 * word_bits:
-    if let word = ${"" if signed else "U"}Int(exactly: self) {
-      hasher._combine(word._lowWord)
-    } else {
-      hasher._combine(UInt64(_value))
-    }
-    % else:
-    fatalError("Unsupported integer width")
-    % end
+    hasher._combine(${U}${Self}(_value))
   }
 
   @inlinable
   public func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
-    // FIXME(hasher): Note that the AnyHashable concern applies here too,
-    // because hashValue uses top-level hashing.
-    % if bits <= word_bits:
-    return Hasher._hash(seed: seed, _lowWord)
-    % elif bits == 2 * word_bits:
-    if let word = ${"" if signed else "U"}Int(exactly: self) {
-      return Hasher._hash(seed: seed, word._lowWord)
-    }
+    % if bits == 64:
     return Hasher._hash(seed: seed, UInt64(_value))
+    % elif bits == word_bits:
+    return Hasher._hash(seed: seed, UInt(_value))
     % else:
-    fatalError("Unsupported integer width")
+    return Hasher._hash(
+      seed: seed,
+      bytes: UInt64(truncatingIfNeeded: ${U}${Self}(_value)),
+      count: ${bits / 8})
     % end
   }
 }

validation-test/stdlib/FixedPoint.swift.gyb

@@ -233,22 +233,26 @@ hash_value_test_template = gyb.parse_template("hash_value",
 % for self_ty in all_integer_types(word_bits):
 %   Self = self_ty.stdlib_name
 
-FixedPoint.test("${Self}.hashValue") {
+FixedPoint.test("${Self}.hash(into:)") {
 
 %   for bit_pattern in test_bit_patterns:
 
   do {
 %     input = prepare_bit_pattern(bit_pattern, self_ty.bits, self_ty.is_signed)
     let input = get${Self}(${input})
-    let output = getInt(input.hashValue)
+    var hasher = Hasher()
+    input.hash(into: &hasher)
+    let output = getInt(hasher.finalize())
 
-    var hasher = _SipHash13(_seed: Hasher._seed)
-%     if prepare_bit_pattern(input, word_bits, self_ty.is_signed) == input:
-    hasher._combine(UInt(truncatingIfNeeded: ${input} as ${"" if self_ty.is_signed else "U"}Int))
+%     reference = prepare_bit_pattern(bit_pattern, self_ty.bits, False)
+%     if self_ty.bits == 64:
+    let expected = Hasher._hash(seed: Hasher._seed, ${reference} as UInt64)
 %     else:
-    hasher._combine(UInt64(truncatingIfNeeded: input))
+    let expected = Hasher._hash(
+      seed: Hasher._seed,
+      bytes: ${reference},
+      count: ${self_ty.bits / 8})
 %     end
-    let expected = getInt(Int(truncatingIfNeeded: hasher.finalize()))
     expectEqual(expected, output, "input: \(input)")
   }