[stdlib][SE-0089] Finish off Lossless String Conversion

benchmark/single-source/unit-tests/ObjectiveCBridging.swift

@@ -73,7 +73,7 @@ public func run_ObjectiveCBridgeFromNSStringForced(_ N: Int) {
 
 @inline(never)
 func testObjectiveCBridgeToNSString() {
-  let nativeString = String("Native")
+  let nativeString = "Native"
 
   var s: NSString?
   for _ in 0 ..< 10_000 {

stdlib/private/StdlibCollectionUnittest/CheckCollectionType.swift.gyb

@@ -561,7 +561,7 @@ extension TestSuite {
       return makeCollectionOfEquatable(elements.map(wrapValueIntoEquatable))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
     //===------------------------------------------------------------------===//
     // generate()
@@ -1209,7 +1209,7 @@ extension TestSuite {
       return makeCollection(elements.map(wrapValue))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
     // FIXME: swift-3-indexing-model - add tests for the follow?
     //          index(before: of i: Index) -> Index
@@ -1522,7 +1522,7 @@ extension TestSuite {
 
     addBidirectionalCollectionTests(${forwardTestArgs})
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
     func makeWrappedCollection(_ elements: [OpaqueValue<Int>]) -> C {
       return makeCollection(elements.map(wrapValue))

stdlib/private/StdlibCollectionUnittest/CheckMutableCollectionType.swift.gyb

@@ -148,7 +148,7 @@ extension TestSuite {
       return makeCollectionOfComparable(elements.map(wrapValueIntoComparable))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
 //===----------------------------------------------------------------------===//
 // subscript(_: Index)
@@ -749,7 +749,7 @@ self.test("\(testNamePrefix).partition/InvalidOrderings") {
       return makeCollection(elements.map(wrapValue))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
 //===----------------------------------------------------------------------===//
 // subscript(_: Index)
@@ -906,7 +906,7 @@ self.test("\(testNamePrefix).partition/DispatchesThrough_withUnsafeMutableBuffer
       return makeCollectionOfComparable(elements.map(wrapValueIntoComparable))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
 //===----------------------------------------------------------------------===//
 // sort()

stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableCollectionType.swift

@@ -497,7 +497,7 @@ extension TestSuite {
       return makeCollection(elements.map(wrapValue))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
 //===----------------------------------------------------------------------===//
 // init()
@@ -1218,7 +1218,7 @@ self.test("\(testNamePrefix).OperatorPlus") {
       return makeCollection(elements.map(wrapValue))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
 //===----------------------------------------------------------------------===//
 // removeLast()
@@ -1340,7 +1340,7 @@ self.test("\(testNamePrefix).removeLast(n: Int)/whereIndexIsBidirectional/remove
       resiliencyChecks: resiliencyChecks,
       outOfBoundsIndexOffset: outOfBoundsIndexOffset)
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
     // No extra checks for collections with random access traversal so far.
   } // addRangeReplaceableRandomAccessCollectionTests

stdlib/private/StdlibCollectionUnittest/CheckRangeReplaceableSliceType.swift

@@ -65,7 +65,7 @@ extension TestSuite {
       return makeCollection(elements.map(wrapValue))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
     //===------------------------------------------------------------------===//
     // removeFirst()
@@ -210,7 +210,7 @@ extension TestSuite {
       return makeCollection(elements.map(wrapValue))
     }
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
     //===------------------------------------------------------------------===//
     // removeLast()
@@ -351,7 +351,7 @@ extension TestSuite {
       resiliencyChecks: resiliencyChecks,
       outOfBoundsIndexOffset: outOfBoundsIndexOffset)
 
-    testNamePrefix += String(C.Type.self)
+    testNamePrefix += String(describing: C.Type.self)
 
     // No tests yet.
   } // addRangeReplaceableRandomAccessSliceTests

stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift

@@ -1484,7 +1484,7 @@ extension TestSuite {
       return makeSequenceOfEquatable(elements.map(wrapValueIntoEquatable))
     }
 
-    testNamePrefix += String(S.Type.self)
+    testNamePrefix += String(describing: S.Type.self)
 
     let isMultiPass = makeSequence([])
       ._preprocessingPass { true } ?? false

stdlib/private/StdlibUnittest/StdlibCoreExtras.swift

@@ -127,7 +127,7 @@ public func == (lhs: TypeIdentifier, rhs: TypeIdentifier) -> Bool {
 extension TypeIdentifier
   : CustomStringConvertible, CustomDebugStringConvertible {
   public var description: String {
-    return String(value)
+    return String(describing: value)
   }
   public var debugDescription: String {
     return "TypeIdentifier(\(description))"

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -2215,6 +2215,12 @@ public func checkStrideable<Instances : Collection, Strides : Collection>(
   }
 }
 
+public func checkLosslessStringConvertible<Instance>(
+  _ instances: [Instance]
+) where Instance : LosslessStringConvertible & Equatable {
+  expectEqualFunctionsForDomain(instances, { $0 }, { Instance(String($0))! })
+}
+
 public func nthIndex<C: Collection>(_ x: C, _ n: Int) -> C.Index {
   return x.index(x.startIndex, offsetBy: numericCast(n))
 }

stdlib/private/StdlibUnittest/StringConvertible.swift.gyb

@@ -112,7 +112,7 @@ extension CustomPrintableValue : CustomDebugStringConvertible {
 public func expectPrinted<T>(
   expectedOneOf patterns: [String], _ object: T, ${TRACE}
 ) {
-  let actual = String(object)
+  let actual = String(describing: object)
   if !patterns.contains(actual) {
     expectationFailure(
       "expected: any of \(String(reflecting: patterns))\n"

stdlib/public/core/AnyHashable.swift

@@ -151,7 +151,7 @@ extension AnyHashable : Hashable {
 
 extension AnyHashable : CustomStringConvertible {
   public var description: String {
-    return String(base)
+    return String(describing: base)
   }
 }
 

stdlib/public/core/Bool.swift

@@ -146,6 +146,18 @@ extension Bool : Equatable, Hashable {
   }
 }
 
+extension Bool : LosslessStringConvertible {
+  public init?(_ description: String) {
+    if description == "true" {
+      self = true
+    } else if description == "false" {
+      self = false
+    } else {
+      return nil
+    }
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Operators
 //===----------------------------------------------------------------------===//

stdlib/public/core/Character.swift

@@ -353,6 +353,14 @@ public struct Character :
   internal var _representation: Representation
 }
 
+extension Character : CustomStringConvertible {
+  public var description: String {
+    return String(describing: self)
+  }
+}
+
+extension Character : LosslessStringConvertible {}
+
 extension Character : CustomDebugStringConvertible {
   /// A textual representation of the character, suitable for debugging.
   public var debugDescription: String {

stdlib/public/core/FloatingPointParsing.swift.gyb

@@ -42,7 +42,7 @@ internal func _isspace_clocale(_ u: UTF16.CodeUnit) -> Bool {
 % end
 
 //===--- Parsing ----------------------------------------------------------===//
-extension ${Self} {
+extension ${Self} : LosslessStringConvertible {
   /// Construct from an ASCII representation.
   ///
   /// Returns the result of calling the POSIX function

stdlib/public/core/ImplicitlyUnwrappedOptional.swift

@@ -45,7 +45,7 @@ extension ImplicitlyUnwrappedOptional : CustomStringConvertible {
   public var description: String {
     switch self {
     case .some(let value):
-      return String(value)
+      return String(describing: value)
     case .none:
       return "nil"
     }

stdlib/public/core/Integers.swift.gyb

@@ -688,7 +688,7 @@ public protocol SignedInteger_ : BinaryInteger, SignedArithmetic {
 
 extension SignedInteger_ {
   public var description: String {
-    let base = String(magnitude)
+    let base = String(describing: magnitude)
     return self < 0 ? "-" + base : base
   }
 

stdlib/public/core/Mirror.swift

@@ -855,7 +855,7 @@ extension String {
   ///     }
   ///
   ///     let p = Point(x: 21, y: 30)
-  ///     print(String(p))
+  ///     print(String(describing: p))
   ///     // Prints "Point(x: 21, y: 30)"
   ///
   /// After adding `CustomStringConvertible` conformance by implementing the
@@ -867,11 +867,11 @@ extension String {
   ///         }
   ///     }
   ///
-  ///     print(String(p))
+  ///     print(String(describing: p))
   ///     // Prints "(21, 30)"
   ///
   /// - SeeAlso: `String.init<Subject>(reflecting: Subject)`
-  public init<Subject>(_ instance: Subject) {
+  public init<Subject>(describing instance: Subject) {
     self.init()
     _print_unlocked(instance, &self)
   }

stdlib/public/core/OutputStream.swift

@@ -164,6 +164,20 @@ public protocol CustomStringConvertible {
   var description: String { get }
 }
 
+/// A type that can be represented as a string in a lossless, unambiguous way.
+///
+/// For example, the integer value 1050 can be represented in its entirety as
+/// the string "1050".
+///
+/// The description property of a conforming type must be a value-preserving
+/// representation of the original value. As such, it should be possible to
+/// re-create an instance from its string representation.
+public protocol LosslessStringConvertible : CustomStringConvertible {
+  /// Instantiates an instance of the conforming type from a string
+  /// representation.
+  init?(_ description: String)
+}
+
 /// A type with a customized textual representation suitable for debugging
 /// purposes.
 ///

stdlib/public/core/StaticString.swift

@@ -255,7 +255,7 @@ public struct StaticString
 
 extension StaticString {
   public var customMirror: Mirror {
-    return Mirror(reflecting: String(self))
+    return Mirror(reflecting: description)
   }
 }
 

stdlib/public/core/String.swift

@@ -981,6 +981,24 @@ extension String {
     return _nativeUnicodeUppercaseString(self)
 #endif
   }
+
+  /// Creates an instance from the description of a given
+  /// `LosslessStringConvertible` instance.
+  public init<T : LosslessStringConvertible>(_ value: T) {
+    self = value.description
+  }
+}
+
+extension String : CustomStringConvertible {
+  public var description: String {
+    return self
+  }
+}
+
+extension String : LosslessStringConvertible {
+  public init?(_ description: String) {
+    self = description
+  }
 }
 
 extension String {

stdlib/public/core/StringInterpolation.swift.gyb

@@ -65,7 +65,7 @@ extension String : ExpressibleByStringInterpolation {
   ///
   /// - SeeAlso: `ExpressibleByStringInterpolation`
   public init<T>(stringInterpolationSegment expr: T) {
-    self = String(expr)
+    self = String(describing: expr)
   }
 
 % for Type in StreamableTypes:

stdlib/public/core/StringUTF16.swift

@@ -314,7 +314,7 @@ extension String {
       return UTF16View(_core)
     }
     set {
-      self = String(newValue)
+      self = String(describing: newValue)
     }
   }
 

stdlib/public/core/StringUTF8.swift

@@ -375,7 +375,7 @@ extension String {
       return UTF8View(self._core)
     }
     set {
-      self = String(newValue)
+      self = String(describing: newValue)
     }
   }
 

stdlib/public/core/UnicodeScalar.swift

@@ -271,17 +271,30 @@ public struct UnicodeScalar :
 }
 
 extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
-  /// An escaped textual representation of the Unicode scalar.
+  /// A textual representation of the Unicode scalar.
   public var description: String {
-    return "\"\(escaped(asASCII: false))\""
+    return String._fromWellFormedCodeUnitSequence(
+      UTF32.self,
+      input: repeatElement(self.value, count: 1))
   }
+
   /// An escaped textual representation of the Unicode scalar, suitable for
   /// debugging.
   public var debugDescription: String {
     return "\"\(escaped(asASCII: true))\""
   }
 }
 
+extension UnicodeScalar : LosslessStringConvertible {
+  public init?(_ description: String) {
+    let scalars = description.unicodeScalars
+    guard let v = scalars.first, scalars.count == 1 else {
+      return nil
+    }
+    self = v
+  }
+}
+
 extension UnicodeScalar : Hashable {
   /// The Unicode scalar's hash value.
   ///

stdlib/public/core/UnsafeBufferPointer.swift.gyb

@@ -219,7 +219,7 @@ extension Unsafe${Mutable}BufferPointer : CustomDebugStringConvertible {
   /// A textual representation of `self`, suitable for debugging.
   public var debugDescription: String {
     return "Unsafe${Mutable}BufferPointer"
-      + "(start: \(_position.map(String.init(_:)) ?? "nil"), count: \(count))"
+      + "(start: \(_position.map(String.init(describing:)) ?? "nil"), count: \(count))"
   }
 }
 %end