[DO NOT MERGE] Rename nulTerminatedUTF8 and nulTerminatedUTF8CString

stdlib/private/SwiftPrivate/IO.swift

@@ -100,7 +100,7 @@ public struct _FDOutputStream : TextOutputStream {
   }
 
   public mutating func write(_ string: String) {
-    let utf8 = string.nulTerminatedUTF8
+    let utf8 = string.nullTerminatedUTF8
     utf8.withUnsafeBufferPointer {
       (utf8) -> Void in
       var writtenBytes = 0

stdlib/private/SwiftPrivateLibcExtras/SwiftPrivateLibcExtras.swift

@@ -22,7 +22,7 @@ public func _stdlib_mkstemps(_ template: inout String, _ suffixlen: CInt) -> CIn
 #if os(Android)
   preconditionFailure("mkstemps doesn't work on Android")
 #else
-  var utf8 = template.nulTerminatedUTF8
+  var utf8 = template.nullTerminatedUTF8
   let (fd, fileName) = utf8.withUnsafeMutableBufferPointer {
     (utf8) -> (CInt, String) in
     let fd = mkstemps(UnsafeMutablePointer(utf8.baseAddress!), suffixlen)

stdlib/public/core/LifetimeManager.swift

@@ -43,7 +43,7 @@ extension String {
   public func withCString<Result>(
     _ body: @noescape (UnsafePointer<Int8>) throws -> Result
   ) rethrows -> Result {
-    return try self.nulTerminatedUTF8.withUnsafeBufferPointer {
+    return try self.nullTerminatedUTF8.withUnsafeBufferPointer {
       try body(UnsafePointer($0.baseAddress!))
     }
   }

stdlib/public/core/Pointer.swift

@@ -87,6 +87,6 @@ public // COMPILER_INTRINSIC
 func _convertConstStringToUTF8PointerArgument<
   ToPointer : _Pointer
 >(_ str: String) -> (AnyObject?, ToPointer) {
-  let utf8 = Array(str.nulTerminatedUTF8)
+  let utf8 = Array(str.nullTerminatedUTF8)
   return _convertConstArrayToPointerArgument(utf8)
 }

stdlib/public/core/StringUTF8.swift

@@ -390,15 +390,15 @@ extension String {
   /// `withUnsafeBufferPointer` on the array.
   ///
   ///     let s = "Hello!"
-  ///     let bytes = s.nulTerminatedUTF8
+  ///     let bytes = s.nullTerminatedUTF8
   ///     print(bytes)
   ///     // Prints "[72, 101, 108, 108, 111, 33, 0]"
   ///     
   ///     bytes.withUnsafeBufferPointer { ptr in
   ///         print(strlen(UnsafePointer(ptr.baseAddress!)))
   ///     }
   ///     // Prints "6"
-  public var nulTerminatedUTF8: ContiguousArray<UTF8.CodeUnit> {
+  public var nullTerminatedUTF8: ContiguousArray<UTF8.CodeUnit> {
     var result = ContiguousArray<UTF8.CodeUnit>()
     result.reserveCapacity(utf8.count + 1)
     result += utf8
@@ -409,9 +409,9 @@ extension String {
   /// A contiguously stored null-terminated UTF-8 representation of
   /// the string.
   ///
-  /// This is a variation on nulTerminatedUTF8 that creates an array
-  /// of element type CChar for use with CString API's.
-  public var nulTerminatedUTF8CString: ContiguousArray<CChar> {
+  /// This is a variation on `nullTerminatedUTF8` that creates an array
+  /// of element type CChar for use with CString APIs.
+  public var utf8CString: ContiguousArray<CChar> {
     var result = ContiguousArray<CChar>()
     result.reserveCapacity(utf8.count + 1)
     for c in utf8 {
@@ -428,7 +428,7 @@ extension String {
     if ptr != nil {
       return try body(UnsafeBufferPointer(start: ptr, count: _core.count))
     }
-    return try nulTerminatedUTF8.withUnsafeBufferPointer(body)
+    return try nullTerminatedUTF8.withUnsafeBufferPointer(body)
   }
 
   /// Creates a string corresponding to the given sequence of UTF-8 code units.
@@ -725,3 +725,14 @@ extension String.UTF8View : CustomPlaygroundQuickLookable {
   }
 }
 
+extension String {
+  @available(*, unavailable, renamed: "nullTerminatedUTF8")
+  public var nulTerminatedUTF8: ContiguousArray<UTF8.CodeUnit> {
+    Builtin.unreachable()
+  }
+
+  @available(*, unavailable, renamed: "utf8CString")
+  public var nulTerminatedUTF8CString: ContiguousArray<CChar> {
+    Builtin.unreachable()
+  }
+}

test/1_stdlib/Runtime.swift.gyb

@@ -21,7 +21,7 @@ func _stdlib_demangleImpl(
 ) -> UnsafeMutablePointer<CChar>?
 
 func _stdlib_demangleName(_ mangledName: String) -> String {
-  return mangledName.nulTerminatedUTF8.withUnsafeBufferPointer {
+  return mangledName.nullTerminatedUTF8.withUnsafeBufferPointer {
     (mangledNameUTF8) in
 
     let demangledNamePtr = _stdlib_demangleImpl(

test/1_stdlib/StringAPI.swift

@@ -483,19 +483,19 @@ CStringTests.test("String.decodeCString") {
   }
 }
 
-CStringTests.test("String.nulTerminatedUTF8") {
+CStringTests.test("String.nullTerminatedUTF8") {
   do {
     let (cstr, dealloc) = getASCIICString()
     let str = String(cString: cstr)
-    expectEqualCString(cstr, str.nulTerminatedUTF8)
-    expectEqualCString(cstr, str.nulTerminatedUTF8CString)
+    expectEqualCString(cstr, str.nullTerminatedUTF8)
+    expectEqualCString(cstr, str.utf8CString)
     dealloc()
   }
   do {
     let (cstr, dealloc) = getNonASCIICString()
     let str = String(cString: cstr)
-    expectEqualCString(cstr, str.nulTerminatedUTF8)
-    expectEqualCString(cstr, str.nulTerminatedUTF8CString)
+    expectEqualCString(cstr, str.nullTerminatedUTF8)
+    expectEqualCString(cstr, str.utf8CString)
     dealloc()
   }
 }

test/1_stdlib/TestData.swift

@@ -125,7 +125,7 @@ class TestData : TestDataSuper {
     // String of course has its own way to get data, but this way tests our own data struct
     func dataFrom(_ string : String) -> Data {
         // Create a Data out of those bytes
-        return string.nulTerminatedUTF8.withUnsafeBufferPointer { (ptr) in
+        return string.nullTerminatedUTF8.withUnsafeBufferPointer { (ptr) in
             // Subtract 1 so we don't get the null terminator byte. This matches NSString behavior.
             return Data(bytes: ptr.baseAddress!, count: ptr.count - 1)
         }