[stdlib] Use _Hasher in conditional Hashable implementations

Implement _hash(into:) rather than hashValue.

Author: lorentey

stdlib/public/core/Arrays.swift.gyb

@@ -2297,15 +2297,17 @@ extension ${Self} : Equatable where Element : Equatable {
   }
 }
 
-extension ${Self} : Hashable where Element : Hashable {
+extension ${Self}: Hashable where Element: Hashable {
   @_inlineable // FIXME(sil-serialize-all)
   public var hashValue: Int {
-    // FIXME(ABI)#177: <rdar://problem/18915294> Issue applies to Array too
-    var result = 0
+    return _hashValue(for: self)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _hash(into hasher: inout _Hasher) {
     for element in self {
-      result = _combineHashValues(result, element.hashValue)
+      hasher.append(element)
     }
-    return result
   }
 }
 

stdlib/public/core/ClosedRange.swift

@@ -167,14 +167,20 @@ extension ClosedRange.Index : Comparable {
 }
 
 extension ClosedRange.Index: Hashable
-  where Bound: Strideable, Bound.Stride: SignedInteger, Bound: Hashable {
+where Bound: Strideable, Bound.Stride: SignedInteger, Bound: Hashable {
   @_inlineable // FIXME(sil-serialize-all)
   public var hashValue: Int {
+    return _hashValue(for: self)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _hash(into hasher: inout _Hasher) {
     switch self {
     case .inRange(let value):
-      return value.hashValue
+      hasher.append(0 as Int8)
+      hasher.append(value)
     case .pastEnd:
-      return .max
+      hasher.append(1 as Int8)
     }
   }
 }
@@ -382,13 +388,16 @@ extension ClosedRange: Equatable {
   }
 }
 
-extension ClosedRange : Hashable where Bound : Hashable {
+extension ClosedRange: Hashable where Bound: Hashable {
   @_inlineable // FIXME(sil-serialize-all)
   public var hashValue: Int {
-    var result = 0
-    result = _combineHashValues(result, lowerBound.hashValue)
-    result = _combineHashValues(result, upperBound.hashValue)
-    return result
+    return _hashValue(for: self)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _hash(into hasher: inout _Hasher) {
+    hasher.append(lowerBound)
+    hasher.append(upperBound)
   }
 }
 

stdlib/public/core/Dictionary.swift

@@ -1449,13 +1449,19 @@ extension Dictionary: Equatable where Value: Equatable {
 extension Dictionary: Hashable where Value: Hashable {
   @_inlineable // FIXME(sil-serialize-all)
   public var hashValue: Int {
-    // FIXME(ABI)#177: <rdar://problem/18915294> Cache Dictionary<T> hashValue
-    var result = 0
+    return _hashValue(for: self)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _hash(into hasher: inout _Hasher) {
+    var commutativeHash = 0
     for (k, v) in self {
-      let combined = _combineHashValues(k.hashValue, v.hashValue)
-      result ^= _mixInt(combined)
+      var elementHasher = _Hasher()
+      elementHasher.append(k)
+      elementHasher.append(v)
+      commutativeHash ^= elementHasher.finalize()
     }
-    return result
+    hasher.append(commutativeHash)
   }
 }
 

stdlib/public/core/Flatten.swift

@@ -237,11 +237,10 @@ extension FlattenCollection.Index : Hashable
     return _hashValue(for: self)
   }
 
+  @_inlineable // FIXME(sil-serialize-all)
   public func _hash(into hasher: inout _Hasher) {
     hasher.append(_outer)
-    if let inner = _inner {
-      hasher.append(inner)
-    }
+    hasher.append(_inner)
   }
 }
 

stdlib/public/core/Optional.swift

@@ -409,7 +409,7 @@ extension Optional : Equatable where Wrapped : Equatable {
   }
 }
 
-extension Optional : Hashable where Wrapped : Hashable {
+extension Optional: Hashable where Wrapped: Hashable {
   /// The hash value for the optional instance.
   ///
   /// Two optionals that are equal will always have equal hash values.
@@ -418,15 +418,18 @@ extension Optional : Hashable where Wrapped : Hashable {
   /// your program. Do not save hash values to use during a future execution.
   @_inlineable // FIXME(sil-serialize-all)
   public var hashValue: Int {
-    var result: Int
+    return _hashValue(for: self)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _hash(into hasher: inout _Hasher) {
     switch self {
     case .none:
-      result = 0
+      hasher.append(0 as UInt8)
     case .some(let wrapped):
-      result = 1
-      result = _combineHashValues(result, wrapped.hashValue)
+      hasher.append(1 as UInt8)
+      hasher.append(wrapped)
     }
-    return result
   }
 }
 

stdlib/public/core/Range.swift

@@ -398,13 +398,16 @@ extension Range: Equatable {
   }
 }
 
-extension Range : Hashable where Bound : Hashable {
+extension Range: Hashable where Bound: Hashable {
   @_inlineable // FIXME(sil-serialize-all)
   public var hashValue: Int {
-    var result = 0
-    result = _combineHashValues(result, lowerBound.hashValue)
-    result = _combineHashValues(result, upperBound.hashValue)
-    return result
+    return _hashValue(for: self)
+  }
+
+  @_inlineable // FIXME(sil-serialize-all)
+  public func _hash(into hasher: inout _Hasher) {
+    hasher.append(lowerBound)
+    hasher.append(upperBound)
   }
 }
 

stdlib/public/core/Reverse.swift

@@ -199,6 +199,7 @@ extension ReversedCollection.Index: Hashable where Base.Index: Hashable {
     return base.hashValue
   }
 
+  @_inlineable // FIXME(sil-serialize-all)
   public func _hash(into hasher: inout _Hasher) {
     hasher.append(base)
   }