Handle long tagged NSStrings

Author: Catfish-Man

stdlib/public/core/SmallString.swift

@@ -353,13 +353,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/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,60 @@
+#import <string.h>
+#import "NSSlowTaggedLocalizedString.h"
+#import <dlfcn.h>
+
+@implementation NSSlowTaggedLocalizedString
+
+uintptr_t *obfuscator;
+void (*_objc_registerTaggedPointerClass)(uint16_t tag, Class cls);
+
++ (instancetype) createTestString {
+#if __LP64__
+  if (obfuscator == NULL) {
+    obfuscator = dlsym(RTLD_DEFAULT, "objc_debug_taggedpointer_obfuscator");
+    *obfuscator = 0;
+    _objc_registerTaggedPointerClass = dlsym(RTLD_DEFAULT, "_objc_registerTaggedPointerClass");
+    (*_objc_registerTaggedPointerClass)(0, self); //0 would be unsafe if we loaded Foundation, but we aren't doing that
+  }
+#if __x86_64__
+  return (id)(void *)(uintptr_t)1; //x86_64 uses the LSB as the tag bit, and we want tag 0
+#else
+  return (id)(void *)(uintptr_t)(1llu << 63); //MSB everywhere else
+#endif
+#else
+  return nil;
+#endif
+}
+
+static const char *contents = NULL;
+
++ (void) setContents: (const char *)newContents {
+  const char *oldContents = contents;
+  contents = strdup(newContents);
+  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]) {
+    //throw the appropriate exception
+    abort();
+  }
+  return (uint16_t)contents[index];
+}
+
+- (void *) _fastCharacterContents {
+  return nil;
+}
+
+@end

test/stdlib/Inputs/NSSlowTaggedLocalizedString/module.map

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

test/stdlib/NSSlowTaggedLocalizedString.swift

@@ -0,0 +1,32 @@
+// RUN: mkdir -p %t
+// RUN: %target-clang -fobjc-arc %S/Inputs/NSSlowTaggedLocalizedString/NSSlowTaggedLocalizedString.m -fno-objc-arc -c -o %t/NSSlowTaggedLocalizedString.o
+// RUN: %target-build-swift -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")
+
+longTaggedTests.test("EqualLongTagged") {
+  var native = "Send Message to different Team"
+  let longTagged = NSSlowTaggedLocalizedString.createTestString()
+  NSSlowTaggedLocalizedString.setContents(&native)
+  defer {
+    NSSlowTaggedLocalizedString.setContents(nil)
+  }
+  let reverseBridged = native._guts._object.objCBridgeableObject
+  expectEqual(
+    reverseBridged.isEqual(to: longTagged),
+    longTagged.isEqual(to: reverseBridged)
+  )
+}
+
+runAllTests()
+