Make ObjC isEqual: delegate to Equatable when Hashable isn't available

When a Swift struct gets bridged to Obj-C, we box it into an opaque
`_SwiftValue` Obj-C object.  This object previously supported the
Obj-C `isEqual:` and `hash` selectors by dispatching to the Swift
Hashable conformance, if present.

This does not work if the Swift struct conforms to Equatable but
does not conform to Hashable.  This case seems to have been
overlooked in PR #4124.

This PR extends the earlier work to support `isEqual:` by
first checking for a Hashable conformance, then falling back
on an Equatable conformance if there is no Hashable conformance.

Resolves rdar://114294889

Author: tbkka

stdlib/public/core/Equatable.swift

@@ -196,6 +196,16 @@ extension Equatable {
   }
 }
 
+// Called by the SwiftValue implementation.
+@_silgen_name("_swift_stdlib_Equatable_isEqual_indirect")
+internal func Equatable_isEqual_indirect<T: Equatable>(
+  _ lhs: UnsafePointer<T>,
+  _ rhs: UnsafePointer<T>
+) -> Bool {
+  return lhs.pointee == rhs.pointee
+}
+
+
 //===----------------------------------------------------------------------===//
 // Reference comparison
 //===----------------------------------------------------------------------===//

stdlib/public/runtime/SwiftValue.mm

@@ -57,6 +57,14 @@ - (id)copyWithZone:(NSZone *)zone;
 
 @end
 
+struct EquatableWitnessTable;
+
+/// Calls `Equatable.==` through an `Equatable` witness table
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
+bool _swift_stdlib_Equatable_isEqual_indirect(
+    const void *lhsValue, const void *rhsValue, const Metadata *type,
+    const EquatableWitnessTable *wt);
+
 /// The fixed-size ivars of `__SwiftValue`.  The actual boxed value is
 /// tail-allocated.
 struct SwiftValueHeader {
@@ -80,10 +88,18 @@ - (id)copyWithZone:(NSZone *)zone;
   /// Returns NULL if the type does not conform.
   const Metadata *getHashableBaseType() const;
 
+  /// Get the base type that conforms to `Equatable`.
+  /// Returns NULL if the type does not conform.
+  const Metadata *getEquatableBaseType() const;
+
   /// Get the `Hashable` protocol witness table for the contained type.
   /// Returns NULL if the type does not conform.
   const hashable_support::HashableWitnessTable *getHashableConformance() const;
 
+  /// Get the `Equatable` protocol witness table for the contained type.
+  /// Returns NULL if the type does not conform.
+  const EquatableWitnessTable *getEquatableConformance() const;
+
   SwiftValueHeader()
       : hashableBaseType(nullptr), hashableConformance(nullptr) {}
 };
@@ -105,6 +121,27 @@ - (id)copyWithZone:(NSZone *)zone;
   return type;
 }
 
+extern "C" const ProtocolDescriptor PROTOCOL_DESCR_SYM(SQ);
+static constexpr auto &EquatableProtocolDescriptor = PROTOCOL_DESCR_SYM(SQ);
+
+const Metadata *SwiftValueHeader::getEquatableBaseType() const {
+  auto witnessTable =
+    swift_conformsToProtocolCommon(type, &EquatableProtocolDescriptor);
+  if (!witnessTable) {
+    return nullptr;
+  }
+#if SWIFT_STDLIB_USE_RELATIVE_PROTOCOL_WITNESS_TABLES
+  const auto *conformance = lookThroughOptionalConditionalWitnessTable(
+    reinterpret_cast<const RelativeWitnessTable*>(witnessTable))
+    ->getDescription();
+#else
+  const auto *conformance = witnessTable->getDescription();
+#endif
+  const Metadata *baseTypeThatConformsToEquatable =
+    findConformingSuperclass(type, conformance);
+  return baseTypeThatConformsToEquatable;
+}
+
 const hashable_support::HashableWitnessTable *
 SwiftValueHeader::getHashableConformance() const {
   if (auto wt = hashableConformance.load(std::memory_order_acquire)) {
@@ -124,6 +161,14 @@ - (id)copyWithZone:(NSZone *)zone;
   return wt;
 }
 
+const EquatableWitnessTable *
+SwiftValueHeader::getEquatableConformance() const {
+  const EquatableWitnessTable *wt =
+      reinterpret_cast<const EquatableWitnessTable *>(
+          swift_conformsToProtocolCommon(type, &EquatableProtocolDescriptor));
+  return wt;
+}
+
 static constexpr const size_t SwiftValueHeaderOffset
   = sizeof(Class); // isa pointer
 static constexpr const size_t SwiftValueMinAlignMask
@@ -300,30 +345,53 @@ - (BOOL)isEqual:(id)other {
     return NO;
   }
 
+  // `other` must also be a _SwiftValue box
   if (![other isKindOfClass:getSwiftValueClass()]) {
     return NO;
   }
 
   auto selfHeader = getSwiftValueHeader(self);
   auto otherHeader = getSwiftValueHeader(other);
 
-  auto hashableBaseType = selfHeader->getHashableBaseType();
-  if (!hashableBaseType ||
-      otherHeader->getHashableBaseType() != hashableBaseType) {
-    return NO;
+  // TODO: getHashableBaseType seems to always succeed,
+  // even if the type is in fact not Hashable.  Why?
+  // Maybe we should try getting the conformance first,
+  // since that seems to actually fail?
+  auto selfHashableBaseType = selfHeader->getHashableBaseType();
+  if (selfHashableBaseType) {
+    auto otherHashableBaseType = otherHeader->getHashableBaseType();
+    if (selfHashableBaseType == otherHashableBaseType) {
+      auto hashableConformance = selfHeader->getHashableConformance();
+      if (hashableConformance) {
+        return _swift_stdlib_Hashable_isEqual_indirect(
+          getSwiftValuePayload(self,
+                               getSwiftValuePayloadAlignMask(selfHeader->type)),
+          getSwiftValuePayload(other,
+                               getSwiftValuePayloadAlignMask(otherHeader->type)),
+          selfHashableBaseType, hashableConformance);
+      }
+    }
   }
 
-  auto hashableConformance = selfHeader->getHashableConformance();
-  if (!hashableConformance) {
-    return NO;
+  // TODO: As above, getEquatableBaseType seems to always succeed
+  // even if the type is not in fact Equatable.
+  auto selfEquatableBaseType = selfHeader->getEquatableBaseType();
+  if (selfEquatableBaseType) {
+    auto otherEquatableBaseType = otherHeader->getEquatableBaseType();
+    if (selfEquatableBaseType == otherEquatableBaseType) {
+      auto equatableConformance = selfHeader->getEquatableConformance();
+      if (equatableConformance) {
+        return _swift_stdlib_Equatable_isEqual_indirect(
+          getSwiftValuePayload(self,
+                               getSwiftValuePayloadAlignMask(selfHeader->type)),
+          getSwiftValuePayload(other,
+                               getSwiftValuePayloadAlignMask(otherHeader->type)),
+          selfEquatableBaseType, equatableConformance);
+      }
+    }
   }
 
-  return _swift_stdlib_Hashable_isEqual_indirect(
-      getSwiftValuePayload(self,
-                           getSwiftValuePayloadAlignMask(selfHeader->type)),
-      getSwiftValuePayload(other,
-                           getSwiftValuePayloadAlignMask(otherHeader->type)),
-      hashableBaseType, hashableConformance);
+  return NO;
 }
 
 - (NSUInteger)hash {

test/stdlib/BridgeEquatableToObjC.swift

@@ -0,0 +1,47 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -g %s -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out
+
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+
+import StdlibUnittest
+import Foundation
+
+var BridgeEquatableToObjC = TestSuite("BridgeEquatableToObjC")
+
+struct MyEquatableStruct: Equatable {
+  var text: String
+}
+
+struct MyNonEquatableStruct {
+  var text: String
+}
+
+BridgeEquatableToObjC.test("Bridge equatable struct") {
+  let swiftA = MyEquatableStruct(text: "xABC")
+  let swiftB = swiftA
+  let swiftResult = swiftA == swiftB
+
+  let objcA = swiftA as AnyObject
+  let objcB = swiftB as AnyObject
+  let objcResult = objcA.isEqual(objcB)
+
+  expectEqual(swiftResult, true)
+  expectEqual(objcResult, true)
+}
+
+BridgeEquatableToObjC.test("Bridge non-equatable struct") {
+  let swiftA = MyNonEquatableStruct(text: "xABC")
+  let swiftB = swiftA
+
+  let objcA = swiftA as AnyObject
+  let objcB = swiftB as AnyObject
+  let objcResult = objcA.isEqual(objcB)
+
+  expectEqual(objcResult, false)
+}
+
+
+runAllTests()