Modernize hashing in Foundation's Swift-only types

CMakeLists.txt

@@ -390,6 +390,7 @@ if(ENABLE_TESTING)
                          TestFoundation/TestCodable.swift
                          TestFoundation/TestDateComponents.swift
                          TestFoundation/TestDateFormatter.swift
+                         TestFoundation/TestDateInterval.swift
                          TestFoundation/TestDateIntervalFormatter.swift
                          TestFoundation/TestDate.swift
                          TestFoundation/TestDecimal.swift
@@ -407,6 +408,7 @@ if(ENABLE_TESTING)
                          TestFoundation/TestJSONSerialization.swift
                          TestFoundation/TestLengthFormatter.swift
                          TestFoundation/TestMassFormatter.swift
+                         TestFoundation/TestMeasurement.swift
                          TestFoundation/TestNotificationCenter.swift
                          TestFoundation/TestNotificationQueue.swift
                          TestFoundation/TestNotification.swift

Foundation.xcodeproj/project.pbxproj

@@ -354,6 +354,8 @@
 		7900433C1CACD33E00ECCBF1 /* TestNSPredicate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7900433A1CACD33E00ECCBF1 /* TestNSPredicate.swift */; };
 		7D0DE86E211883F500540061 /* TestDateComponents.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7D0DE86C211883F500540061 /* TestDateComponents.swift */; };
 		7D0DE86F211883F500540061 /* Utilities.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7D0DE86D211883F500540061 /* Utilities.swift */; };
+		7D8BD739225ED1480057CF37 /* TestMeasurement.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7D8BD738225ED1480057CF37 /* TestMeasurement.swift */; };
+		7D8BD737225EADB80057CF37 /* TestDateInterval.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7D8BD736225EADB80057CF37 /* TestDateInterval.swift */; };
 		90E645DF1E4C89A400D0D47C /* TestNSCache.swift in Sources */ = {isa = PBXBuildFile; fileRef = 90E645DE1E4C89A400D0D47C /* TestNSCache.swift */; };
 		91B668A32252B3C5001487A1 /* FileManager+POSIX.swift in Sources */ = {isa = PBXBuildFile; fileRef = 91B668A22252B3C5001487A1 /* FileManager+POSIX.swift */; };
 		91B668A52252B3E7001487A1 /* FileManager+Win32.swift in Sources */ = {isa = PBXBuildFile; fileRef = 91B668A42252B3E7001487A1 /* FileManager+Win32.swift */; };
@@ -881,6 +883,8 @@
 		7A7D6FBA1C16439400957E2E /* TestURLResponse.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestURLResponse.swift; sourceTree = "<group>"; };
 		7D0DE86C211883F500540061 /* TestDateComponents.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestDateComponents.swift; sourceTree = "<group>"; };
 		7D0DE86D211883F500540061 /* Utilities.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Utilities.swift; sourceTree = "<group>"; };
+		7D8BD738225ED1480057CF37 /* TestMeasurement.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TestMeasurement.swift; sourceTree = "<group>"; };
+		7D8BD736225EADB80057CF37 /* TestDateInterval.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TestDateInterval.swift; sourceTree = "<group>"; };
 		83712C8D1C1684900049AD49 /* TestNSURLRequest.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestNSURLRequest.swift; sourceTree = "<group>"; };
 		844DC3321C17584F005611F9 /* TestScanner.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestScanner.swift; sourceTree = "<group>"; };
 		848A30571C137B3500C83206 /* TestHTTPCookie.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = TestHTTPCookie.swift; path = TestFoundation/TestHTTPCookie.swift; sourceTree = SOURCE_ROOT; };
@@ -1586,6 +1590,7 @@
 				7D0DE86D211883F500540061 /* Utilities.swift */,
 				155D3BBB22401D1100B0D38E /* FixtureValues.swift */,
 				7D0DE86C211883F500540061 /* TestDateComponents.swift */,
+				7D8BD736225EADB80057CF37 /* TestDateInterval.swift */,
 				6E203B8C1C1303BB003B2576 /* TestBundle.swift */,
 				A5A34B551C18C85D00FD972B /* TestByteCountFormatter.swift */,
 				2EBE67A31C77BF05006583D5 /* TestDateFormatter.swift */,
@@ -1668,6 +1673,7 @@
 				5B6F17961C48631C00935030 /* TestUtils.swift */,
 				03B6F5831F15F339004F25AF /* TestURLProtocol.swift */,
 				3E55A2321F52463B00082000 /* TestUnit.swift */,
+				7D8BD738225ED1480057CF37 /* TestMeasurement.swift */,
 			);
 			name = Tests;
 			sourceTree = "<group>";
@@ -2661,6 +2667,7 @@
 				2EBE67A51C77BF0E006583D5 /* TestDateFormatter.swift in Sources */,
 				5B13B3291C582D4C00651CE2 /* TestCalendar.swift in Sources */,
 				158BCCAA2220A12600750239 /* TestDateIntervalFormatter.swift in Sources */,
+				7D8BD737225EADB80057CF37 /* TestDateInterval.swift in Sources */,
 				5B13B34F1C582D4C00651CE2 /* TestXMLParser.swift in Sources */,
 				BF85E9D81FBDCC2000A79793 /* TestHost.swift in Sources */,
 				D5C40F331CDA1D460005690C /* TestOperationQueue.swift in Sources */,
@@ -2678,6 +2685,7 @@
 				5B13B3511C582D4C00651CE2 /* TestByteCountFormatter.swift in Sources */,
 				BDFDF0A71DFF5B3E00C04CC5 /* TestPersonNameComponents.swift in Sources */,
 				5B13B3501C582D4C00651CE2 /* TestUtils.swift in Sources */,
+				7D8BD739225ED1480057CF37 /* TestMeasurement.swift in Sources */,
 				CD1C7F7D1E303B47008E331C /* TestNSError.swift in Sources */,
 				294E3C1D1CC5E19300E4F44C /* TestNSAttributedString.swift in Sources */,
 				5B13B3431C582D4C00651CE2 /* TestScanner.swift in Sources */,

Foundation/AffineTransform.swift

@@ -253,9 +253,13 @@ public struct AffineTransform : ReferenceConvertible, Hashable, CustomStringConv
         return newSize
     }
 
-    /// The computed hash value for the transform.
-    public var hashValue : Int {
-        return Int((m11 + m12 + m21 + m22 + tX + tY).native)
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(m11)
+        hasher.combine(m12)
+        hasher.combine(m21)
+        hasher.combine(m22)
+        hasher.combine(tX)
+        hasher.combine(tY)
     }
 
     /// A textual description of the transform.

Foundation/Boxing.swift

@@ -75,7 +75,9 @@ internal protocol _SwiftNativeFoundationType : class {
 
     func mutableCopy(with zone : NSZone) -> Any
 
+    func hash(into hasher: inout Hasher)
     var hashValue: Int { get }
+
     var description: String { get }
     var debugDescription: String { get }
 
@@ -115,6 +117,10 @@ extension _SwiftNativeFoundationType {
         return _mapUnmanaged { ($0 as NSObject).mutableCopy() }
     }
 
+    func hash(into hasher: inout Hasher) {
+        _mapUnmanaged { hasher.combine($0) }
+    }
+
     var hashValue: Int {
         return _mapUnmanaged { return $0.hashValue }
     }

Foundation/CGFloat.swift

@@ -477,6 +477,16 @@ extension CGFloat : Hashable {
     public var hashValue: Int {
         return native.hashValue
     }
+
+    @_transparent
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(native)
+    }
+
+    @_transparent
+    public func _rawHashValue(seed: Int) -> Int {
+        return native._rawHashValue(seed: seed)
+    }
 }
 
 extension UInt8 {

Foundation/Calendar.swift

@@ -862,8 +862,9 @@ public struct Calendar : Hashable, Equatable, ReferenceConvertible, _MutableBoxi
     public func hash(into hasher: inout Hasher) {
         // We implement hash ourselves, because we need to make sure autoupdating calendars have the same hash
         if _autoupdating {
-            hasher.combine(1 as Int8)
+            hasher.combine(false)
         } else {
+            hasher.combine(true)
             hasher.combine(_handle.map { $0 })
         }
     }

Foundation/Date.swift

@@ -136,9 +136,9 @@ public struct Date : ReferenceConvertible, Comparable, Equatable {
      The distant past is in terms of centuries.
      */
     public static let distantPast = Date(timeIntervalSinceReferenceDate: -63114076800.0)
-    
-    public var hashValue: Int {
-        return Int(bitPattern: __CFHashDouble(_time))
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(_time)
     }
 
     /// Compare two `Date` values.

Foundation/DateInterval.swift

@@ -150,14 +150,9 @@ public struct DateInterval : ReferenceConvertible, Comparable, Hashable {
         return false
     }
 
-    public var hashValue: Int {
-        var buf: (UInt, UInt) = (UInt(start.timeIntervalSinceReferenceDate), UInt(end.timeIntervalSinceReferenceDate))
-        return withUnsafeMutablePointer(to: &buf) { bufferPtr in
-            let count = MemoryLayout<UInt>.size * 2
-            return bufferPtr.withMemoryRebound(to: UInt8.self, capacity: count) { bufferBytes in
-                return Int(bitPattern: CFHashBytes(bufferBytes, CFIndex(count)))
-            }
-        }
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(start)
+        hasher.combine(duration)
     }
 
     public static func ==(lhs: DateInterval, rhs: DateInterval) -> Bool {

Foundation/Decimal.swift

@@ -286,8 +286,12 @@ extension Decimal : Hashable, Comparable {
         return Int64(bitPattern: uint64Value)
     }
 
-    public var hashValue: Int {
-        return Int(bitPattern: __CFHashDouble(doubleValue))
+    public func hash(into hasher: inout Hasher) {
+        // FIXME: This is a weak hash.  We should rather normalize self to a
+        // canonical member of the exact same equivalence relation that
+        // NSDecimalCompare implements, then simply feed all components to the
+        // hasher.
+        hasher.combine(doubleValue)
     }
 
     public static func ==(lhs: Decimal, rhs: Decimal) -> Bool {

Foundation/FileManager.swift

@@ -828,11 +828,11 @@ public struct FileAttributeKey : RawRepresentable, Equatable, Hashable {
     public init(rawValue: String) {
         self.rawValue = rawValue
     }
-    
-    public var hashValue: Int {
-        return self.rawValue.hashValue
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(rawValue)
     }
-    
+
     public static func ==(_ lhs: FileAttributeKey, _ rhs: FileAttributeKey) -> Bool {
         return lhs.rawValue == rhs.rawValue
     }
@@ -873,8 +873,8 @@ public struct FileAttributeType : RawRepresentable, Equatable, Hashable {
         self.rawValue = rawValue
     }
 
-    public var hashValue: Int {
-        return self.rawValue.hashValue
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(rawValue)
     }
 
     public static func ==(_ lhs: FileAttributeType, _ rhs: FileAttributeType) -> Bool {

Foundation/HTTPCookie.swift

@@ -18,8 +18,8 @@ public struct HTTPCookiePropertyKey : RawRepresentable, Equatable, Hashable {
         self.rawValue = rawValue
     }
 
-    public var hashValue: Int {
-        return self.rawValue.hashValue
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(rawValue)
     }
 
     public static func ==(_ lhs: HTTPCookiePropertyKey, _ rhs: HTTPCookiePropertyKey) -> Bool {

Foundation/IndexPath.swift

@@ -675,23 +675,29 @@ public struct IndexPath : ReferenceConvertible, Equatable, Hashable, MutableColl
         }
         return .orderedSame
     }
-
-    public var hashValue: Int {
-        func hashIndexes(first: Int, last: Int, count: Int) -> Int {
-            let totalBits = MemoryLayout<Int>.size * 8
-            let lengthBits = 8
-            let firstIndexBits = (totalBits - lengthBits) / 2
-            return count &+ (first << lengthBits) &+ (last << (lengthBits + firstIndexBits))
-        }
-
+
+    public func hash(into hasher: inout Hasher) {
+        // Note: We compare all indices in ==, so for proper hashing, we must
+        // also feed them all to the hasher.
+        //
+        // To ensure we have unique hash encodings in nested hashing contexts,
+        // we combine the count of indices as well as the indices themselves.
+        // (This matches what Array does.)
         switch _indexes {
-            case .empty: return 0
-            case .single(let index): return index.hashValue
-            case .pair(let first, let second):
-                return hashIndexes(first: first, last: second, count: 2)
-            default:
-                let cnt = _indexes.count
-                return hashIndexes(first: _indexes[0], last: _indexes[cnt - 1], count: cnt)
+        case .empty:
+            hasher.combine(0)
+        case let .single(index):
+            hasher.combine(1)
+            hasher.combine(index)
+        case let .pair(first, second):
+            hasher.combine(2)
+            hasher.combine(first)
+            hasher.combine(second)
+        case let .array(indexes):
+            hasher.combine(indexes.count)
+            for index in indexes {
+                hasher.combine(index)
+            }
         }
     }
 

Foundation/Locale.swift

@@ -423,8 +423,9 @@ public struct Locale : CustomStringConvertible, CustomDebugStringConvertible, Ha
 
     public func hash(into hasher: inout Hasher) {
         if _autoupdating {
-            hasher.combine(1 as Int8)
+            hasher.combine(false)
         } else {
+            hasher.combine(true)
             hasher.combine(_wrapped)
         }
     }

Foundation/Measurement.swift

@@ -36,8 +36,19 @@ public struct Measurement<UnitType : Unit> : ReferenceConvertible, Comparable, E
         self.unit = unit
     }
 
-    public var hashValue: Int {
-        return Int(bitPattern: __CFHashDouble(value))
+    public func hash(into hasher: inout Hasher) {
+        // Warning: The canonicalization performed here needs to be kept in
+        // perfect sync with the definition of == below. The floating point
+        // values that are compared there must match exactly with the values fed
+        // to the hasher here, or hashing would break.
+        if let dimension = unit as? Dimension {
+            // We don't need to feed the base unit to the hasher here; all
+            // dimensional measurements of the same type share the same unit.
+            hasher.combine(dimension.converter.baseUnitValue(fromValue: value))
+        } else {
+            hasher.combine(unit)
+            hasher.combine(value)
+        }
     }
 }
 
@@ -170,6 +181,10 @@ extension Measurement {
     /// If `lhs.unit == rhs.unit`, returns `lhs.value == rhs.value`. Otherwise, converts `rhs` to the same unit as `lhs` and then compares the resulting values.
     /// - returns: `true` if the measurements are equal.
     public static func ==<LeftHandSideType, RightHandSideType>(_ lhs: Measurement<LeftHandSideType>, _ rhs: Measurement<RightHandSideType>) -> Bool {
+        // Warning: This defines an equivalence relation that needs to be kept
+        // in perfect sync with the hash(into:) definition above. The floating
+        // point values that are fed to the hasher there must match exactly with
+        // the values compared here, or hashing would break.
         if lhs.unit == rhs.unit {
             return lhs.value == rhs.value
         } else {

Foundation/NSAttributedString.swift

@@ -21,8 +21,12 @@ extension NSAttributedString {
             self.rawValue = rawValue
         }
 
-        public var hashValue: Int {
-            return rawValue.hashValue
+        public func hash(into hasher: inout Hasher) {
+            hasher.combine(rawValue)
+        }
+
+        public static func ==(left: NSAttributedString.Key, right: NSAttributedString.Key) -> Bool {
+            return left.rawValue == right.rawValue
         }
     }
 }

Foundation/NSCalendar.swift

@@ -65,9 +65,9 @@ extension NSCalendar {
         public init(rawValue: String) {
             self.rawValue = rawValue
         }
-        
-        public var hashValue: Int {
-            return rawValue.hashValue
+
+        public func hash(into hasher: inout Hasher) {
+            hasher.combine(rawValue)
         }
 
         public static let gregorian = NSCalendar.Identifier("gregorian")

Foundation/NSCharacterSet.swift

@@ -46,7 +46,7 @@ open class NSCharacterSet : NSObject, NSCopying, NSMutableCopying, NSCoding {
     }
 
     open override var hash: Int {
-        return Int(bitPattern: CFHash(_cfObject))
+        return Int(bitPattern: _CFNonObjCHash(_cfObject))
     }
 
     open override func isEqual(_ value: Any?) -> Bool {

Foundation/NSDecimalNumber.swift

@@ -18,9 +18,9 @@ public struct NSExceptionName : RawRepresentable, Equatable, Hashable {
     public init(rawValue: String) {
         self.rawValue = rawValue
     }
-    
-    public var hashValue: Int {
-        return self.rawValue.hashValue
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(rawValue)
     }
 
     public static func ==(_ lhs: NSExceptionName, _ rhs: NSExceptionName) -> Bool {

Foundation/NSError.swift

@@ -455,6 +455,10 @@ extension __BridgedNSError where Self: RawRepresentable, Self.RawValue: FixedWid
     }
 
     public var hashValue: Int { return _code }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(rawValue)
+    }
 }
 
 /// Describes a raw representable type that is bridged to a particular
@@ -533,7 +537,11 @@ public extension _BridgedStoredNSError {
 /// Implementation of Hashable for all _BridgedStoredNSErrors.
 public extension _BridgedStoredNSError {
     var hashValue: Int {
-        return _nsError.hashValue
+        return _nsError.hash
+    }
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(_nsError)
     }
 }