Merge pull request #18456 from milseman/internalable

[string] Internalize many faux-testable declarations

Author: milseman

stdlib/public/core/CMakeLists.txt

@@ -134,13 +134,14 @@ set(SWIFTLIB_ESSENTIAL
   StringObject.swift
   StringProtocol.swift
   StringIndex.swift
+  StringIndexConversions.swift
   StringInterpolation.swift
   StringLegacy.swift
+  StringNormalization.swift
   StringRangeReplaceableCollection.swift
   StringStorage.swift
   StringSwitch.swift
-  StringIndexConversions.swift
-  StringNormalization.swift
+  StringTesting.swift
   StringUnicodeScalarView.swift
   StringUTF16View.swift
   StringUTF8View.swift

stdlib/public/core/GroupInfo.json

@@ -32,6 +32,7 @@
     "StringRangeReplaceableCollection.swift",
     "StringStorage.swift",
     "StringSwitch.swift",
+    "StringTesting.swift",
     "StringUTF16View.swift",
     "StringUTF8View.swift",
     "StringUnicodeScalarView.swift",

stdlib/public/core/SmallString.swift

@@ -31,8 +31,8 @@ func unsupportedOn32bit() -> Never { _conditionallyUnreachable() }
 
 #else
 @_fixed_layout
-public // @testable
-struct _SmallUTF8String {
+@usableFromInline
+internal struct _SmallUTF8String {
   @usableFromInline
   typealias _RawBitPattern = (low: UInt, high: UInt)
 
@@ -61,12 +61,11 @@ struct _SmallUTF8String {
 //
 extension _SmallUTF8String {
   @inlinable
-  public // @testable
-  static var capacity: Int { return 15 }
+  static internal var capacity: Int { return 15 }
 
 #if _runtime(_ObjC)
-  public // @testable
-  init?(_cocoaString cocoa: _CocoaString) {
+  @usableFromInline
+  internal init?(_cocoaString cocoa: _CocoaString) {
 #if arch(i386) || arch(arm)
     return nil // Never form small strings on 32-bit
 #else
@@ -89,8 +88,7 @@ extension _SmallUTF8String {
 #endif // _runtime(_ObjC)
 
   @inlinable
-  public // @testable
-  init?<C: RandomAccessCollection>(_ codeUnits: C) where C.Element == UInt16 {
+  internal init?<C: RandomAccessCollection>(_ codeUnits: C) where C.Element == UInt16 {
 #if arch(i386) || arch(arm)
     return nil // Never form small strings on 32-bit
 #else

stdlib/public/core/String.swift

@@ -540,7 +540,8 @@ extension String {
 /// [equivalence]: http://www.unicode.org/glossary/#canonical_equivalent
 @_fixed_layout
 public struct String {
-  public var _guts: _StringGuts
+  public // SPI(Foundation)
+  var _guts: _StringGuts
 
   /// Creates an empty string.
   ///
@@ -555,8 +556,7 @@ public struct String {
   }
 
   @inlinable // FIXME(sil-serialize-all)
-  public // @testable
-  init(_ _guts: _StringGuts) {
+  internal init(_ _guts: _StringGuts) {
     self._guts = _guts
   }
 }

stdlib/public/core/StringBridge.swift

@@ -136,8 +136,8 @@ internal func _bridgeASCIICocoaString(
   return length == numCharWritten ? count : nil
 }
 
-public // @testable
-func _bridgeToCocoa(_ small: _SmallUTF8String) -> _CocoaString {
+@usableFromInline
+internal func _bridgeToCocoa(_ small: _SmallUTF8String) -> _CocoaString {
   return small.withUTF8CodeUnits { bufPtr in
       return _swift_stdlib_CFStringCreateWithBytes(
           nil, bufPtr.baseAddress._unsafelyUnwrappedUnchecked,

stdlib/public/core/StringGuts.swift

@@ -100,8 +100,7 @@ extension _StringGuts {
 
   @inlinable
   @inline(__always)
-  public // @testable
-  mutating func _isUniqueNative() -> Bool {
+  internal mutating func _isUniqueNative() -> Bool {
     guard _isNative else { return false }
     // Note that the isUnique test must be in a separate statement;
     // `isNative && _isUnique` always evaluates to false in debug builds,
@@ -121,8 +120,7 @@ extension _StringGuts {
 
 extension _StringGuts {
   @inlinable
-  public // @testable
-  var isASCII: Bool {
+  internal var isASCII: Bool {
     @inline(__always) get { return _object.isContiguousASCII }
   }
 
@@ -135,40 +133,32 @@ extension _StringGuts {
   }
 
   @inlinable
-  public // @testable
-  var _isNative: Bool {
+  internal var _isNative: Bool {
     return _object.isNative
   }
 
-#if _runtime(_ObjC)
   @inlinable
-  public // @testable
-  var _isCocoa: Bool {
+  internal var _isCocoa: Bool {
     return _object.isCocoa
   }
-#endif
 
   @inlinable
-  public // @testable
-  var _isUnmanaged: Bool {
+  internal var _isUnmanaged: Bool {
     return _object.isUnmanaged
   }
 
   @inlinable
-  public // @testable
-  var _isSmall: Bool {
+  internal var _isSmall: Bool {
     return _object.isSmall
   }
 
   @inlinable
-  public // @testable
-  var _owner: AnyObject? {
+  internal var _owner: AnyObject? {
     return _object.owner
   }
 
   @inlinable
-  public // @testable
-  var isSingleByte: Bool {
+  internal var isSingleByte: Bool {
     // FIXME: Currently used to sometimes mean contiguous ASCII
     return _object.isSingleByte
   }
@@ -180,8 +170,7 @@ extension _StringGuts {
   }
 
   @inlinable
-  public // @testable
-  var byteWidth: Int {
+  internal var byteWidth: Int {
     return _object.byteWidth
   }
 
@@ -215,8 +204,7 @@ extension _StringGuts {
 extension _StringGuts {
   @inlinable
   @inline(__always)
-  public // @testable
-  init() {
+  internal init() {
     self.init(object: _StringObject(), otherBits: 0)
     _invariantCheck()
   }
@@ -474,8 +462,8 @@ extension _StringGuts {
   /// Return the object identifier for the reference counted heap object
   /// referred to by this string (if any). This is useful for testing allocation
   /// behavior.
-  public // @testable
-  var _objectIdentifier: ObjectIdentifier? {
+  @usableFromInline
+  internal var _objectIdentifier: ObjectIdentifier? {
     if _object.isNative {
       return ObjectIdentifier(_object.nativeRawStorage)
     }
@@ -793,8 +781,7 @@ extension _StringGuts {
   }
 
   @inlinable
-  public // @testable
-  var count: Int {
+  internal var count: Int {
     if _slowPath(!_hasStoredCount) {
       return _nonStoredCount
     }
@@ -823,8 +810,7 @@ extension _StringGuts {
   }
 
   @inlinable
-  public // @testable
-  var capacity: Int {
+  internal var capacity: Int {
     if _fastPath(_object.isNative) {
       return _object.nativeRawStorage.capacity
     }
@@ -839,8 +825,7 @@ extension _StringGuts {
 
   /// Get the UTF-16 code unit stored at the specified position in this string.
   @inlinable // FIXME(sil-serialize-all)
-  public // @testable
-  subscript(position: Int) -> UTF16.CodeUnit {
+  internal subscript(position: Int) -> UTF16.CodeUnit {
     if _slowPath(_isOpaque) {
       return _opaquePosition(position)
     }

stdlib/public/core/StringTesting.swift

@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// Declarations to enable ease-of-testing
+
+public // @testable
+struct _StringRepresentation {
+  public var _isASCII: Bool
+  public var _count: Int
+  public var _capacity: Int
+
+  public enum _Form {
+    case _small
+    case _cocoa(object: AnyObject)
+    case _native(object: AnyObject)
+    case _immortal(address: UInt)
+  }
+  public var _form: _Form
+
+  public var _objectIdentifier: ObjectIdentifier? {
+    switch _form {
+      case ._cocoa(let object): return ObjectIdentifier(object)
+      case ._native(let object): return ObjectIdentifier(object)
+      default: return nil
+    }
+  }
+}
+
+extension String {
+  public // @testable
+  func _classify() -> _StringRepresentation {
+    var result = _StringRepresentation(
+      _isASCII: _guts._isASCIIOrSmallASCII,
+      _count: _guts.count,
+      _capacity: _guts.capacity,
+      _form: ._small
+    )
+    if _guts._isSmall {
+      return result
+    }
+    if _guts._isNative {
+      result._form = ._native(object: _guts._owner!)
+      return result
+    }
+    if _guts._isCocoa {
+      result._form = ._cocoa(object: _guts._owner!)
+      return result
+    }
+    if _guts._isUnmanaged {
+      result._form = ._immortal(
+        address: UInt(bitPattern: _guts._unmanagedRawStart))
+      return result
+    }
+    fatalError()
+  }
+}
+

test/stdlib/BridgedObjectDebuggerSupport.swift

@@ -30,7 +30,11 @@ func debugVal<T>(_ x: inout T) -> String {
 
 // Check if @x uses the small-string or Cocoa representations.
 func hasSmallStringOrCocoaVariant(_ x: String) -> Bool {
-  return x._guts._isCocoa || x._guts._isSmall
+  switch x._classify()._form {
+    case ._small: return true
+    case ._cocoa: return true
+    default: return false
+  }
 }
 
 StringForPrintObjectTests.test("Basic") {

test/stdlib/Character.swift

@@ -256,8 +256,9 @@ func checkUnicodeScalars(_ s: String) {
 }
 
 func checkRepresentation(_ s: String) {
+  let utf16 = Array(s.utf16)
   let expectSmall
-    = s.utf16.count < 4 || s.utf16.count == 4 && s._guts[3] < 0x8000
+    = utf16.count < 4 || utf16.count == 4 && utf16[3] < 0x8000
   let isSmall = isSmallRepresentation(s)
 
   let expectedSize = expectSmall ? "small" : "large"