stdlib: make AnyHashable(SwiftValue) unbox the value

Previously AnyHashable would consider SwiftValue to be a subclass of
NSObject (which it is in practice) and return false when trying to
compare an AnyHashable of a SwiftValue box to an AnyHashable of the
unboxed value.

Author: gribozavr

stdlib/public/runtime/AnyHashableSupport.cpp

@@ -16,6 +16,7 @@
 #include "swift/Runtime/Debug.h"
 #include "swift/Runtime/Metadata.h"
 #include "Private.h"
+#include "SwiftValue.h"
 #include "SwiftHashableSupport.h"
 
 using namespace swift;
@@ -126,7 +127,7 @@ extern "C" void _swift_stdlib_makeAnyHashableUsingDefaultRepresentation(
 
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERFACE
 extern "C" void _swift_stdlib_makeAnyHashableUpcastingToHashableBaseType(
-  const OpaqueValue *value,
+  OpaqueValue *value,
   const void *anyHashableResultPointer,
   const Metadata *type,
   const WitnessTable *hashableWT
@@ -135,6 +136,32 @@ extern "C" void _swift_stdlib_makeAnyHashableUpcastingToHashableBaseType(
   case MetadataKind::Class:
   case MetadataKind::ObjCClassWrapper:
   case MetadataKind::ForeignClass: {
+#if SWIFT_OBJC_INTEROP
+    id srcObject;
+    memcpy(&srcObject, value, sizeof(id));
+    // Do we have a SwiftValue?
+    if (SwiftValue *srcSwiftValue = getAsSwiftValue(srcObject)) {
+      // If so, extract the boxed value and try to cast it.
+      const Metadata *unboxedType;
+      const OpaqueValue *unboxedValue;
+      std::tie(unboxedType, unboxedValue) =
+          getValueFromSwiftValue(srcSwiftValue);
+
+      if (auto unboxedHashableWT =
+              swift_conformsToProtocol(type, &_TMps8Hashable)) {
+        ValueBuffer unboxedCopyBuf;
+        auto unboxedValueCopy = unboxedType->vw_initializeBufferWithCopy(
+            &unboxedCopyBuf, const_cast<OpaqueValue *>(unboxedValue));
+        _swift_stdlib_makeAnyHashableUpcastingToHashableBaseType(
+            unboxedValueCopy, anyHashableResultPointer, unboxedType,
+            unboxedHashableWT);
+        unboxedType->vw_deallocateBuffer(&unboxedCopyBuf);
+        type->vw_destroy(value);
+        return;
+      }
+    }
+#endif
+
     _swift_stdlib_makeAnyHashableUsingDefaultRepresentation(
         value, anyHashableResultPointer,
         findHashableBaseTypeOfHashableType(type),

validation-test/stdlib/AnyHashable.swift.gyb

@@ -88,6 +88,29 @@ AnyHashableTests.test("AnyHashable(${wrapped}).base") {
 }
 % end
 
+#if _runtime(_ObjC)
+AnyHashableTests.test("AnyHashable(MinimalHashableValue, SwiftValue(MinimalHashableValue))/Hashable") {
+  let xs = (0...5).flatMap {
+    [ MinimalHashableValue($0, identity: 0),
+      MinimalHashableValue($0, identity: 1) ]
+  }
+  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })
+
+  let boxedXs = xs.flatMap {
+    [ AnyHashable($0),
+      AnyHashable(_bridgeAnythingToObjectiveC($0) as! NSObject) ]
+  }
+  for x in boxedXs {
+    expectEqual(
+      "MinimalHashableValue",
+      String(describing: type(of: x.base)))
+  }
+  checkHashable(
+    boxedXs,
+    equalityOracle: { $0 / 4 == $1 / 4 })
+}
+#endif
+
 % for wrapped in ['GenericMinimalHashableValue', 'GenericMinimalHashableClass']:
 %   for payload in [ 'OpaqueValue<Int>', 'LifetimeTracked' ]:
 AnyHashableTests.test("AnyHashable(${wrapped}<OpaqueValue<Int>>)/Hashable") {