Fix hash/isEqual interop conditionals, update tests

Github PR swiftlang#71620 mixed up one of the bincompat conditionals.
It also had some errors in the tests for ObjC interop.

For now, this leaves the legacy behavior in place for
all Apple platforms.

Author: tbkka

stdlib/public/runtime/SwiftValue.mm

@@ -464,7 +464,7 @@ - (NSUInteger)hash {
 	    selfHeader->type, hashableConformance);
   }
 
-  if (!runtime::bincompat::useLegacySwiftObjCHashing()) {
+  if (runtime::bincompat::useLegacySwiftObjCHashing()) {
     // Legacy behavior doesn't honor Equatable conformance, only Hashable
     return (NSUInteger)self;
   }

test/stdlib/BridgeEquatableToObjC.swift

@@ -32,7 +32,12 @@ BridgeEquatableToObjC.test("Bridge equatable struct") {
   let objcResult = objcA.isEqual(objcB)
 
   expectEqual(swiftResult, true)
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+  // Apple platforms use old semantics for now...
+  expectEqual(objcResult, false)
+#else
   expectEqual(objcResult, true)
+#endif
 }
 
 BridgeEquatableToObjC.test("Bridge non-equatable struct") {

test/stdlib/SwiftObjectNSObject.swift

@@ -91,7 +91,12 @@ func TestSwiftObjectNSObjectAssertNoErrors()
 // Verify that Obj-C isEqual: provides same answer as Swift ==
 func TestEquatableEquals<T: Equatable & AnyObject>(_ e1: T, _ e2: T) {
   if e1 == e2 {
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+    // Legacy behavior: Equatable Swift does not imply == in ObjC
+    TestSwiftObjectNSObjectNotEquals(e1, e2)
+#else
     TestSwiftObjectNSObjectEquals(e1, e2)
+#endif
   } else {
     TestSwiftObjectNSObjectNotEquals(e1, e2)
   }
@@ -104,14 +109,27 @@ func TestNonEquatableEquals(_ e1: AnyObject, _ e2: AnyObject) {
 // Verify that Obj-C hashValue matches Swift hashValue for Hashable types
 func TestHashable(_ h: H)
 {
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+  // Legacy behavior: Hash value is identity in ObjC
+  TestSwiftObjectNSObjectDefaultHashValue(h)
+#else
+  // New behavior: Hashable in Swift, same hash value in ObjC
   TestSwiftObjectNSObjectHashValue(h, h.hashValue)
+#endif
 }
 
 // Test Obj-C hashValue for Swift types that are Equatable but not Hashable
 func TestEquatableHash(_ e: AnyObject)
 {
-  // These should have a constant hash value
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+  // Legacy behavior: Equatable in Swift => ObjC hashes with identity
+  TestSwiftObjectNSObjectDefaultHashValue(e)
+  let msg = "Obj-C `-hash` ... type `SwiftObjectNSObject.\(type(of: e))` ... Equatable but not Hashable\n"
+  fputs(msg, stderr)
+#else
+  // New behavior: These should have a constant hash value
   TestSwiftObjectNSObjectHashValue(e, 1)
+#endif
 }
 
 func TestNonEquatableHash(_ e: AnyObject)

test/stdlib/SwiftValueNSObject.swift

@@ -77,9 +77,25 @@ func TestSwiftValueNSObjectDefaultHashValue(_: AnyObject)
 func TestSwiftValueNSObjectAssertNoErrors()
 
 // Verify that Obj-C isEqual: provides same answer as Swift ==
+// This has been true for a long time for Hashable value types
+func TestHashableEquals<T: Equatable>(_ e1: T, _ e2: T) {
+  if e1 == e2 {
+    TestSwiftValueNSObjectEquals(e1 as AnyObject, e2 as AnyObject)
+  } else {
+    TestSwiftValueNSObjectNotEquals(e1 as AnyObject, e2 as AnyObject)
+  }
+}
+
+// Verify that Obj-C isEqual: provides same answer as Swift ==
+// This has not always been true for Equatable value types
 func TestEquatableEquals<T: Equatable>(_ e1: T, _ e2: T) {
   if e1 == e2 {
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+    // Legacy: Swift Equatable is not used in ObjC
+    TestSwiftValueNSObjectNotEquals(e1 as AnyObject, e2 as AnyObject)
+#else
     TestSwiftValueNSObjectEquals(e1 as AnyObject, e2 as AnyObject)
+#endif
   } else {
     TestSwiftValueNSObjectNotEquals(e1 as AnyObject, e2 as AnyObject)
   }
@@ -143,9 +159,9 @@ if #available(OSX 10.12, iOS 10.0, *) {
   TestNonEquatableHash(D())
 
   // Hashable types are also Equatable
-  TestEquatableEquals(H(i:1), H(i:1))
-  TestEquatableEquals(H(i:1), H(i:2))
-  TestEquatableEquals(H(i:2), H(i:1))
+  TestHashableEquals(H(i:1), H(i:1))
+  TestHashableEquals(H(i:1), H(i:2))
+  TestHashableEquals(H(i:2), H(i:1))
 
   // Verify Obj-C hash value agrees with Swift
   TestHashable(H(i:1))