Handle ObjC -hash differently for Equatable and non-Equatable types

For an Equatable type, we need a hash implementation that
is compatible with any possible definition of `==`.
Conservatively, that means `-hash` must return a constant.

For non-Equatable types, we know that `==` is identity based,
so we can get better hash behavior by using the object address.

Caveat:  This means that non-Equatable types will do two
protocol conformance checks on every call to `hash`.

Author: tbkka

stdlib/public/runtime/SwiftObject.mm

@@ -375,20 +375,32 @@ + (BOOL)conformsToProtocol:(Protocol*)proto {
 
 - (NSUInteger)hash {
   auto selfMetadata = _swift_getClassOfAllocated(self);
+
+  // If it's Hashable, use that
   auto hashableConformance =
     reinterpret_cast<const hashable_support::HashableWitnessTable *>(
       swift_conformsToProtocolCommon(
 	selfMetadata, &hashable_support::HashableProtocolDescriptor));
-  if (hashableConformance == NULL) {
-    // If a type is Equatable (but not Hashable), we
-    // have to return something here that is compatible
-    // with the `isEqual:` below.  NSObject's default
-    // of `(NSUInteger)self` won't work, so we instead
-    // return a constant fallback value:
+  if (hashableConformance != NULL) {
+    return _swift_stdlib_Hashable_hashValue_indirect(
+      &self, selfMetadata, hashableConformance);
+  }
+
+  // If a type is Equatable (but not Hashable), we
+  // have to return something here that is compatible
+  // with the `isEqual:` below.  NSObject's default
+  // of `(NSUInteger)self` won't work, so we instead
+  // return a constant fallback value:
+  auto equatableConformance =
+    reinterpret_cast<const equatable_support::EquatableWitnessTable *>(
+      swift_conformsToProtocolCommon(
+	selfMetadata, &equatable_support::EquatableProtocolDescriptor));
+  if (equatableConformance != nullptr) {
     return (NSUInteger)1;
   }
-  return _swift_stdlib_Hashable_hashValue_indirect(
-    &self, selfMetadata, hashableConformance);
+
+  // Legacy default for types that are neither Hashable nor Equatable.
+  return (NSUInteger)self;
 }
 
 - (BOOL)isEqual:(id)other {

test/stdlib/Inputs/SwiftObjectNSObject/SwiftObjectNSObject.m

@@ -116,6 +116,12 @@ void TestSwiftObjectNSObjectHashValue(id e, NSUInteger hashValue)
   expectTrue([e hash] == hashValue);
 }
 
+void TestSwiftObjectNSObjectDefaultHashValue(id e)
+{
+  NSUInteger hashValue = (NSUInteger)e;
+  TestSwiftObjectNSObjectHashValue(e, hashValue);
+}
+
 void TestSwiftObjectNSObject(id c, id d)
 {
   printf("TestSwiftObjectNSObject\n");

test/stdlib/SwiftObjectNSObject.swift

@@ -79,6 +79,8 @@ func TestSwiftObjectNSObjectEquals(_: AnyObject, _: AnyObject)
 func TestSwiftObjectNSObjectNotEquals(_: AnyObject, _: AnyObject)
 @_silgen_name("TestSwiftObjectNSObjectHashValue")
 func TestSwiftObjectNSObjectHashValue(_: AnyObject, _: Int)
+@_silgen_name("TestSwiftObjectNSObjectDefaultHashValue")
+func TestSwiftObjectNSObjectDefaultHashValue(_: AnyObject)
 @_silgen_name("TestSwiftObjectNSObjectAssertNoErrors")
 func TestSwiftObjectNSObjectAssertNoErrors()
 
@@ -101,14 +103,18 @@ func TestHashable(_ h: H)
   TestSwiftObjectNSObjectHashValue(h, h.hashValue)
 }
 
-// Test Obj-C hashValue for Swift types that are not Hashable
-func TestNonHashableHash(_ e: AnyObject)
+// Test Obj-C hashValue for Swift types that are Equatable but not Hashable
+func TestEquatableHash(_ e: AnyObject)
 {
-  // Non-Hashable type should always have the
-  // same hash value in Obj-C
+  // These should have a constant hash value
   TestSwiftObjectNSObjectHashValue(e, 1)
 }
 
+func TestNonEquatableHash(_ e: AnyObject)
+{
+  TestSwiftObjectNSObjectDefaultHashValue(e)
+}
+
 // This check is for NSLog() output from TestSwiftObjectNSObject().
 // CHECK: c ##SwiftObjectNSObject.C##
 // CHECK-NEXT: d ##SwiftObjectNSObject.D##
@@ -154,12 +160,14 @@ if #available(OSX 10.12, iOS 10.0, *) {
   TestNonEquatableEquals(F1(i: 1), E(i: 1))
   TestEquatableEquals(H(i:1), E(i:1))
 
-  // Non-Hashable: alway have the same Obj-C hashValue
-  TestNonHashableHash(E(i: 1))
-  TestNonHashableHash(E1(i: 3))
-  TestNonHashableHash(E2(i: 8))
-  TestNonHashableHash(C())
-  TestNonHashableHash(D())
+  // Equatable but not Hashable: alway have the same Obj-C hashValue
+  TestEquatableHash(E(i: 1))
+  TestEquatableHash(E1(i: 3))
+  TestEquatableHash(E2(i: 8))
+
+  // Neither Equatable nor Hashable
+  TestNonEquatableHash(C())
+  TestNonEquatableHash(D())
 
   // Hashable types are also Equatable
   TestEquatableEquals(H(i:1), H(i:1))