Merge pull request #14046 from milseman/string_guts_squash

StringGuts: New 2-word representation for String

Author: milseman

benchmark/utils/DriverUtils.swift

@@ -298,9 +298,9 @@ func internalMedian(_ inputs: [UInt64]) -> UInt64 {
 #if SWIFT_RUNTIME_ENABLE_LEAK_CHECKER
 
 @_silgen_name("_swift_leaks_startTrackingObjects")
-func startTrackingObjects(_: UnsafeMutableRawPointer) -> ()
+func startTrackingObjects(_: UnsafePointer<CChar>) -> ()
 @_silgen_name("_swift_leaks_stopTrackingObjects")
-func stopTrackingObjects(_: UnsafeMutableRawPointer) -> Int
+func stopTrackingObjects(_: UnsafePointer<CChar>) -> Int
 
 #endif
 
@@ -346,15 +346,14 @@ class SampleRunner {
   func run(_ name: String, fn: (Int) -> Void, num_iters: UInt) -> UInt64 {
     // Start the timer.
 #if SWIFT_RUNTIME_ENABLE_LEAK_CHECKER
-    var str = name
-    startTrackingObjects(UnsafeMutableRawPointer(str._core.startASCII))
+    name.withCString { p in startTrackingObjects(p) }
 #endif
     let start_ticks = timer.getTime()
     fn(Int(num_iters))
     // Stop the timer.
     let end_ticks = timer.getTime()
 #if SWIFT_RUNTIME_ENABLE_LEAK_CHECKER
-    stopTrackingObjects(UnsafeMutableRawPointer(str._core.startASCII))
+    name.withCString { p in stopTrackingObjects(p) }
 #endif
 
     // Compute the spent time and the scaling factor.

stdlib/public/SDK/Foundation/NSString.swift

@@ -23,8 +23,8 @@ public class NSSimpleCString {}
 public class NSConstantString {}
 
 // Called by the SwiftObject implementation.
-public func _convertStringToNSString(_ string: String) -> NSString {
-  return string._bridgeToObjectiveC()
+public func _getDescription<T>(_ x: T) -> NSString {
+  return String(reflecting: x)._bridgeToObjectiveC()
 }
 
 extension NSString : ExpressibleByStringLiteral {

stdlib/public/core/Arrays.swift.gyb

@@ -1232,7 +1232,8 @@ extension ${Self} : RangeReplaceableCollection, ArrayProtocol {
   /// element. Otherwise, `nil`.
   @_inlineable
   public var _baseAddressIfContiguous: UnsafeMutablePointer<Element>? {
-    return _buffer.firstElementAddressIfContiguous
+    @inline(__always) // FIXME(TODO: JIRA): Hack around test failure
+    get { return _buffer.firstElementAddressIfContiguous }
   }
 
 %if Self != 'Array': # // Array does not necessarily have contiguous storage

stdlib/public/core/Builtin.swift

@@ -259,6 +259,13 @@ public func unsafeDowncast<T : AnyObject>(_ x: AnyObject, to type: T.Type) -> T
   return Builtin.castReference(x)
 }
 
+@_inlineable // FIXME(sil-serialize-all)
+@_transparent
+public func _unsafeUncheckedDowncast<T : AnyObject>(_ x: AnyObject, to type: T.Type) -> T {
+  _sanityCheck(x is T, "invalid unsafeDowncast")
+  return Builtin.castReference(x)
+}
+
 import SwiftShims
 
 @_inlineable // FIXME(sil-serialize-all)
@@ -356,6 +363,14 @@ internal func _class_getInstancePositiveExtentSize(_ theClass: AnyClass) -> Int
 #endif
 }
 
+@_inlineable
+@_versioned
+internal
+func _isValidAddress(_ address: UInt) -> Bool {
+  // TODO: define (and use) ABI max valid pointer value
+  return address >= _swift_abi_LeastValidPointerValue
+}
+
 //===--- Builtin.BridgeObject ---------------------------------------------===//
 
 // TODO(<rdar://problem/34837023>): Get rid of superfluous UInt constructor
@@ -419,6 +434,155 @@ internal func _nonPointerBits(_ x: Builtin.BridgeObject) -> UInt {
 internal func _isObjCTaggedPointer(_ x: AnyObject) -> Bool {
   return (Builtin.reinterpretCast(x) & _objCTaggedPointerBits) != 0
 }
+@_inlineable // FIXME(sil-serialize-all)
+@_versioned
+@inline(__always)
+internal func _isObjCTaggedPointer(_ x: UInt) -> Bool {
+  return (x & _objCTaggedPointerBits) != 0
+}
+
+/// TODO: describe extras
+
+@_inlineable /*@_versioned*/ @inline(__always) public // FIXME
+func _isTaggedObject(_ x: Builtin.BridgeObject) -> Bool {
+  return _bitPattern(x) & _objCTaggedPointerBits != 0
+}
+@_inlineable /*@_versioned*/ @inline(__always) public // FIXME
+func _isNativePointer(_ x: Builtin.BridgeObject) -> Bool {
+  return (
+    _bitPattern(x) & (_objCTaggedPointerBits | _objectPointerIsObjCBit)
+  ) == 0
+}
+@_inlineable /*@_versioned*/ @inline(__always) public // FIXME
+func _isNonTaggedObjCPointer(_ x: Builtin.BridgeObject) -> Bool {
+  return !_isTaggedObject(x) && !_isNativePointer(x)
+}
+
+@_inlineable
+@_versioned
+@inline(__always)
+func _getNonTagBits(_ x: Builtin.BridgeObject) -> UInt {
+  // Zero out the tag bits, and leave them all at the top.
+  _sanityCheck(_isTaggedObject(x), "not tagged!")
+  return (_bitPattern(x) & ~_objCTaggedPointerBits)
+    >> _objectPointerLowSpareBitShift
+}
+
+// Values -> BridgeObject
+@inline(__always)
+@_inlineable
+public func _bridgeObject(fromNative x: AnyObject) -> Builtin.BridgeObject {
+  _sanityCheck(!_isObjCTaggedPointer(x))
+  let object = Builtin.castToBridgeObject(x, 0._builtinWordValue)
+  _sanityCheck(_isNativePointer(object))
+  return object
+}
+
+@inline(__always)
+@_inlineable
+public func _bridgeObject(
+  fromNonTaggedObjC x: AnyObject
+) -> Builtin.BridgeObject {
+  _sanityCheck(!_isObjCTaggedPointer(x))
+  let object = _makeObjCBridgeObject(x)
+  _sanityCheck(_isNonTaggedObjCPointer(object))
+  return object
+}
+
+@inline(__always)
+@_inlineable
+public func _bridgeObject(fromTagged x: UInt) -> Builtin.BridgeObject {
+  _sanityCheck(x & _objCTaggedPointerBits != 0)
+  let object: Builtin.BridgeObject = Builtin.reinterpretCast(x)
+  _sanityCheck(_isTaggedObject(object))
+  return object
+}
+
+@inline(__always)
+@_inlineable
+public func _bridgeObject(taggingPayload x: UInt) -> Builtin.BridgeObject {
+  let shifted = x &<< _objectPointerLowSpareBitShift
+  _sanityCheck(x == (shifted &>> _objectPointerLowSpareBitShift),
+    "out-of-range: limited bit range requires some zero top bits")
+  _sanityCheck(shifted & _objCTaggedPointerBits == 0,
+    "out-of-range: post-shift use of tag bits")
+  return _bridgeObject(fromTagged: shifted | _objCTaggedPointerBits)
+}
+
+// BridgeObject -> Values
+@inline(__always)
+@_inlineable
+public func _bridgeObject(toNative x: Builtin.BridgeObject) -> AnyObject {
+  _sanityCheck(_isNativePointer(x))
+  return Builtin.castReferenceFromBridgeObject(x)
+}
+
+@inline(__always)
+@_inlineable
+public func _bridgeObject(
+  toNonTaggedObjC x: Builtin.BridgeObject
+) -> AnyObject {
+  _sanityCheck(_isNonTaggedObjCPointer(x))
+  return Builtin.castReferenceFromBridgeObject(x)
+}
+
+@inline(__always)
+@_inlineable
+public func _bridgeObject(toTagged x: Builtin.BridgeObject) -> UInt {
+  _sanityCheck(_isTaggedObject(x))
+  let bits = _bitPattern(x)
+  _sanityCheck(bits & _objCTaggedPointerBits != 0)
+  return bits
+}
+@inline(__always)
+@_inlineable
+public func _bridgeObject(toTagPayload x: Builtin.BridgeObject) -> UInt {
+  return _getNonTagBits(x)
+}
+
+@inline(__always)
+@_inlineable
+public func _bridgeObject(
+  fromNativeObject x: Builtin.NativeObject
+) -> Builtin.BridgeObject {
+  return _bridgeObject(fromNative: _nativeObject(toNative: x))
+}
+
+//
+// NativeObject
+//
+
+@inline(__always)
+@_inlineable
+public func _nativeObject(fromNative x: AnyObject) -> Builtin.NativeObject {
+  _sanityCheck(!_isObjCTaggedPointer(x))
+  let native = Builtin.unsafeCastToNativeObject(x)
+  // _sanityCheck(native == Builtin.castToNativeObject(x))
+  return native
+}
+@inline(__always)
+@_inlineable
+public func _nativeObject(
+  fromBridge x: Builtin.BridgeObject
+) -> Builtin.NativeObject {
+  return _nativeObject(fromNative: _bridgeObject(toNative: x))
+}
+
+@inline(__always)
+@_inlineable
+public func _nativeObject(toNative x: Builtin.NativeObject) -> AnyObject {
+  return Builtin.castFromNativeObject(x)
+}
+
+// FIXME
+extension ManagedBufferPointer {
+  // FIXME: String Guts
+  @inline(__always)
+  @_inlineable
+  public init(_nativeObject buffer: Builtin.NativeObject) {
+    self._nativeBuffer = buffer
+  }
+}
 
 /// Create a `BridgeObject` around the given `nativeObject` with the
 /// given spare bits.

stdlib/public/core/CMakeLists.txt

@@ -122,18 +122,20 @@ set(SWIFTLIB_ESSENTIAL
   StringHashable.swift  # ORDER DEPENDENCY: Must precede String.swift
   String.swift
   StringBridge.swift
-  StringBuffer.swift
   StringComparable.swift
-  StringCore.swift
+  StringGuts.swift
+  StringObject.swift
   StringIndex.swift
   StringInterpolation.swift
   StringLegacy.swift
   StringRangeReplaceableCollection.swift.gyb
+  StringStorage.swift
   StringSwitch.swift
   StringIndexConversions.swift
   StringUnicodeScalarView.swift
   StringUTF16.swift
   StringUTF8.swift
+  StringVariant.swift
   Substring.swift.gyb
   SwiftNativeNSArray.swift
   ThreadLocalStorage.swift
@@ -142,6 +144,8 @@ set(SWIFTLIB_ESSENTIAL
   UnicodeEncoding.swift
   UnicodeParser.swift
   Unmanaged.swift
+  UnmanagedOpaqueString.swift
+  UnmanagedString.swift
   UnsafeBitMap.swift
   UnsafeBufferPointer.swift.gyb
   UnsafeRawBufferPointer.swift.gyb
@@ -152,6 +156,7 @@ set(SWIFTLIB_ESSENTIAL
   UTF16.swift
   UTF32.swift
   Unicode.swift # ORDER DEPENDENCY: must follow new unicode support
+  StringGraphemeBreaking.swift # ORDER DEPENDENCY: Must follow UTF16.swift
   ValidUTF8Buffer.swift
   WriteBackMutableSlice.swift
   )

stdlib/public/core/CString.swift

@@ -197,9 +197,7 @@ internal func _decodeCString<Encoding : _UnicodeEncoding>(
   let buffer = UnsafeBufferPointer<Encoding.CodeUnit>(
     start: cString, count: length)
 
-  let (stringBuffer, hadError) = _StringBuffer.fromCodeUnits(
+  let (guts, hadError) = _StringGuts.fromCodeUnits(
     buffer, encoding: encoding, repairIllFormedSequences: isRepairing)
-  return stringBuffer.map {
-    (result: String(_storage: $0), repairsMade: hadError)
-  }
+  return guts.map { (result: String($0), repairsMade: hadError) }
 }

stdlib/public/core/CTypes.swift

@@ -229,7 +229,7 @@ extension CVaListPointer : CustomDebugStringConvertible {
 @_inlineable
 internal func _memcpy(
   dest destination: UnsafeMutableRawPointer,
-  src: UnsafeMutableRawPointer,
+  src: UnsafeRawPointer,
   size: UInt
 ) {
   let dest = destination._rawValue