[stdlib] String: Avoid retain/release operations around use sites of sharedStorage and cocoaObject

Author: lorentey

stdlib/public/core/StringGuts.swift

@@ -249,12 +249,11 @@ extension _StringGuts {
   ) -> Int? {
     #if _runtime(_ObjC)
     // Currently, foreign  means NSString
-    if let res = _cocoaStringCopyUTF8(_object.cocoaObject,
-      into: UnsafeMutableRawBufferPointer(start: mbp.baseAddress,
-                                          count: mbp.count)) {
-      return res
+    let res = _object.withCocoaObject {
+      _cocoaStringCopyUTF8($0, into: UnsafeMutableRawBufferPointer(mbp))
     }
-    
+    if let res { return res }
+
     // If the NSString contains invalid UTF8 (e.g. unpaired surrogates), we
     // can get nil from cocoaStringCopyUTF8 in situations where a character by
     // character loop would get something more useful like repaired contents

stdlib/public/core/StringObject.swift

@@ -933,11 +933,12 @@ extension _StringObject {
     _internalInvariant(largeFastIsShared)
 #if _runtime(_ObjC)
     if largeIsCocoa {
-      return stableCocoaUTF8Pointer(cocoaObject)._unsafelyUnwrappedUnchecked
+      return withCocoaObject {
+        stableCocoaUTF8Pointer($0)._unsafelyUnwrappedUnchecked
+      }
     }
 #endif
-
-    return sharedStorage.start
+    return withSharedStorage { $0.start }
   }
 
   @usableFromInline
@@ -970,6 +971,7 @@ extension _StringObject {
     _ body: (__StringStorage) -> R
   ) -> R {
 #if arch(i386) || arch(arm) || arch(arm64_32) || arch(wasm32)
+    // FIXME: Do this properly.
     return body(nativeStorage)
 #else
     _internalInvariant(hasNativeStorage)
@@ -993,6 +995,21 @@ extension _StringObject {
 #endif
   }
 
+  @inline(__always)
+  internal func withSharedStorage<R>(
+    _ body: (__SharedStringStorage) -> R
+  ) -> R {
+#if arch(i386) || arch(arm) || arch(arm64_32) || arch(wasm32)
+    // FIXME: Do this properly.
+    return body(sharedStorage)
+#else
+    _internalInvariant(largeFastIsShared && !largeIsCocoa)
+    _internalInvariant(hasSharedStorage)
+    let unmanaged = Unmanaged<__SharedStringStorage>.fromOpaque(largeAddress)
+    return unmanaged._withUnsafeGuaranteedRef { body($0) }
+#endif
+  }
+
   @inline(__always)
   internal var cocoaObject: AnyObject {
 #if arch(i386) || arch(arm) || arch(arm64_32) || arch(wasm32)
@@ -1007,6 +1024,22 @@ extension _StringObject {
 #endif
   }
 
+  /// Call `body` with the bridged Cocoa object in `self`, without retaining
+  /// it.
+  @inline(__always)
+  internal func withCocoaObject<R>(
+    _ body: (AnyObject) -> R
+  ) -> R {
+#if arch(i386) || arch(arm) || arch(arm64_32) || arch(wasm32)
+    // FIXME: Do this properly.
+    return body(cocoaObject)
+#else
+    _internalInvariant(largeIsCocoa && !isImmortal)
+    let unmanaged = Unmanaged<AnyObject>.fromOpaque(largeAddress)
+    return unmanaged._withUnsafeGuaranteedRef { body($0) }
+#endif
+  }
+
   @_alwaysEmitIntoClient
   @inlinable
   @inline(__always)

stdlib/public/core/StringStorage.swift

@@ -737,8 +737,9 @@ extension _StringGuts {
     if hasNativeStorage {
       mutPtr = _object.withNativeStorage { $0._breadcrumbsAddress }
     } else {
-      mutPtr = UnsafeMutablePointer(
-        Builtin.addressof(&_object.sharedStorage._breadcrumbs))
+      mutPtr = _object.withSharedStorage {
+        UnsafeMutablePointer(Builtin.addressof(&$0._breadcrumbs))
+      }
     }
 
     if let breadcrumbs = _stdlib_atomicAcquiringLoadARCRef(object: mutPtr) {

stdlib/public/core/StringUTF8View.swift

@@ -541,10 +541,10 @@ extension String.UTF8View {
 
     #if _runtime(_ObjC)
     // Currently, foreign means NSString
-    if let count = _cocoaStringUTF8Count(
-      _guts._object.cocoaObject,
-      range: i._encodedOffset ..< j._encodedOffset
-    ) {
+    let count = _guts._object.withCocoaObject {
+      _cocoaStringUTF8Count($0, range: i._encodedOffset ..< j._encodedOffset)
+    }
+    if let count {
       // _cocoaStringUTF8Count gave us the scalar aligned count, but we still
       // need to compensate for sub-scalar indexing, e.g. if `i` is in the
       // middle of a two-byte UTF8 scalar.

stdlib/public/core/UnicodeHelpers.swift

@@ -247,10 +247,10 @@ extension _StringGuts {
   @_effects(releasenone)
   private func _getForeignCodeUnit(at i: Int) -> UInt16 {
 #if _runtime(_ObjC)
-    // Currently, foreign  means NSString
-    return _cocoaStringSubscript(_object.cocoaObject, i)
+    // Currently, foreign means NSString
+    return _object.withCocoaObject { _cocoaStringSubscript($0, i) }
 #else
-  fatalError("No foreign strings on Linux in this version of Swift")
+    fatalError("No foreign strings on Linux in this version of Swift")
 #endif
   }
 
@@ -386,11 +386,13 @@ extension _StringGuts {
     return withUnsafeTemporaryAllocation(
       of: UInt16.self, capacity: count
     ) { buffer in
-      _cocoaStringCopyCharacters(
-        from: self._object.cocoaObject,
-        range: start..<end,
-        into: buffer.baseAddress._unsafelyUnwrappedUnchecked
-      )
+      self._object.withCocoaObject {
+        _cocoaStringCopyCharacters(
+          from: $0,
+          range: start..<end,
+          into: buffer.baseAddress._unsafelyUnwrappedUnchecked
+        )
+      }
       return Character(String._uncheckedFromUTF16(UnsafeBufferPointer(buffer)))
     }
 #else