Use Swift Equatable and Hashable conformances from ObjC

If a Swift type implements Equatable and/or Hashable and
we then pass that object into ObjC, we want ObjC
`isEqual:` and `hashValue` to use that.  This allows
ObjC code to build ObjC collections of Swift objects.

* Support for Hashable struct/enum types was implemented in #4124
* Support for Equatable struct/enum types was implemented in swiftlang#68720
* This implements support for Hashable and Equatable _class_ types

Caveats:
1. This does a lot of dynamic lookup work for each operation, so is
   inherently rather slow.  Unlike the struct/enum case, there is no convenient
   place to cache the conformance information, so it's not clear that there is a
   viable way to make it significantly faster.
2. This is a behavioral change to low-level support code.  There is a
   risk of breaking code that may be relying on the old behavior.

Author: tbkka

stdlib/public/runtime/SwiftObject.mm

@@ -41,6 +41,7 @@
 #include "../CompatibilityOverride/CompatibilityOverride.h"
 #include "ErrorObject.h"
 #include "Private.h"
+#include "SwiftEquatableSupport.h"
 #include "SwiftObject.h"
 #include "SwiftValue.h"
 #include "WeakReference.h"
@@ -373,11 +374,62 @@ + (BOOL)conformsToProtocol:(Protocol*)proto {
 }
 
 - (NSUInteger)hash {
-  return (NSUInteger)self;
+  auto selfMetadata = _swift_getClassOfAllocated(self);
+  auto hashableConformance =
+    reinterpret_cast<const hashable_support::HashableWitnessTable *>(
+      swift_conformsToProtocolCommon(
+	selfMetadata, &hashable_support::HashableProtocolDescriptor));
+  if (hashableConformance == NULL) {
+    return (NSUInteger)self;
+  }
+  return _swift_stdlib_Hashable_hashValue_indirect(
+    &self, selfMetadata, hashableConformance);
 }
 
-- (BOOL)isEqual:(id)object {
-  return self == object;
+- (BOOL)isEqual:(id)other {
+  if (self == other) {
+    return YES;
+  }
+  // Both objects must be `SwiftObject` in ObjC
+  if (object_getClass(other) != object_getClass((id)self)) {
+    return NO;
+  }
+
+  // TODO: Bincompat check -- return NO if this is an old executable
+
+  // Get Swift type for self and other
+  auto selfMetadata = _swift_getClassOfAllocated(self);
+  auto otherMetadata = _swift_getClassOfAllocated(other);
+
+  // Find common parent Swift class
+  const ClassMetadata * parentMetadata = NULL;
+  // Collect parents of self
+  std::unordered_set<const ClassMetadata *> selfParents;
+  for (auto m = selfMetadata; m != NULL; m = m->Superclass) {
+    selfParents.emplace(m);
+  }
+  // Find first parent of other that is also a parent of self
+  for (auto m = otherMetadata; m != NULL; m = m->Superclass) {
+    if (selfParents.find(m) != selfParents.end()) {
+      parentMetadata = m;
+      break;
+    }
+  }
+  // If there's no common Swift parent class, we can't compare them
+  if (parentMetadata == NULL) {
+    return NO;
+  }
+
+  auto equatableConformance =
+    reinterpret_cast<const equatable_support::EquatableWitnessTable *>(
+      swift_conformsToProtocolCommon(
+        parentMetadata, &equatable_support::EquatableProtocolDescriptor));
+  if (equatableConformance == NULL) {
+    return NO;
+  }
+
+  return _swift_stdlib_Equatable_isEqual_indirect(
+          &self, &other, parentMetadata, equatableConformance);
 }
 
 - (id)performSelector:(SEL)aSelector {

test/stdlib/Inputs/SwiftObjectNSObject/SwiftObjectNSObject.m

@@ -80,7 +80,10 @@ void HackSwiftObject()
     class_addMethod(cls, @selector(perform2::), (IMP)Perform2, "@@:@@");
 }
 
-void TestSwiftObjectNSObject(id c, id d)
+void TestSwiftObjectNSObject(id c, id d,
+			     id e1a, id e1b, id e2,
+			     id h1a, id h1b, id h2,
+			     NSUInteger hash1, NSUInteger hash2)
 {
   printf("TestSwiftObjectNSObject\n");
 
@@ -159,12 +162,24 @@ void TestSwiftObjectNSObject(id c, id d)
   expectFalse([C_meta isEqual:D_meta]);
   expectFalse([S_meta isEqual:C_meta]);
 
+  // Check that ObjC isEqual delegates to Equatable
+  expectTrue([e1a isEqual: e1b]);
+  expectFalse([e1a isEqual: e2]);
+  expectFalse([e1b isEqual: e2]);
+
+  // Check that ObjC isEqual delegates to Hashable
+  expectTrue([h1a isEqual: h1b]);
+  expectFalse([h1a isEqual: h2]);
+  expectFalse([h1b isEqual: h2]);
 
   printf("NSObjectProtocol.hash\n");
 
   expectTrue ([d hash] + [c hash] + [D hash] + [C hash] + [S hash] +
               [D_meta hash] + [C_meta hash] + [S_meta hash] != 0);
 
+  expectTrue([h1a hash] == hash1);
+  expectTrue([h1b hash] == hash1);
+  expectTrue([h2 hash] == hash2);
 
   printf("NSObjectProtocol.self\n");
 

test/stdlib/SwiftObjectNSObject.swift

@@ -39,8 +39,24 @@ class D : C {
   @objc override class func cClassOverride() -> Int { return 8 }
 }
 
+class E : Equatable {
+  var i : Int
+  static func ==(lhs: E, rhs: E) -> Bool { lhs.i == rhs.i }
+  init(i: Int) { self.i = i }
+}
+
+class H : Hashable {
+  var i : Int
+  static func ==(lhs: H, rhs: H) -> Bool { lhs.i == rhs.i }
+  func hash(into hasher: inout Hasher) { hasher.combine(i + 17) }
+  init(i: Int) { self.i = i }
+}
+
 @_silgen_name("TestSwiftObjectNSObject") 
-func TestSwiftObjectNSObject(_ c: C, _ d: D)
+func TestSwiftObjectNSObject(
+  _ c: C, _ d: D,
+  _ e1a: E, _ e1b: E, _ e2: E,
+  _ h1a: H, _ h1b: H, _ h2: H, _ hash1: UInt, _ hash2: UInt)
 
 // This check is for NSLog() output from TestSwiftObjectNSObject().
 // CHECK: c ##SwiftObjectNSObject.C##
@@ -50,7 +66,9 @@ func TestSwiftObjectNSObject(_ c: C, _ d: D)
 // Temporarily disable this test on older OSes until we have time to
 // look into why it's failing there. rdar://problem/47870743
 if #available(OSX 10.12, iOS 10.0, *) {
-  TestSwiftObjectNSObject(C(), D())
+  TestSwiftObjectNSObject(C(), D(),
+    E(i:1), E(i:1), E(i:2),
+    H(i:1), H(i:1), H(i:2), UInt(H(i:1).hashValue), UInt(H(i:2).hashValue))
   // does not return
 } else {
   // Horrible hack to satisfy FileCheck