Log a message when Obj-C -hash is invoked for a Swift object that is Equatable but not Hashable

This is worth telling people about:

Since we're being asked for the hash value, that probably means someone is
trying to put this object into some form of set or dictionary.  But we don't know
anything about the Equatable implementation, so the only valid hash value we can
possibly return is a constant.  And hash table implementations typically degrade
into unsorted lists when provided constant hash values.

Note: In order to avoid hammering the logs, we only emit the
warning once for each class that hits this path.

Author: tbkka

stdlib/public/runtime/SwiftObject.mm

@@ -388,19 +388,28 @@ - (NSUInteger)hash {
 
   // If a type is Equatable (but not Hashable), we
   // have to return something here that is compatible
-  // with the `isEqual:` below.  NSObject's default
-  // of `(NSUInteger)self` won't work, so we instead
-  // return a constant fallback value:
+  // with the `isEqual:` below.
   auto equatableConformance =
     reinterpret_cast<const equatable_support::EquatableWitnessTable *>(
       swift_conformsToProtocolCommon(
 	selfMetadata, &equatable_support::EquatableProtocolDescriptor));
   if (equatableConformance != nullptr) {
-    const char *clsName = class_getName([self class]);
-    warning(0,
-	    "Obj-C `-hash` invoked on a Swift object of type %s that is not Hashable; "
-	    "this can lead to severe performance problems",
-	    clsName);
+    // Warn once per class about this
+    auto selfClass = [self class];
+    static Lazy<std::unordered_set<Class>> warned;
+    static LazyMutex warnedLock;
+    LazyMutex::ScopedLock guard(warnedLock);
+    auto result = warned.get().insert(selfClass);
+    auto inserted = std::get<1>(result);
+    if (inserted) {
+      const char *clsName = class_getName([self class]);
+      warning(0,
+	      "Obj-C `-hash` method was invoked on a Swift object of type `%s` "
+	      "that is Equatable but not Hashable; "
+	      "this can lead to severe performance problems.\n",
+	      clsName);
+    }
+    // Constant value (yuck!) is the only choice here
     return (NSUInteger)1;
   }
 

test/stdlib/SwiftObjectNSObject.swift

@@ -16,6 +16,7 @@
 // RUN: %target-build-swift %s -g -I %S/Inputs/SwiftObjectNSObject/ -Xlinker %t/SwiftObjectNSObject.o -o %t/SwiftObjectNSObject
 // RUN: %target-codesign %t/SwiftObjectNSObject
 // RUN: %target-run %t/SwiftObjectNSObject 2> %t/log.txt
+// RUN: cat %t/log.txt 1>&2
 // RUN: %FileCheck %s < %t/log.txt
 // REQUIRES: executable_test
 
@@ -115,11 +116,17 @@ func TestNonEquatableHash(_ e: AnyObject)
   TestSwiftObjectNSObjectDefaultHashValue(e)
 }
 
-// This check is for NSLog() output from TestSwiftObjectNSObject().
+// Check NSLog() output from TestSwiftObjectNSObject().
+
 // CHECK: c ##SwiftObjectNSObject.C##
 // CHECK-NEXT: d ##SwiftObjectNSObject.D##
 // CHECK-NEXT: S ##{{.*}}SwiftObject##
 
+// Full message is longer, but this is the essential part...
+// CHECK-NEXT: Obj-C `-hash` {{.*}} type `SwiftObjectNSObject.E` {{.*}} Equatable but not Hashable
+// CHECK-NEXT: Obj-C `-hash` {{.*}} type `SwiftObjectNSObject.E1` {{.*}} Equatable but not Hashable
+// CHECK-NEXT: Obj-C `-hash` {{.*}} type `SwiftObjectNSObject.E2` {{.*}} Equatable but not Hashable
+
 // 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, *) {
@@ -185,4 +192,7 @@ if #available(OSX 10.12, iOS 10.0, *) {
   fputs("c ##SwiftObjectNSObject.C##\n", stderr)
   fputs("d ##SwiftObjectNSObject.D##\n", stderr)
   fputs("S ##Swift._SwiftObject##\n", stderr)
+  fputs("Obj-C `-hash` ... type `SwiftObjectNSObject.E` ... Equatable but not Hashable", stderr)
+  fputs("Obj-C `-hash` ... type `SwiftObjectNSObject.E1` ... Equatable but not Hashable", stderr)
+  fputs("Obj-C `-hash` ... type `SwiftObjectNSObject.E2` ... Equatable but not Hashable", stderr)
 }