Make SwiftValue hash/equality work the same as SwiftObject

Update PR #68720 with lessons learned in reviewing #69464

Background:

* SwiftValue can expose Swift value types (structs/enums)
  to ObjC by wrapping them in an Obj-C object on the heap

* SwiftObject is the Obj-C type that Swift class objects all
  inherit from (when viewed from Obj-C).  This allows arbitrary
  Swift class objects to be passed into Obj-C.

History:

* PR #4124 made Obj-C `-hash` and `-isEqual:` work for SwiftValue for Hashable Swift types

* PR #68720 extended SwiftValue to also support Equatable Swift types

* PR #69464 added similar support to SwiftObject

In the process of working through #69464, we found a better way
to handle an ObjC request for `-hash` for a type that is Swift
Equatable but not Hashable.  This PR updates SwiftValue to use
the same approach.  The approach considers three cases:

1. A Hashable type can forward both `-hash` and `-isEqual:` to
   the Swift object.

2. A type that is neither Equatable nor Hashable can implement
   `-isEqual:` as the identity check and `-hash` as returning
   the address of the object in memory.

3. A type is that Equatable but not Hashable is more complex.

In this last case, we can easily forward `-isEqual:` to the
Equatable conformance but ObjC also requires us to
always provide a compatible `-hash` implementation.
The only way to do this is to have `-hash` return a constant,
but that is a very bad idea in general, so we're also including
a log message whenever we see a request for `-hash` on
a Swift value that is Equatable but not Hashable.
To limit performance problems from the logging itself, we
emit the log message only once for each type.

Author: tbkka

stdlib/public/runtime/SwiftValue.mm

@@ -29,13 +29,15 @@
 #include "swift/Runtime/Metadata.h"
 #include "swift/Runtime/ObjCBridge.h"
 #include "swift/Runtime/Debug.h"
+#include "swift/Threading/Mutex.h"
 #include "Private.h"
 #include "SwiftEquatableSupport.h"
 #include "SwiftHashableSupport.h"
 #include <objc/runtime.h>
 #include <Foundation/Foundation.h>
 
 #include <new>
+#include <unordered_set>
 
 using namespace swift;
 using namespace swift::hashable_support;
@@ -446,15 +448,43 @@ - (BOOL)isEqual:(id)other {
 }
 
 - (NSUInteger)hash {
+  // If Swift type is Hashable, get the hash value from there
   auto selfHeader = getSwiftValueHeader(self);
   auto hashableConformance = selfHeader->getHashableConformance();
-  if (!hashableConformance) {
-    return (NSUInteger)self;
+  if (hashableConformance) {
+	  return _swift_stdlib_Hashable_hashValue_indirect(
+	    getSwiftValuePayload(self,
+				 getSwiftValuePayloadAlignMask(selfHeader->type)),
+	    selfHeader->type, hashableConformance);
   }
-  return _swift_stdlib_Hashable_hashValue_indirect(
-      getSwiftValuePayload(self,
-                           getSwiftValuePayloadAlignMask(selfHeader->type)),
-      selfHeader->type, hashableConformance);
+
+  // If Swift type is Equatable but not Hashable,
+  // we have to return something here that is compatible
+  // with the `isEqual:` above.
+  auto equatableConformance = selfHeader->getEquatableConformance();
+  if (equatableConformance) {
+    // Warn once per type about this
+    auto metadata = getSwiftValueTypeMetadata(self);
+    static Lazy<std::unordered_set<const Metadata *>> warned;
+    static LazyMutex warnedLock;
+    LazyMutex::ScopedLock guard(warnedLock);
+    auto result = warned.get().insert(metadata);
+    auto inserted = std::get<1>(result);
+    if (inserted) {
+      TypeNamePair typeName = swift_getTypeName(metadata, true);
+      warning(0,
+	      "Obj-C `-hash` invoked on a Swift value of type `%s` that is Equatable but not Hashable; "
+	      "this can lead to severe performance problems.\n",
+	      typeName.data);
+    }
+    // Constant value (yuck!) is the only choice here
+    return (NSUInteger)1;
+  }
+
+  // If the Swift type is neither Equatable nor Hashable,
+  // then we can hash the identity, which should be pretty
+  // good in practice.
+  return (NSUInteger)self;
 }
 
 static id getValueDescription(__SwiftValue *self) {