Avoid protocol conformance lookups in more NSString bridging scenarios

stdlib/public/core/AnyHashable.swift

@@ -145,7 +145,13 @@ public struct AnyHashable {
   /// Creates a type-erased hashable value that wraps the given instance.
   ///
   /// - Parameter base: A hashable value to wrap.
+  @_specialize(where H == String)
   public init<H: Hashable>(_ base: H) {
+    if H.self == String.self {
+      self.init(_box: _ConcreteHashableBox(base))
+      return
+    }
+
     if let custom =
       (base as? _HasCustomAnyHashableRepresentation)?._toCustomAnyHashable() {
       self = custom

stdlib/public/runtime/DynamicCast.cpp

@@ -764,14 +764,21 @@ tryCastToAnyHashable(
   assert(cast<StructMetadata>(destType)->Description
          == &STRUCT_TYPE_DESCR_SYM(s11AnyHashable));
 
+  const HashableWitnessTable *hashableConformance = nullptr;
+
   switch (srcType->getKind()) {
   case MetadataKind::ForeignClass: // CF -> String
   case MetadataKind::ObjCClassWrapper: { // Obj-C -> String
 #if SWIFT_OBJC_INTEROP
-    // TODO: Implement a fast path for NSString->AnyHashable casts.
-    // These are incredibly common because an NSDictionary with
-    // NSString keys is bridged by default to [AnyHashable:Any].
-    // Until this is implemented, fall through to the general case
+    auto cls = srcType;
+    auto nsString = getNSStringMetadata();
+    do {
+      if (cls == nsString) {
+        hashableConformance = getNSStringHashableConformance();
+        break;
+      }
+      cls = _swift_class_getSuperclass(cls);
+    } while (cls != nullptr);
     break;
 #else
     // If no Obj-C interop, just fall through to the general case.
@@ -805,8 +812,11 @@ tryCastToAnyHashable(
 
 
   // General case: If it conforms to Hashable, we cast it
-  auto hashableConformance = reinterpret_cast<const HashableWitnessTable *>(
-    swift_conformsToProtocol(srcType, &HashableProtocolDescriptor));
+  if (hashableConformance == nullptr) {
+    hashableConformance = reinterpret_cast<const HashableWitnessTable *>(
+      swift_conformsToProtocol(srcType, &HashableProtocolDescriptor)
+    );
+  }
   if (hashableConformance) {
     _swift_convertToAnyHashableIndirect(srcValue, destLocation,
                                         srcType, hashableConformance);

stdlib/public/runtime/SwiftObject.h

@@ -22,6 +22,7 @@
 #include <cstdint>
 #include <utility>
 #include "swift/Runtime/HeapObject.h"
+#include "../runtime/SwiftHashableSupport.h"
 #if SWIFT_OBJC_INTEROP
 #include <objc/NSObject.h>
 #endif
@@ -89,7 +90,11 @@ namespace swift {
 
 /// Get the NSObject metadata.
 const Metadata *getNSObjectMetadata();
+const Metadata *getNSStringMetadata();
 
+namespace hashable_support {
+const HashableWitnessTable *getNSStringHashableConformance();
+}
 }
 
 #endif

stdlib/public/runtime/SwiftObject.mm

@@ -56,6 +56,7 @@
 #endif
 
 using namespace swift;
+using namespace hashable_support;
 
 #if SWIFT_HAS_ISA_MASKING
 OBJC_EXPORT __attribute__((__weak_import__))
@@ -1600,6 +1601,24 @@ void swift_objc_swift3ImplicitObjCEntrypoint(id self, SEL selector,
       swift_getObjCClassMetadata((const ClassMetadata *)[NSObject class]));
 }
 
+const Metadata *swift::getNSStringMetadata() {
+  return SWIFT_LAZY_CONSTANT(swift_getObjCClassMetadata(
+    (const ClassMetadata *)objc_lookUpClass("NSString")
+  ));
+}
+
+const HashableWitnessTable *
+swift::hashable_support::getNSStringHashableConformance() {
+  return SWIFT_LAZY_CONSTANT(
+    reinterpret_cast<const HashableWitnessTable *>(
+      swift_conformsToProtocol(
+        getNSStringMetadata(),
+        &HashableProtocolDescriptor
+      )
+    )
+  );
+}
+
 #endif
 
 const ClassMetadata *swift::getRootSuperclass() {