Handle long tagged NSStrings

Author: Catfish-Man

stdlib/public/core/SmallString.swift

@@ -346,13 +346,22 @@ extension _SmallString {
   //
   @_effects(readonly) // @opaque
   @usableFromInline // testable
-  internal init(taggedCocoa cocoa: AnyObject) {
+  internal init?(taggedCocoa cocoa: AnyObject) {
     self.init()
+    var success = true
     self.withMutableCapacity {
-      let len = _bridgeTagged(cocoa, intoUTF8: $0)
-      _internalInvariant(len != nil && len! <= _SmallString.capacity,
-        "Internal invariant violated: large tagged NSStrings")
-      return len._unsafelyUnwrappedUnchecked
+      /*
+       For regular NSTaggedPointerStrings we will always succeed here, but
+       tagged NSLocalizedStrings may not fit in a SmallString
+       */
+      if let len = _bridgeTagged(cocoa, intoUTF8: $0) {
+        return len
+      }
+      success = false
+      return 0
+    }
+    if !success {
+      return nil
     }
     self._invariantCheck()
   }

stdlib/public/core/StringBridge.swift

@@ -335,8 +335,9 @@ internal enum _KnownCocoaString {
 #if !(arch(i386) || arch(arm) || arch(arm64_32))
 
 // Resiliently write a tagged _CocoaString's contents into a buffer.
-// TODO: move this to the Foundation overlay and reimplement it with
-// _NSTaggedPointerStringGetBytes
+// The Foundation overlay takes care of bridging tagged pointer strings before
+// they reach us, but this may still be called by older code, or by strings
+// entering our domain via the arguments to -isEqual:, etc...
 @_effects(releasenone) // @opaque
 internal func _bridgeTagged(
   _ cocoa: _CocoaString,
@@ -370,8 +371,11 @@ private func _withCocoaASCIIPointer<R>(
     if requireStableAddress {
       return nil // tagged pointer strings don't support _fastCStringContents
     }
-    let tmp = _StringGuts(_SmallString(taggedCocoa: str))
-    return tmp.withFastUTF8 { work($0.baseAddress._unsafelyUnwrappedUnchecked) }
+    if let smol = _SmallString(taggedCocoa: str) {
+      return _StringGuts(smol).withFastUTF8 {
+        work($0.baseAddress._unsafelyUnwrappedUnchecked)
+      }
+    }
   }
   #endif
   defer { _fixLifetime(str) }
@@ -503,7 +507,11 @@ internal func _bridgeCocoaString(_ cocoaString: _CocoaString) -> _StringGuts {
       cocoaString, to: __SharedStringStorage.self).asString._guts
 #if !(arch(i386) || arch(arm) || arch(arm64_32))
   case .tagged:
-    return _StringGuts(_SmallString(taggedCocoa: cocoaString))
+    // Foundation should be taking care of tagged pointer strings before they
+    // reach here, so the only ones reaching this point should be back deployed,
+    // which will never have tagged pointer strings that aren't small, hence
+    // the force unwrap here.
+    return _StringGuts(_SmallString(taggedCocoa: cocoaString)!)
 #if arch(arm64)
   case .constantTagged:
     let taggedContents = getConstantTaggedCocoaContents(cocoaString)!
@@ -530,7 +538,11 @@ internal func _bridgeCocoaString(_ cocoaString: _CocoaString) -> _StringGuts {
 
 #if !(arch(i386) || arch(arm) || arch(arm64_32))
     if _isObjCTaggedPointer(immutableCopy) {
-      return _StringGuts(_SmallString(taggedCocoa: immutableCopy))
+      // Copying a tagged pointer can produce a tagged pointer, but only if it's
+      // small enough to definitely fit in a _SmallString
+      return _StringGuts(
+        _SmallString(taggedCocoa: immutableCopy).unsafelyUnwrapped
+      )
     }
 #endif
 

test/api-digester/stability-stdlib-abi-without-asserts.test

@@ -65,6 +65,8 @@ Protocol CodingKey has added inherited protocol Sendable
 Protocol CodingKey has generic signature change from <Self : Swift.CustomDebugStringConvertible, Self : Swift.CustomStringConvertible> to <Self : Swift.CustomDebugStringConvertible, Self : Swift.CustomStringConvertible, Self : Swift.Sendable>
 Protocol Error has added inherited protocol Sendable
 Protocol Error has generic signature change from to <Self : Swift.Sendable>
+Constructor _SmallString.init(taggedCocoa:) has mangled name changing from 'Swift._SmallString.init(taggedCocoa: Swift.AnyObject) -> Swift._SmallString' to 'Swift._SmallString.init(taggedCocoa: Swift.AnyObject) -> Swift.Optional<Swift._SmallString>'
+Constructor _SmallString.init(taggedCocoa:) has return type change from Swift._SmallString to Swift._SmallString?
 Enum Never has added a conformance to an existing protocol Identifiable
 
 // These haven't actually been removed; they are simply marked unavailable.

test/stdlib/Inputs/NSSlowTaggedLocalizedString/NSSlowTaggedLocalizedString.h

@@ -0,0 +1,10 @@
+#import <objc/objc.h>
+#import <objc/NSObject.h>
+
+
+@interface NSSlowTaggedLocalizedString : NSObject
+
++ (instancetype) createTestString;
++ (void) setContents: (const char *)newContents;
+
+@end

test/stdlib/Inputs/NSSlowTaggedLocalizedString/NSSlowTaggedLocalizedString.m

@@ -0,0 +1,116 @@
+#import <string.h>
+#import "NSSlowTaggedLocalizedString.h"
+#import <dlfcn.h>
+#import <objc/runtime.h>
+#import <Foundation/Foundation.h>
+
+/*
+ This horrific mess is simulating the new-in-macOS-Ventura tagged pointer strings,
+ which can have lengths >15 characters, which can cause problems in SmallString,
+ which used to assume that would never happen. Once CI is running on Ventura or
+ later, this can be rewritten to use a regular NSLocalizedString.
+ */
+
+@implementation NSSlowTaggedLocalizedString
+
++ (instancetype) createTestString {
+#if __LP64__
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    [[[NSString alloc] init] release]; //Make sure NSString is initialized
+    Class tagClass = objc_lookUpClass("NSTaggedPointerString");
+    Class ourClass = [NSSlowTaggedLocalizedString class];
+    
+    Method fastCString = class_getInstanceMethod(ourClass, @selector(_fastCStringContents:));
+    class_replaceMethod(tagClass, @selector(_fastCStringContents:), method_getImplementation(fastCString), method_getTypeEncoding(fastCString));
+    
+    Method length = class_getInstanceMethod(ourClass, @selector(length));
+    class_replaceMethod(tagClass, @selector(length), method_getImplementation(length), method_getTypeEncoding(length));
+    
+    Method charIndex = class_getInstanceMethod(ourClass, @selector(characterAtIndex:));
+    class_replaceMethod(tagClass, @selector(characterAtIndex:), method_getImplementation(charIndex), method_getTypeEncoding(charIndex));
+    
+    Method fastChars = class_getInstanceMethod(ourClass, @selector(_fastCharacterContents));
+    class_replaceMethod(tagClass, @selector(_fastCharacterContents), method_getImplementation(fastChars), method_getTypeEncoding(fastChars));
+    
+    Method retain = class_getInstanceMethod(ourClass, @selector(retain));
+    class_replaceMethod(tagClass, @selector(retain), method_getImplementation(retain), method_getTypeEncoding(retain));
+    
+    Method release = class_getInstanceMethod(ourClass, @selector(release));
+    class_replaceMethod(tagClass, @selector(release), method_getImplementation(release), method_getTypeEncoding(release));
+    
+    Method typeID = class_getInstanceMethod(ourClass, @selector(_cfTypeID));
+    class_replaceMethod(tagClass, @selector(_cfTypeID), method_getImplementation(typeID), method_getTypeEncoding(typeID));
+    
+    Method description = class_getInstanceMethod(ourClass, @selector(description));
+    class_replaceMethod(tagClass, @selector(description), method_getImplementation(description), method_getTypeEncoding(description));
+    
+    Method getBytes = class_getInstanceMethod(ourClass, @selector(getBytes:maxLength:usedLength:encoding:options:range:remainingRange:));
+    class_replaceMethod(tagClass, @selector(getBytes:maxLength:usedLength:encoding:options:range:remainingRange:), method_getImplementation(getBytes), method_getTypeEncoding(getBytes));
+  });
+  return (NSSlowTaggedLocalizedString *)(void *)CFStringCreateWithCString(NULL, "a", kCFStringEncodingASCII); //make a tagged pointer string
+#else
+  return nil;
+#endif
+}
+
+static const char *contents = NULL;
+
++ (void) setContents: (const char *)newContents {
+  const char *oldContents = contents;
+  if (newContents) {
+    contents = strdup(newContents);
+  } else {
+    contents = NULL;
+  }
+  free((void *)oldContents);
+}
+
+- (const char *)_fastCStringContents:(BOOL)nullTerminationRequired {
+  return contents;
+}
+
+- (uint64_t)length {
+  return strlen(contents);
+}
+
+- (id)copyWithZone:(id)unused {
+  return self;
+}
+
+- (uint16_t)characterAtIndex:(NSUInteger)index {
+  if (index >= [self length]) {
+    abort();
+  }
+  return (uint16_t)contents[index];
+}
+
+- (void *) _fastCharacterContents {
+  return nil;
+}
+
+- (id) retain { return self; }
+- (oneway void) release {}
+
+- (uint64_t)_cfTypeID {
+  return 7; //CFString
+}
+
+- (id) description {
+  return self;
+}
+
+- (BOOL)getBytes:(void *)buffer maxLength:(uint64_t)max usedLength:(uint64_t *)used encoding:(uint64_t)encoding options:(uint64_t)options range:(NSRange)range remainingRange:(NSRange *)leftover {
+  assert(encoding == 1 /* ASCII */ || encoding == 4 /* UTF8 */);
+  strncpy(buffer, contents, max);
+  if (strlen(contents) > max) {
+    leftover->location = max;
+    leftover->length = strlen(contents) - max;
+    return false;
+  }
+  leftover->location = 0;
+  leftover->length = 0;
+  return true;
+}
+
+@end

test/stdlib/Inputs/NSSlowTaggedLocalizedString/module.map

@@ -0,0 +1,3 @@
+module NSSlowTaggedLocalizedString {
+  header "NSSlowTaggedLocalizedString.h"
+}

test/stdlib/NSSlowTaggedLocalizedString.swift

@@ -0,0 +1,38 @@
+// RUN: mkdir -p %t
+// RUN: %target-clang %S/Inputs/NSSlowTaggedLocalizedString/NSSlowTaggedLocalizedString.m -fno-objc-arc -c -o %t/NSSlowTaggedLocalizedString.o
+// RUN: %target-build-swift -g -parse-stdlib -Xfrontend -disable-access-control -I %S/Inputs/NSSlowTaggedLocalizedString/ %t/NSSlowTaggedLocalizedString.o %s -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out
+
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+
+import NSSlowTaggedLocalizedString
+import Swift
+
+import StdlibUnittest
+
+let longTaggedTests = TestSuite("NonContiguousTaggedStrings")
+var constant = "Send Message to different Team"
+
+func runEqualLongTagged() {
+  let native = constant.withUTF8 { String(decoding: $0, as: UTF8.self) }
+  let longTagged = NSSlowTaggedLocalizedString.createTest()!
+  constant.withCString {
+    NSSlowTaggedLocalizedString.setContents($0)
+  }
+  defer {
+    NSSlowTaggedLocalizedString.setContents(nil)
+  }
+  let reverseBridged = unsafeBitCast(native._guts._object.largeAddressBits, to: AnyObject.self)
+  let eq = reverseBridged.isEqual(to: longTagged)
+  expectEqual(eq, 1)
+  _fixLifetime(native)
+}
+
+longTaggedTests.test("EqualLongTagged") {
+  runEqualLongTagged()
+}
+
+runAllTests()
+