[5.0][Sema] Emit a deprecation warning if a Hashable type only implements hashValue (#21445)

* [Sema] Emit a deprecation warning when hashValue is provided by hash(into:) isn’t

SE-206 deprecated hashValue as a protocol requirement. We should gently encourage people to migrate to hash(into:), for its more secure, easier and faster hashing.

Emit a compiler warning whenever hashValue has an explicit implementation, but hash(into:) doesn’t.

(cherry picked from commit e0495a7)

* [stdlib] Document that `hashValue` is deprecated

(cherry picked from commit 1485404)

* [test] Test new deprecation warning for hashValue implementations

(cherry picked from commit cb3cff5)

* Doc fix

Co-Authored-By: lorentey <[email protected]>
(cherry picked from commit 646849e)

* [test] StdlibUnittest: Add missing hash(into:) implementations

(cherry picked from commit 8e77a26)

* [test] Modernize hashing throughout the test suite

(cherry picked from commit 666a22f)

Author: lorentey

include/swift/AST/DiagnosticsSema.def

@@ -4280,6 +4280,10 @@ WARNING(non_exhaustive_switch_warn,none, "switch must be exhaustive", ())
 WARNING(override_nsobject_hashvalue,none,
         "override of 'NSObject.hashValue' is deprecated; "
         "override 'NSObject.hash' to get consistent hashing behavior", ())
+WARNING(hashvalue_implementation,none,
+        "'Hashable.hashValue' is deprecated as a protocol requirement; "
+        "conform type %0 to 'Hashable' by implementing 'hash(into:)' instead",
+        (Type))
 
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)

lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -1175,7 +1175,7 @@ ValueDecl *DerivedConformance::deriveHashable(ValueDecl *requirement) {
       // The hashValue failure will produce a diagnostic elsewhere.
       return nullptr;
     }
-    if (hashValueDecl && hashValueDecl->isImplicit()) {
+    if (hashValueDecl->isImplicit()) {
       // Neither hashValue nor hash(into:) is explicitly defined; we need to do
       // a full Hashable derivation.
 
@@ -1209,8 +1209,11 @@ ValueDecl *DerivedConformance::deriveHashable(ValueDecl *requirement) {
         llvm_unreachable("Attempt to derive Hashable for a type other "
                          "than a struct or enum");      
     } else {
-      // We can always derive hash(into:) if hashValue has an explicit
-      // implementation.
+      // hashValue has an explicit implementation, but hash(into:) doesn't.
+      // Emit a deprecation warning, then derive hash(into:) in terms of
+      // hashValue.
+      TC.diagnose(hashValueDecl->getLoc(), diag::hashvalue_implementation,
+                  Nominal->getDeclaredType());
       return deriveHashable_hashInto(*this,
                                      &deriveBodyHashable_compat_hashInto);
     }

stdlib/private/StdlibCollectionUnittest/MinimalCollections.swift

@@ -305,8 +305,8 @@ public struct _CollectionState : Equatable, Hashable {
     }
   }
 
-  public var hashValue: Int {
-    return _id.hashValue
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(_id)
   }
 }
 

stdlib/private/StdlibUnicodeUnittest/Collation.swift

@@ -181,42 +181,11 @@ let ducetExtractData: [CollationTableEntry] = [
   CollationTableEntry([0xE01EF], [0x0000_0000_0000], "VARIATION SELECTOR-256"),
 ]
 
-public struct HashableArray<Element : Hashable> : Hashable {
-  internal var _elements: [Element]
-
-  public init(_ elements: [Element]) {
-    _elements = elements
-  }
-
-  public var hashValue: Int {
-    // FIXME: this is a bad approach to combining hash values.
-    var result = 0
-    for x in _elements {
-      result ^= x.hashValue
-      result = result &* 997
-    }
-    return result
-  }
-}
-
-public func == <Element>(
-  lhs: HashableArray<Element>,
-  rhs: HashableArray<Element>
-) -> Bool {
-  return lhs._elements.elementsEqual(rhs._elements)
-}
-
-extension HashableArray : ExpressibleByArrayLiteral {
-  public init(arrayLiteral elements: Element...) {
-    self._elements = elements
-  }
-}
-
-let ducetExtract: [HashableArray<Unicode.Scalar> : CollationTableEntry] = {
+let ducetExtract: [[Unicode.Scalar]: CollationTableEntry] = {
   () in
-  var result: [HashableArray<Unicode.Scalar> : CollationTableEntry] = [:]
+  var result: [[Unicode.Scalar]: CollationTableEntry] = [:]
   for entry in ducetExtractData {
-    result[HashableArray(entry.scalars)] = entry
+    result[entry.scalars] = entry
   }
   return result
 }()
@@ -232,7 +201,7 @@ extension String {
   internal var _collationElements: [UInt64] {
     var result: [UInt64] = []
     for us in self.unicodeScalars {
-      let scalars: HashableArray<Unicode.Scalar> = [us]
+      let scalars: [Unicode.Scalar] = [us]
       let collationElements = ducetExtract[scalars]!.collationElements
       if collationElements[0] != 0 {
         result += collationElements

stdlib/private/StdlibUnittest/LifetimeTracked.swift

@@ -51,6 +51,9 @@ extension LifetimeTracked : Hashable {
   public var hashValue: Int {
     return value
   }
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
+  }
 }
 
 extension LifetimeTracked : Strideable {

stdlib/private/StdlibUnittest/StdlibCoreExtras.swift

@@ -110,14 +110,20 @@ public func <=> <T: Comparable>(lhs: T, rhs: T) -> ExpectedComparisonResult {
 }
 
 public struct TypeIdentifier : Hashable, Comparable {
+  public var value: Any.Type
+
   public init(_ value: Any.Type) {
     self.value = value
   }
 
   public var hashValue: Int { return objectID.hashValue }
-  public var value: Any.Type
-  
-  internal var objectID : ObjectIdentifier { return ObjectIdentifier(value) }
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(objectID)
+  }
+
+  internal var objectID : ObjectIdentifier {
+    return ObjectIdentifier(value)
+  }
 }
 
 public func < (lhs: TypeIdentifier, rhs: TypeIdentifier) -> Bool {

stdlib/private/StdlibUnittest/StringConvertible.swift

@@ -65,6 +65,10 @@ public struct CustomPrintableValue
     return value.hashValue
   }
 
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
+  }
+
   public typealias Stride = Int
 
   public func distance(to other: CustomPrintableValue) -> Stride {

stdlib/public/core/Hashable.swift

@@ -106,6 +106,9 @@ public protocol Hashable : Equatable {
   ///
   /// Hash values are not guaranteed to be equal across different executions of
   /// your program. Do not save hash values to use during a future execution.
+  ///
+  /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
+  ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
   var hashValue: Int { get }
 
   /// Hashes the essential components of this value by feeding them into the

test/ClangImporter/objc_override.swift

@@ -110,7 +110,7 @@ class CallbackSubC : CallbackBase {
 
 //
 class MyHashableNSObject: NSObject {
-  override var hashValue: Int { // expected-warning{{override of 'NSObject.hashValue' is deprecated}}
+  override var hashValue: Int { // expected-error{{overriding non-open property outside of its defining module}} expected-error{{overriding non-@objc declarations from extensions is not supported}}
     return 0
   }
 }

test/Constraints/bridging-nsnumber-and-nsvalue.swift.gyb

@@ -38,7 +38,12 @@ extension Equatable {
     fatalError("hella cray")
   }
 }
-extension Hashable { public var hashValue: Int { fatalError("trill hiphy") } }
+extension Hashable {
+  public func hash(into hasher: inout Hasher) {
+    fatalError("trill hiphy")
+  }
+}
+
 extension CGSize: Hashable {}
 extension CGPoint: Hashable {}
 extension CGRect: Hashable {}