Bincompat hooks for revised hash/isEqual interop

This adds in hooks so that the new hash/isEqual interop
(which bridges Obj-C hash/isEqual: calls to the corresponding
Swift Hashable/Equatable conformances) can be selectively
disabled based on the OS and/or client.

For now, enable the new semantics everywhere except Apple platforms
(which have legacy apps that may be relying on the old semantics).

Author: tbkka

include/swift/Runtime/Bincompat.h

@@ -41,6 +41,12 @@ bool useLegacyObjCBoxingInCasting();
 /// Whether to use legacy semantics when unboxing __SwiftValue
 bool useLegacySwiftValueUnboxingInCasting();
 
+/// Legacy semantics use trivial implementations for -hashValue/-isEqual:
+/// requests from ObjC to Swift values.
+/// New semantics attempt to dispatch to Swift Hashable/Equatable conformances
+/// if present.
+bool useLegacySwiftObjCHashing();
+
 } // namespace bincompat
 
 } // namespace runtime

stdlib/public/runtime/Bincompat.cpp

@@ -228,6 +228,30 @@ bool useLegacySwiftValueUnboxingInCasting() {
 #endif
 }
 
+// Controls how ObjC -hashValue and -isEqual are handled
+// by Swift objects.
+// There are two basic semantics:
+// * pointer: -hashValue returns pointer, -isEqual: tests pointer equality
+// * proxy: -hashValue calls on Hashable conformance, -isEqual: calls Equatable conformance
+//
+// Legacy handling:
+// * Swift struct/enum values that implement Hashable: proxy -hashValue and -isEqual:
+// * Swift struct/enum values that implement Equatable but not Hashable: pointer semantics
+// * Swift class values regardless of hashable/Equatable support: pointer semantics
+//
+// New behavior:
+// * Swift struct/enum/class values that implement Hashable: proxy -hashValue and -isEqual:
+// * Swift struct/enum/class values that implement Equatable but not Hashable: proxy -isEqual:, constant -hashValue
+// * All other cases: pointer semantics
+//
+bool useLegacySwiftObjCHashing() {
+#if BINARY_COMPATIBILITY_APPLE
+  return true; // For now, legacy behavior on Apple OSes
+#else
+  return false; // Always use the new behavior on non-Apple OSes
+#endif
+}
+
 } // namespace bincompat
 
 } // namespace runtime

stdlib/public/runtime/SwiftObject.mm

@@ -376,6 +376,11 @@ + (BOOL)conformsToProtocol:(Protocol*)proto {
 }
 
 - (NSUInteger)hash {
+  if (runtime::bincompat::useLegacySwiftObjCHashing()) {
+    // Legacy behavior: Don't proxy to Swift Hashable
+    return (NSUInteger)self;
+  }
+
   auto selfMetadata = _swift_getClassOfAllocated(self);
 
   // If it's Hashable, use that
@@ -423,6 +428,11 @@ - (BOOL)isEqual:(id)other {
   if (self == other) {
     return YES;
   }
+  if (runtime::bincompat::useLegacySwiftObjCHashing()) {
+    // Legacy behavior: Don't proxy to Swift Hashable or Equatable
+    return NO; // We know the ids are different
+  }
+
 
   // Get Swift type for self and other
   auto selfMetadata = _swift_getClassOfAllocated(self);

stdlib/public/runtime/SwiftValue.mm

@@ -24,6 +24,7 @@
 #include "SwiftObject.h"
 #include "SwiftValue.h"
 #include "swift/Basic/Lazy.h"
+#include "swift/Runtime/Bincompat.h"
 #include "swift/Runtime/Casting.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Metadata.h"
@@ -429,6 +430,11 @@ - (BOOL)isEqual:(id)other {
     }
   }
 
+  if (runtime::bincompat::useLegacySwiftObjCHashing()) {
+    // Legacy behavior only proxies isEqual: for Hashable, not Equatable
+    return NO;
+  }
+
   if (auto equatableConformance = selfHeader->getEquatableConformance()) {
     if (auto selfEquatableBaseType = selfHeader->getEquatableBaseType()) {
       auto otherEquatableBaseType = otherHeader->getEquatableBaseType();
@@ -458,6 +464,11 @@ - (NSUInteger)hash {
 	    selfHeader->type, hashableConformance);
   }
 
+  if (!runtime::bincompat::useLegacySwiftObjCHashing()) {
+    // Legacy behavior doesn't honor Equatable conformance, only Hashable
+    return (NSUInteger)self;
+  }
+
   // If Swift type is Equatable but not Hashable,
   // we have to return something here that is compatible
   // with the `isEqual:` above.