Add support for compiling without the Objective-C runtime. (swiftlang#17)

* Restore Linux support

On Linux, Cocoa strings aren't supported; however, we still support opaque strings via the new _OpaqueString protocol, whose requirements approximate a minimal NSString API. (One use of this would be to allow NSString from the open source Foundation lib to be bridged directly. This isn't implemented yet.)

_OpaqueString's interface is not a subset of NSString; in particular, the method getCharacters(_:, range:) is replaced with copyCodeUnits(from:,into:), to get around dealing with _SwiftNSRange.

_OpaqueString is not yet supported on Apple platforms.

* _NSStringCore: Fix length requirement

Be consistent with Foundation; NSString.length is imported/defined as `var length: Int`, not `func length() -> UInt`.

* _StringGuts: Add file header

* _StringGuts: Add _objectIdentifier property, for testing allocation behavior

Also, update tests that used to rely on _underlyingCocoaString -- it is only available with the Objective-C runtime.

* Fix lowercased()/uppercased() on Linux.

* [test] Relax check for realloc behavior on widening String storage

Widening a String from single-byte to two-byte storage may increase available capacity.

* Add deprecated compatibility definitions for SPI used by swift-corelibs-foundation

Author: lorentey

stdlib/public/core/String.swift

@@ -958,16 +958,14 @@ extension String {
     into processCodeUnit: (Encoding.CodeUnit) -> Void
   ) {
     if _slowPath(_guts._isOpaque) {
-#if _runtime(_ObjC)
       let opaque = _guts._asOpaque()
       var i = opaque.makeIterator()
       Unicode.UTF16.ForwardParser._parse(&i) {
         Encoding._transcode($0, from: UTF16.self).forEach(processCodeUnit)
       }
-#else
-      _sanityCheckFailure("encode: non-native string without objc runtime")
-#endif
-    } else if _guts.isASCII {
+      return
+    }
+    if _guts.isASCII {
       let ascii = _guts._unmanagedASCIIView
       if encoding == Unicode.ASCII.self
       || encoding == Unicode.UTF8.self
@@ -983,12 +981,12 @@ extension String {
             Unicode.Scalar(_unchecked: UInt32(b))).forEach(processCodeUnit)
         }
       }
-    } else {
-      let utf16 = _guts._unmanagedUTF16View
-      var i = utf16.makeIterator()
-      Unicode.UTF16.ForwardParser._parse(&i) {
-        Encoding._transcode($0, from: UTF16.self).forEach(processCodeUnit)
-      }
+      return
+    }
+    let utf16 = _guts._unmanagedUTF16View
+    var i = utf16.makeIterator()
+    Unicode.UTF16.ForwardParser._parse(&i) {
+      Encoding._transcode($0, from: UTF16.self).forEach(processCodeUnit)
     }
   }
 }
@@ -1021,14 +1019,16 @@ extension String {
       self = other
       return
     }
+    defer { _fixLifetime(other) }
+    if _slowPath(other._guts._isOpaque) {
+      self._guts.append(other._guts._asOpaque())
+      return
+    }
     if other._guts.isASCII {
       self._guts.append(other._guts._unmanagedASCIIView)
-    } else if _slowPath(other._guts._isOpaque) {
-      self._guts.append(other._guts._asOpaque())
-    } else {
-      self._guts.append(other._guts._unmanagedUTF16View)
+      return
     }
-    _fixLifetime(other)
+    self._guts.append(other._guts._unmanagedUTF16View)
   }
 
   /// Appends the given Unicode scalar to the string.
@@ -1205,54 +1205,58 @@ internal func _stdlib_NSStringUppercaseString(_ str: AnyObject) -> _CocoaString
 @_inlineable // FIXME(sil-serialize-all)
 @_versioned // FIXME(sil-serialize-all)
 internal func _nativeUnicodeLowercaseString(_ str: String) -> String {
-  defer { _fixLifetime(str) }
-  let utf16 = str._guts._unmanagedUTF16View
+  let guts = str._guts._extractContiguousUTF16()
+  defer { _fixLifetime(guts) }
+  let utf16 = guts._unmanagedUTF16View
   var storage = _SwiftStringStorage<UTF16.CodeUnit>.create(
     capacity: utf16.count,
     count: utf16.count)
 
   // Try to write it out to the same length.
   let z = _swift_stdlib_unicode_strToLower(
-    dest, Int32(utf16.count), // FIXME: handle overflow case
+    storage.start, Int32(storage.capacity), // FIXME: handle overflow case
     utf16.start, Int32(utf16.count))
   let correctSize = Int(z)
 
   // If more space is needed, do it again with the correct buffer size.
-  if correctSize != utf16.count {
+  if correctSize > storage.capacity {
     storage = _SwiftStringStorage<UTF16.CodeUnit>.create(
       capacity: correctSize,
       count: correctSize)
     _swift_stdlib_unicode_strToLower(
-      dest, Int32(utf16.count), // FIXME: handle overflow case
+      storage.start, Int32(storage.capacity), // FIXME: handle overflow case
       utf16.start, Int32(utf16.count))
   }
+  storage.count = correctSize
   return String(_storage: storage)
 }
 
 @_inlineable // FIXME(sil-serialize-all)
 @_versioned // FIXME(sil-serialize-all)
 internal func _nativeUnicodeUppercaseString(_ str: String) -> String {
-  defer { _fixLifetime(str) }
-  let utf16 = str._guts._unmanagedUTF16View
+  let guts = str._guts._extractContiguousUTF16()
+  defer { _fixLifetime(guts) }
+  let utf16 = guts._unmanagedUTF16View
   var storage = _SwiftStringStorage<UTF16.CodeUnit>.create(
     capacity: utf16.count,
     count: utf16.count)
 
   // Try to write it out to the same length.
   let z = _swift_stdlib_unicode_strToUpper(
-    dest, Int32(utf16.count), // FIXME: handle overflow case
+    storage.start, Int32(storage.capacity), // FIXME: handle overflow case
     utf16.start, Int32(utf16.count))
   let correctSize = Int(z)
 
   // If more space is needed, do it again with the correct buffer size.
-  if correctSize != utf16.count {
+  if correctSize > storage.capacity {
     storage = _SwiftStringStorage<UTF16.CodeUnit>.create(
       capacity: correctSize,
       count: correctSize)
     _swift_stdlib_unicode_strToUpper(
-      dest, Int32(utf16.count), // FIXME: handle overflow case
+      storage.start, Int32(storage.capacity), // FIXME: handle overflow case
       utf16.start, Int32(utf16.count))
   }
+  storage.count = correctSize
   return String(_storage: storage)
 }
 #endif
@@ -1316,9 +1320,9 @@ extension String {
             _asciiUpperCaseTable &>>
             UInt64(((value &- 1) & 0b0111_1111) &>> 1)
           let add = (isUpper & 0x1) &<< 5
-          // Since we are left with either 0x0 or 0x20, we can safely truncate to
-          // a UInt8 and add to our ASCII value (this will not overflow numbers in
-          // the ASCII range).
+          // Since we are left with either 0x0 or 0x20, we can safely truncate
+          // to a UInt8 and add to our ASCII value (this will not overflow
+          // numbers in the ASCII range).
           storage._value.start[i] = value &+ UInt8(truncatingIfNeeded: add)
         }
       }

stdlib/public/core/StringBridge.swift

@@ -205,7 +205,7 @@ public protocol _NSStringCore : _NSCopying /* _NSFastEnumeration */ {
   // NSString subclass.
 
   @objc(length)
-  func length() -> UInt
+  var length: Int { get }
 
   @objc(characterAtIndex:)
   func character(at index: Int) -> UInt16
@@ -269,8 +269,8 @@ public final class _NSContiguousString : _SwiftNativeNSString, _NSStringCore {
 
   @_inlineable
   @objc(length)
-  public func length() -> UInt {
-    return UInt(bitPattern: _guts.count)
+  public var length: Int {
+    return _guts.count
   }
 
   @_inlineable
@@ -366,4 +366,18 @@ extension String {
     return _stdlib_binary_bridgeToObjectiveCImpl()
   }
 }
+
+#else // !_runtime(_ObjC)
+
+@_fixed_layout // FIXME(sil-serialize-all)
+public class _SwiftNativeNSString {
+  @_inlineable // FIXME(sil-serialize-all)
+  @_versioned // FIXME(sil-serialize-all)
+  internal init() {}
+  @_inlineable // FIXME(sil-serialize-all)
+  deinit {}
+}
+
+public protocol _NSStringCore: class {}
+
 #endif

stdlib/public/core/StringComparable.swift

@@ -126,7 +126,7 @@ extension _StringGuts {
       return Int(_stdlib_compareNSStringDeterministicUnicodeCollation(l, r))
     }
 #else
-    switch (_guts.isASCII, rhs._guts.isASCII) {
+    switch (left.isASCII, right.isASCII) {
     case (true, false):
       let l = left._unmanagedASCIIView[leftRange]
       let r = right._unmanagedUTF16View[rightRange]
@@ -135,7 +135,8 @@ extension _StringGuts {
           r.start, Int32(r.count)))
     case (false, true):
       // Just invert it and recurse for this case.
-      return -rhs._compareDeterministicUnicodeCollation(self)
+      return -_compareDeterministicUnicodeCollation(
+        right, rightRange, to: left, leftRange)
     case (false, false):
       let l = left._unmanagedUTF16View[leftRange]
       let r = right._unmanagedUTF16View[rightRange]