[stdlib] Implement top-level hashing for stdlib types

Author: lorentey

stdlib/public/core/Arrays.swift.gyb

@@ -2270,6 +2270,17 @@ extension ${Self}: Hashable where Element: Hashable {
       hasher.combine(element)
     }
   }
+
+  @inlinable // FIXME(sil-serialize-all)
+  public func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    var hasher = Hasher(_seed: seed)
+    // Note that we don't need to use delimiters/discriminators for top-level
+    // hashing.
+    for element in self {
+      hasher.combine(element)
+    }
+    return hasher._finalize()
+  }
 }
 
 extension ${Self} {

stdlib/public/core/Bool.swift

@@ -144,19 +144,21 @@ extension Bool : CustomStringConvertible {
 public // COMPILER_INTRINSIC
 func _getBool(_ v: Builtin.Int1) -> Bool { return Bool(v) }
 
-extension Bool : Equatable, Hashable {
-  @inlinable // FIXME(sil-serialize-all)
-  public func hash(into hasher: inout Hasher) {
-    hasher.combine((self ? 1 : 0) as UInt8)
-  }
-
+extension Bool: Equatable {
   @inlinable // FIXME(sil-serialize-all)
   @_transparent
   public static func == (lhs: Bool, rhs: Bool) -> Bool {
     return Bool(Builtin.cmp_eq_Int1(lhs._value, rhs._value))
   }
 }
 
+extension Bool: Hashable {
+  @inlinable // FIXME(sil-serialize-all)
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine((self ? 1 : 0) as UInt8)
+  }
+}
+
 extension Bool : LosslessStringConvertible {
   /// Creates a new Boolean value from the given string.
   ///

stdlib/public/core/Dictionary.swift

@@ -1453,13 +1453,28 @@ extension Dictionary: Hashable where Value: Hashable {
   public func hash(into hasher: inout Hasher) {
     var commutativeHash = 0
     for (k, v) in self {
-      var elementHasher = Hasher()
+      // Note that we use a copy of the outer hasher here. This makes collisions
+      // dependent on its state, eliminating static collision patterns.
+      var elementHasher = hasher
       elementHasher.combine(k)
       elementHasher.combine(v)
       commutativeHash ^= elementHasher._finalize()
     }
     hasher.combine(commutativeHash)
   }
+
+  @inlinable // FIXME(sil-serialize-all)
+  public func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    var commutativeHash = 0
+    let hasher = Hasher(_seed: seed)
+    for (k, v) in self {
+      var elementHasher = hasher
+      elementHasher.combine(k)
+      elementHasher.combine(v)
+      commutativeHash ^= elementHasher._finalize()
+    }
+    return commutativeHash
+  }
 }
 
 extension Dictionary: CustomStringConvertible, CustomDebugStringConvertible {
@@ -4325,11 +4340,6 @@ extension Dictionary.Index {
     }
   }
 
-  @inlinable // FIXME(sil-serialize-all)
-  public var hashValue: Int {
-    return _hashValue(for: self)
-  }
-
   @inlinable // FIXME(sil-serialize-all)
   public func hash(into hasher: inout Hasher) {
   #if _runtime(_ObjC)

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -1537,6 +1537,22 @@ extension ${Self} : Hashable {
   %end
   }
 
+  @inlinable // FIXME(sil-serialize-all)
+  public func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    // To satisfy the axiom that equality implies hash equality, we need to
+    // finesse the hash value of -0.0 to match +0.0.
+    let v = isZero ? 0 : self
+  %if bits == 80:
+    var hasher = Hasher(_seed: seed)
+    hasher.combine(v._representation.signAndExponent)
+    hasher.combine(v.significandBitPattern)
+    return hasher._finalize()
+  %elif bits == 64:
+    return Hasher._hash(seed: seed, v.bitPattern)
+  %elif bits == 32:
+    return Hasher._hash(seed: seed, bytes: UInt64(v.bitPattern), count: 4)
+  %end
+  }
 }
 
 extension ${Self} {

stdlib/public/core/Integers.swift.gyb

@@ -3713,6 +3713,22 @@ extension ${Self} : Hashable {
     fatalError("Unsupported integer width")
     % end
   }
+
+  @inlinable // FIXME(sil-serialize-all)
+  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)
+    }
+    return Hasher._hash(seed: seed, UInt64(_value))
+    % else:
+    fatalError("Unsupported integer width")
+    % end
+  }
 }
 
 

stdlib/public/core/Set.swift

@@ -487,11 +487,16 @@ extension Set: Hashable {
   @inlinable // FIXME(sil-serialize-all)
   public func hash(into hasher: inout Hasher) {
     // FIXME(ABI)#177: <rdar://problem/18915294> Cache Set<T> hashValue
+    hasher.combine(_rawHashValue(seed: hasher._generateSeed()))
+  }
+
+  @inlinable // FIXME(sil-serialize-all)
+  public func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
     var hash = 0
     for member in self {
-      hash ^= _hashValue(for: member)
+      hash ^= member._rawHashValue(seed: seed)
     }
-    hasher.combine(hash)
+    return hash
   }
 }
 
@@ -3647,11 +3652,6 @@ extension Set.Index {
     }
   }
 
-  @inlinable // FIXME(sil-serialize-all)
-  public var hashValue: Int {
-    return _hashValue(for: self)
-  }
-
   @inlinable // FIXME(sil-serialize-all)
   public func hash(into hasher: inout Hasher) {
   #if _runtime(_ObjC)

stdlib/public/core/StringHashable.swift

@@ -49,20 +49,36 @@ extension _UnmanagedString where CodeUnit == UInt8 {
     self.hashASCII(into: &hasher._core)
     hasher._core.combine(0xFF as UInt8) // terminator
   }
+
+  internal func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    return Hasher._hash(seed: seed, bytes: rawBuffer)
+  }
 }
 
 extension _UnmanagedString where CodeUnit == UInt16 {
   internal func hash(into hasher: inout Hasher) {
     self.hashUTF16(into: &hasher._core)
     hasher._core.combine(0xFF as UInt8) // terminator
   }
+
+  internal func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    var core = Hasher.Core(seed: seed)
+    self.hashUTF16(into: &core)
+    return Int(truncatingIfNeeded: core.finalize())
+  }
 }
 
 extension _UnmanagedOpaqueString {
   internal func hash(into hasher: inout Hasher) {
     self.hashUTF16(into: &hasher._core)
     hasher._core.combine(0xFF as UInt8) // terminator
   }
+
+  internal func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    var core = Hasher.Core(seed: seed)
+    self.hashUTF16(into: &core)
+    return Int(truncatingIfNeeded: core.finalize())
+  }
 }
 
 extension _SmallUTF8String {
@@ -75,6 +91,17 @@ extension _SmallUTF8String {
       return
     }
     self.withUnmanagedUTF16 { $0.hash(into: &hasher) }
+#endif // 64-bit
+  }
+
+  internal func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+#if arch(i386) || arch(arm)
+    unsupportedOn32bit()
+#else
+    if isASCII {
+      return self.withUnmanagedASCII { $0._rawHashValue(seed: seed) }
+    }
+    return self.withUnmanagedUTF16 { $0._rawHashValue(seed: seed) }
 #endif // 64-bit
   }
 }
@@ -119,18 +146,65 @@ extension _StringGuts {
     }
     _unmanagedUTF16View[range].hash(into: &hasher)
   }
+
+  @effects(releasenone) // FIXME: Is this valid in the opaque case?
+  @usableFromInline
+  internal func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    if _isSmall {
+      return _smallUTF8String._rawHashValue(seed: seed)
+    }
+
+    defer { _fixLifetime(self) }
+    if _slowPath(_isOpaque) {
+      return _asOpaque()._rawHashValue(seed: seed)
+    }
+    if isASCII {
+      return _unmanagedASCIIView._rawHashValue(seed: seed)
+    }
+    return _unmanagedUTF16View._rawHashValue(seed: seed)
+  }
+
+  @effects(releasenone) // FIXME: Is this valid in the opaque case?
+  @usableFromInline
+  internal func _rawHashValue(
+    _ range: Range<Int>,
+    seed: (UInt64, UInt64)
+  ) -> Int {
+    if _isSmall {
+      return _smallUTF8String[range]._rawHashValue(seed: seed)
+    }
+
+    defer { _fixLifetime(self) }
+    if _slowPath(_isOpaque) {
+      return _asOpaque()[range]._rawHashValue(seed: seed)
+    }
+    if isASCII {
+      return _unmanagedASCIIView[range]._rawHashValue(seed: seed)
+    }
+    return _unmanagedUTF16View[range]._rawHashValue(seed: seed)
+  }
 }
 
 extension String : Hashable {
   @inlinable
   public func hash(into hasher: inout Hasher) {
     _guts.hash(into: &hasher)
   }
+
+  @inlinable
+  public func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    return _guts._rawHashValue(seed: seed)
+  }
 }
 
 extension StringProtocol {
   @inlinable
   public func hash(into hasher: inout Hasher) {
     _wholeString._guts.hash(_encodedOffsetRange, into: &hasher)
   }
+
+  @inlinable
+  public func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    return _wholeString._guts._rawHashValue(_encodedOffsetRange, seed: seed)
+  }
 }

stdlib/public/core/UnsafePointer.swift.gyb

@@ -899,7 +899,12 @@ extension ${Self}: Comparable {
 extension ${Self}: Hashable {
   @inlinable // FIXME(sil-serialize-all)
   public func hash(into hasher: inout Hasher) {
-    hasher.combine(Int(bitPattern: self))
+    hasher.combine(UInt(bitPattern: self))
+  }
+
+  @inlinable // FIXME(sil-serialize-all)
+  public func _rawHashValue(seed: (UInt64, UInt64)) -> Int {
+    return Hasher._hash(seed: seed, UInt(bitPattern: self))
   }
 }