Rename initialize(with:count:) to initialize(to:count:). (#3601)

As proposed in SE-0107: UnsafeRawPointer.

"with" is considered a vacuous preposition. "to" implies direction.

Author: atrick

stdlib/private/StdlibUnittest/OpaqueIdentityFunctions.swift

@@ -15,7 +15,7 @@ func _stdlib_getPointer(_ x: OpaquePointer) -> OpaquePointer
 
 public func _opaqueIdentity<T>(_ x: T) -> T {
   let ptr = UnsafeMutablePointer<T>(allocatingCapacity: 1)
-  ptr.initialize(with: x)
+  ptr.initialize(to: x)
   let result =
     UnsafeMutablePointer<T>(_stdlib_getPointer(OpaquePointer(ptr))).pointee
   ptr.deinitialize()

stdlib/private/SwiftPrivate/ShardedAtomicCounter.swift

@@ -35,7 +35,7 @@ public struct _stdlib_ShardedAtomicCounter {
     let count = max(8, hardwareConcurrency * hardwareConcurrency)
     let shards = UnsafeMutablePointer<Int>(allocatingCapacity: count)
     for i in 0..<count {
-      (shards + i).initialize(with: 0)
+      (shards + i).initialize(to: 0)
     }
     self._shardsPtr = shards
     self._shardsCount = count

stdlib/private/SwiftPrivatePthreadExtras/SwiftPrivatePthreadExtras.swift

@@ -42,7 +42,7 @@ internal class PthreadBlockContextImpl<Argument, Result>: PthreadBlockContext {
 
   override func run() -> UnsafeMutablePointer<Void> {
     let result = UnsafeMutablePointer<Result>(allocatingCapacity: 1)
-    result.initialize(with: block(arg))
+    result.initialize(to: block(arg))
     return UnsafeMutablePointer(result)
   }
 }

stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift

@@ -357,7 +357,7 @@ public func reflect(object: AnyObject) {
 public func reflect<T>(any: T) {
   let any: Any = any
   let anyPointer = UnsafeMutablePointer<Any>(allocatingCapacity: sizeof(Any.self))
-  anyPointer.initialize(with: any)
+  anyPointer.initialize(to: any)
   let anyPointerValue = unsafeBitCast(anyPointer, to: UInt.self)
   reflect(instanceAddress: anyPointerValue, kind: .Existential)
   anyPointer.deallocateCapacity(sizeof(Any.self))
@@ -421,7 +421,7 @@ struct ThickFunctionParts {
 public func reflect(function: () -> ()) {
   let fn = UnsafeMutablePointer<ThickFunction0>(
       allocatingCapacity: sizeof(ThickFunction0.self))
-  fn.initialize(with: ThickFunction0(function: function))
+  fn.initialize(to: ThickFunction0(function: function))
 
   let parts = unsafeBitCast(fn, to: UnsafePointer<ThickFunctionParts>.self)
   let contextPointer = unsafeBitCast(parts.pointee.context, to: UInt.self)
@@ -436,7 +436,7 @@ public func reflect(function: () -> ()) {
 public func reflect(function: (Int) -> ()) {
   let fn = UnsafeMutablePointer<ThickFunction1>(
       allocatingCapacity: sizeof(ThickFunction1.self))
-  fn.initialize(with: ThickFunction1(function: function))
+  fn.initialize(to: ThickFunction1(function: function))
 
   let parts = unsafeBitCast(fn, to: UnsafePointer<ThickFunctionParts>.self)
   let contextPointer = unsafeBitCast(parts.pointee.context, to: UInt.self)
@@ -451,7 +451,7 @@ public func reflect(function: (Int) -> ()) {
 public func reflect(function: (Int, String) -> ()) {
   let fn = UnsafeMutablePointer<ThickFunction2>(
       allocatingCapacity: sizeof(ThickFunction2.self))
-  fn.initialize(with: ThickFunction2(function: function))
+  fn.initialize(to: ThickFunction2(function: function))
 
   let parts = unsafeBitCast(fn, to: UnsafePointer<ThickFunctionParts>.self)
   let contextPointer = unsafeBitCast(parts.pointee.context, to: UInt.self)
@@ -466,7 +466,7 @@ public func reflect(function: (Int, String) -> ()) {
 public func reflect(function: (Int, String, AnyObject?) -> ()) {
   let fn = UnsafeMutablePointer<ThickFunction3>(
       allocatingCapacity: sizeof(ThickFunction3.self))
-  fn.initialize(with: ThickFunction3(function: function))
+  fn.initialize(to: ThickFunction3(function: function))
 
   let parts = unsafeBitCast(fn, to: UnsafePointer<ThickFunctionParts>.self)
   let contextPointer = unsafeBitCast(parts.pointee.context, to: UInt.self)

stdlib/public/SDK/Foundation/NSError.swift

@@ -282,7 +282,7 @@ public func _stdlib_bridgeNSErrorToError<
   T : _ObjectiveCBridgeableError
 >(_ error: NSError, out: UnsafeMutablePointer<T>) -> Bool {
   if let bridged = T(_bridgedNSError: error) {
-    out.initialize(with: bridged)
+    out.initialize(to: bridged)
     return true
   } else {
     return false

stdlib/public/core/ArrayBuffer.swift

@@ -217,7 +217,7 @@ extension _ArrayBuffer {
     // Make another pass to retain the copied objects
     var result = target
     for _ in CountableRange(bounds) {
-      result.initialize(with: result.pointee)
+      result.initialize(to: result.pointee)
       result += 1
     }
     return result

stdlib/public/core/ArrayBufferProtocol.swift

@@ -163,7 +163,7 @@ extension _ArrayBufferProtocol where Index == Int {
       }
       // Initialize the hole left by sliding the tail forward
       for j in oldTailIndex..<newTailIndex {
-        (elements + j).initialize(with: newValues[i])
+        (elements + j).initialize(to: newValues[i])
         newValues.formIndex(after: &i)
       }
       _expectEnd(i, newValues)

stdlib/public/core/Arrays.swift.gyb

@@ -1061,7 +1061,7 @@ extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
     var p: UnsafeMutablePointer<Element>
     (self, p) = ${Self}._allocateUninitialized(count)
     for _ in 0..<count {
-      p.initialize(with: repeatedValue)
+      p.initialize(to: repeatedValue)
       p += 1
     }
   }
@@ -1252,7 +1252,7 @@ extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
     _sanityCheck(_buffer.capacity >= _buffer.count + 1)
 
     _buffer.count = oldCount + 1
-    (_buffer.firstElementAddress + oldCount).initialize(with: newElement)
+    (_buffer.firstElementAddress + oldCount).initialize(to: newElement)
   }
 
   /// Adds a new element at the end of the array.
@@ -1616,7 +1616,7 @@ internal struct _InitializeMemoryFromCollection<
     var p = rawMemory
     var q = newValues.startIndex
     for _ in 0..<count {
-      p.initialize(with: newValues[q])
+      p.initialize(to: newValues[q])
       newValues.formIndex(after: &q)
       p += 1
     }
@@ -1923,7 +1923,7 @@ internal struct _InitializePointer<T> : _PointerFunction {
   internal func call(_ rawMemory: UnsafeMutablePointer<T>, count: Int) {
     _sanityCheck(count == 1)
     // FIXME: it would be better if we could find a way to move, here
-    rawMemory.initialize(with: newValue)
+    rawMemory.initialize(to: newValue)
   }
 
   @_transparent
@@ -2003,7 +2003,7 @@ internal func _arrayAppendSequence<Buffer, S>(
     let base = buffer.firstElementAddress
 
     while (nextItem != nil) && count < capacity {
-      (base + count).initialize(with: nextItem!)
+      (base + count).initialize(to: nextItem!)
       count += 1
       nextItem = stream.next()
     }

stdlib/public/core/Collection.swift

@@ -1680,7 +1680,7 @@ extension Sequence
     } else {
       var p = ptr
       for x in self {
-        p.initialize(with: x)
+        p.initialize(to: x)
         p += 1
       }
       return p

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -145,7 +145,7 @@ final class _ContiguousArrayStorage<Element> : _ContiguousArrayStorage1 {
     let resultPtr = result.baseAddress
     let p = __manager._elementPointer
     for i in 0..<count {
-      (resultPtr + i).initialize(with: _bridgeToObjectiveCUnconditional(p[i]))
+      (resultPtr + i).initialize(to: _bridgeToObjectiveCUnconditional(p[i]))
     }
     _fixLifetime(__manager)
     return result
@@ -239,7 +239,7 @@ struct _ContiguousArrayBuffer<Element> : _ArrayBufferProtocol {
     let verbatim = false
 #endif
 
-    __bufferPointer._headerPointer.initialize(with: 
+    __bufferPointer._headerPointer.initialize(to: 
       _ArrayBody(
         count: count,
         capacity: capacity,
@@ -608,7 +608,7 @@ internal func _copyCollectionToContiguousArray<
   var i = source.startIndex
   for _ in 0..<count {
     // FIXME(performance): use _copyContents(initializing:).
-    p.initialize(with: source[i])
+    p.initialize(to: source[i])
     source.formIndex(after: &i)
     p += 1
   }
@@ -667,7 +667,7 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
       "_UnsafePartiallyInitializedContiguousArrayBuffer has no more capacity")
     remainingCapacity -= 1
 
-    p.initialize(with: element)
+    p.initialize(to: element)
     p += 1
   }