Assorted bridging changes:

• Convert _AbstractStringStorage to a protocol, and the free functions used to deduplicate implementations to extensions on that protocol.
• Move 'start' into the abstract type and use that to simplify some code
• Move the ASCII fast path for length into UTF16View.
• Add a weirder but faster way to check which (if any) of our NSString subclasses a given object is, and adopt it

Author: Catfish-Man

stdlib/public/SwiftShims/CoreFoundationShims.h

@@ -137,6 +137,10 @@ _swift_stdlib_NSStringGetCStringTrampoline(id _Nonnull obj,
                                          _swift_shims_UInt8 *buffer,
                                          _swift_shims_CFIndex maxLength,
                                          unsigned long encoding);
+
+SWIFT_RUNTIME_STDLIB_API
+__swift_uintptr_t
+_swift_stdlib_unsafeAddressOfClass(id _Nonnull obj);
 
 #endif // __OBJC2__
 

stdlib/public/core/StringBridge.swift

@@ -107,6 +107,8 @@ internal func _cocoaCStringUsingEncodingTrampoline(
 }
 
 
+
+
 @_effects(releasenone)
 internal func _cocoaGetCStringTrampoline(
                              _ string: _CocoaString,
@@ -131,6 +133,40 @@ private var kCFStringEncodingUTF8 : _swift_shims_CFStringEncoding {
   @inline(__always) get { return 0x8000100 }
 }
 
+@_effects(readonly)
+private func _unsafeAddressOfCocoaStringClass(_ str: _CocoaString) -> UInt {
+  return _swift_stdlib_unsafeAddressOfClass(str)
+}
+
+internal enum _KnownCocoaString {
+  case storage
+  case shared
+  case cocoa
+#if !(arch(i386) || arch(arm))
+  case tagged
+#endif
+  
+  @inline(__always)
+  init(_ str: _CocoaString) {
+    
+    #if !(arch(i386) || arch(arm))
+    if _isObjCTaggedPointer(str) {
+      self = .tagged
+      return
+    }
+    #endif
+    
+    switch _unsafeAddressOfCocoaStringClass(str) {
+    case unsafeBitCast(_StringStorage.self, to: UInt.self):
+      self = .storage
+    case unsafeBitCast(_SharedStringStorage.self, to: UInt.self):
+      self = .shared
+    default:
+      self = .cocoa
+    }
+  }
+}
+
 #if !(arch(i386) || arch(arm))
 // Resiliently write a tagged cocoa string's contents into a buffer
 @_effects(releasenone) // @opaque
@@ -185,47 +221,49 @@ private func _getCocoaStringPointer(
 @usableFromInline
 @_effects(releasenone) // @opaque
 internal func _bridgeCocoaString(_ cocoaString: _CocoaString) -> _StringGuts {
-  if let abstract = cocoaString as? _AbstractStringStorage {
-    return abstract.asString._guts
-  }
+  switch _KnownCocoaString(cocoaString) {
+  case .storage:
+    return _unsafeUncheckedDowncast(cocoaString, to: _StringStorage.self).asString._guts
+  case .shared:
+    return _unsafeUncheckedDowncast(cocoaString, to: _SharedStringStorage.self).asString._guts
 #if !(arch(i386) || arch(arm))
-  if _isObjCTaggedPointer(cocoaString) {
-    return _StringGuts(_SmallString(taggedCocoa: cocoaString))
-  }
+  case .tagged:
+      return _StringGuts(_SmallString(taggedCocoa: cocoaString))
 #endif
-
-  // "copy" it into a value to be sure nobody will modify behind
-  // our backs.  In practice, when value is already immutable, this
-  // just does a retain.
-  //
-  // TODO: Only in certain circumstances should we emit this call:
-  //   1) If it's immutable, just retain it.
-  //   2) If it's mutable with no associated information, then a copy must
-  //      happen; might as well eagerly bridge it in.
-  //   3) If it's mutable with associated information, must make the call
-  //
-  let immutableCopy
-    = _stdlib_binary_CFStringCreateCopy(cocoaString) as AnyObject
-
-#if !(arch(i386) || arch(arm))
-  if _isObjCTaggedPointer(immutableCopy) {
-    return _StringGuts(_SmallString(taggedCocoa: immutableCopy))
-  }
-#endif
-
-  let (fastUTF8, isASCII): (Bool, Bool)
-  switch _getCocoaStringPointer(immutableCopy) {
+  case .cocoa:
+    // "copy" it into a value to be sure nobody will modify behind
+    // our backs.  In practice, when value is already immutable, this
+    // just does a retain.
+    //
+    // TODO: Only in certain circumstances should we emit this call:
+    //   1) If it's immutable, just retain it.
+    //   2) If it's mutable with no associated information, then a copy must
+    //      happen; might as well eagerly bridge it in.
+    //   3) If it's mutable with associated information, must make the call
+    //
+    let immutableCopy
+      = _stdlib_binary_CFStringCreateCopy(cocoaString) as AnyObject
+    
+    #if !(arch(i386) || arch(arm))
+    if _isObjCTaggedPointer(immutableCopy) {
+      return _StringGuts(_SmallString(taggedCocoa: immutableCopy))
+    }
+    #endif
+    
+    let (fastUTF8, isASCII): (Bool, Bool)
+    switch _getCocoaStringPointer(immutableCopy) {
     case .ascii(_): (fastUTF8, isASCII) = (true, true)
     case .utf8(_): (fastUTF8, isASCII) = (true, false)
     default:  (fastUTF8, isASCII) = (false, false)
+    }
+    let length = _stdlib_binary_CFStringGetLength(immutableCopy)
+    
+    return _StringGuts(
+      cocoa: immutableCopy,
+      providesFastUTF8: fastUTF8,
+      isASCII: isASCII,
+      length: length)
   }
-  let length = _stdlib_binary_CFStringGetLength(immutableCopy)
-
-  return _StringGuts(
-    cocoa: immutableCopy,
-    providesFastUTF8: fastUTF8,
-    isASCII: isASCII,
-    length: length)
 }
 
 extension String {