stdlib: initializePointee(_) => initialize(with:)

Tacking "Pointee" on just for unary operations (and especially
operations with an optional count) created inconsistency.

Author: Dave Abrahams

Diff for: 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.initializePointee(x)
+  ptr.initialize(with: x)
   let result =
     UnsafeMutablePointer<T>(_stdlib_getPointer(OpaquePointer(ptr))).pointee
   ptr.deinitializePointee()

Diff for: 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).initializePointee(0)
+      (shards + i).initialize(with: 0)
     }
     self._shardsPtr = shards
     self._shardsCount = count

Diff for: 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.initializePointee(block(arg))
+    result.initialize(with: block(arg))
     return UnsafeMutablePointer(result)
   }
 }

Diff for: stdlib/public/SDK/Foundation/NSError.swift

@@ -46,7 +46,7 @@ public func _stdlib_bridgeNSErrorToErrorProtocol<
   T : _ObjectiveCBridgeableErrorProtocol
 >(error: NSError, out: UnsafeMutablePointer<T>) -> Bool {
   if let bridged = T(_bridgedNSError: error) {
-    out.initializePointee(bridged)
+    out.initialize(with: bridged)
     return true
   } else {
     return false

Diff for: stdlib/public/core/ArrayBuffer.swift

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

Diff for: stdlib/public/core/ArrayBufferProtocol.swift

@@ -169,7 +169,7 @@ extension _ArrayBufferProtocol {
       }
       // Initialize the hole left by sliding the tail forward
       for j in oldTailIndex..<newTailIndex {
-        (elements + j).initializePointee(newValues[i])
+        (elements + j).initialize(with: newValues[i])
         i._successorInPlace()
       }
       _expectEnd(i, newValues)

Diff for: stdlib/public/core/ArrayCast.swift

@@ -82,7 +82,7 @@ public func _arrayForceCast<SourceElement, TargetElement>(
         _precondition(
           bridged != nil, "array element cannot be bridged to Objective-C")
         // FIXME: should be an unsafeDowncast.
-        p.initializePointee(unsafeBitCast(bridged!, to: TargetElement.self))
+        p.initialize(with: unsafeBitCast(bridged!, to: TargetElement.self))
         p += 1
       }
     }
@@ -162,7 +162,7 @@ ElementwiseBridging:
       if _slowPath(value == nil) {
         break ElementwiseBridging
       }
-      p.initializePointee(value!)
+      p.initialize(with: value!)
       p += 1
     }
     return Array(_ArrayBuffer(buf, shiftedToStartIndex: 0))

Diff for: stdlib/public/core/Arrays.swift.gyb

@@ -510,7 +510,7 @@ extension ${Self} : _ArrayProtocol {
     var p: UnsafeMutablePointer<Element>
     (self, p) = ${Self}._allocateUninitialized(count)
     for _ in 0..<count {
-      p.initializePointee(repeatedValue)
+      p.initialize(with: repeatedValue)
       p += 1
     }
   }
@@ -676,7 +676,7 @@ extension ${Self} : _ArrayProtocol {
     _sanityCheck(_buffer.capacity >= _buffer.count + 1)
 
     _buffer.count = oldCount + 1
-    (_buffer.firstElementAddress + oldCount).initializePointee(newElement)
+    (_buffer.firstElementAddress + oldCount).initialize(with: newElement)
   }
 
   /// Append `newElement` to the ${Self}.
@@ -904,7 +904,7 @@ internal struct _InitializeMemoryFromCollection<
     var p = rawMemory
     var q = newValues.startIndex
     for _ in 0..<count {
-      p.initializePointee(newValues[q])
+      p.initialize(with: newValues[q])
       q = q.successor()
       p += 1
     }
@@ -1172,7 +1172,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.initializePointee(newValue)
+    rawMemory.initialize(with: newValue)
   }
 
   @_transparent
@@ -1249,7 +1249,7 @@ internal func _arrayAppendSequence<
     let base = buffer.firstElementAddress
 
     while (nextItem != nil) && count < capacity {
-      (base + count).initializePointee(nextItem!)
+      (base + count).initialize(with: nextItem!)
       count += 1
       nextItem = stream.next()
     }

Diff for: stdlib/public/core/Collection.swift

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

Diff for: stdlib/public/core/ContiguousArrayBuffer.swift

@@ -149,7 +149,7 @@ final class _ContiguousArrayStorage<Element> : _ContiguousArrayStorage1 {
     let resultPtr = result.baseAddress
     let p = __manager._elementPointer
     for i in 0..<count {
-      (resultPtr + i).initializePointee(_bridgeToObjectiveCUnconditional(p[i]))
+      (resultPtr + i).initialize(with: _bridgeToObjectiveCUnconditional(p[i]))
     }
     _fixLifetime(__manager)
     return result
@@ -242,7 +242,7 @@ public struct _ContiguousArrayBuffer<Element> : _ArrayBufferProtocol {
     let verbatim = false
 #endif
 
-    __bufferPointer._valuePointer.initializePointee(
+    __bufferPointer._valuePointer.initialize(with: 
       _ArrayBody(
         count: count,
         capacity: capacity,
@@ -614,7 +614,7 @@ internal func _copyCollectionToNativeArrayBuffer<
   var i = source.startIndex
   for _ in 0..<count {
     // FIXME(performance): use _initializeTo().
-    p.initializePointee(source[i])
+    p.initialize(with: source[i])
     i._successorInPlace()
     p._successorInPlace()
   }
@@ -674,7 +674,7 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
       "_UnsafePartiallyInitializedContiguousArrayBuffer has no more capacity")
     remainingCapacity -= 1
 
-    p.initializePointee(element)
+    p.initialize(with: element)
     p += 1
   }
 

Diff for: stdlib/public/core/HashedCollections.swift.gyb

@@ -1641,7 +1641,7 @@ internal struct _BitMap {
 
   internal func initializeToZero() {
     for i in 0 ..< numberOfWords {
-      (values + i).initializePointee(0)
+      (values + i).initialize(with: 0)
     }
   }
 
@@ -1981,7 +1981,7 @@ struct _Native${Self}Storage<${TypeParametersDecl}> :
   internal func initializeKey(k: Key, at i: Int) {
     _sanityCheck(!isInitializedEntry(at: i))
 
-    (keys + i).initializePointee(k)
+    (keys + i).initialize(with: k)
     initializedEntries[i] = true
     _fixLifetime(self)
   }
@@ -1991,7 +1991,7 @@ struct _Native${Self}Storage<${TypeParametersDecl}> :
     from from: Storage, at: Int, toEntryAt: Int
   ) {
     _sanityCheck(!isInitializedEntry(at: toEntryAt))
-    (keys + toEntryAt).initializePointee((from.keys + at).move())
+    (keys + toEntryAt).initialize(with: (from.keys + at).move())
     from.initializedEntries[at] = false
     initializedEntries[toEntryAt] = true
   }
@@ -2009,8 +2009,8 @@ struct _Native${Self}Storage<${TypeParametersDecl}> :
   internal func initializeKey(k: Key, value v: Value, at i: Int) {
     _sanityCheck(!isInitializedEntry(at: i))
 
-    (keys + i).initializePointee(k)
-    (values + i).initializePointee(v)
+    (keys + i).initialize(with: k)
+    (values + i).initialize(with: v)
     initializedEntries[i] = true
     _fixLifetime(self)
   }
@@ -2020,8 +2020,8 @@ struct _Native${Self}Storage<${TypeParametersDecl}> :
     from from: Storage, at: Int, toEntryAt: Int
   ) {
     _sanityCheck(!isInitializedEntry(at: toEntryAt))
-    (keys + toEntryAt).initializePointee((from.keys + at).move())
-    (values + toEntryAt).initializePointee((from.values + at).move())
+    (keys + toEntryAt).initialize(with: (from.keys + at).move())
+    (values + toEntryAt).initialize(with: (from.values + at).move())
     from.initializedEntries[at] = false
     initializedEntries[toEntryAt] = true
   }
@@ -2340,7 +2340,7 @@ internal struct _BridgedNative${Self}Storage {
   internal func initializeKey(k: AnyObject, at i: Int) {
     _sanityCheck(!isInitializedEntry(at: i))
 
-    (keys + i).initializePointee(k)
+    (keys + i).initialize(with: k)
     initializedEntries[i] = true
     _fixLifetime(self)
   }
@@ -2350,8 +2350,8 @@ internal struct _BridgedNative${Self}Storage {
   ) {
     _sanityCheck(!isInitializedEntry(at: i))
 
-    (keys + i).initializePointee(k)
-    (values + i).initializePointee(v)
+    (keys + i).initialize(with: k)
+    (values + i).initialize(with: v)
     initializedEntries[i] = true
     _fixLifetime(self)
   }

Diff for: stdlib/public/core/HeapBuffer.swift

@@ -181,7 +181,7 @@ struct _HeapBuffer<Value, Element> : Equatable {
       size: totalSize,
       alignmentMask: alignMask)
     self._storage = Builtin.castToNativeObject(object)
-    self._value.initializePointee(initializer)
+    self._value.initialize(with: initializer)
   }
 
   public // @testable

Diff for: stdlib/public/core/ManagedBuffer.swift

@@ -190,7 +190,7 @@ public struct ManagedBufferPointer<Value, Element> : Equatable {
 
     // initialize the value field
     withUnsafeMutablePointerToValue {
-      $0.initializePointee(
+      $0.initialize(with: 
         initialValue(
           buffer: self.buffer,
           capacity: {

Diff for: stdlib/public/core/Reflection.swift

@@ -138,7 +138,7 @@ public protocol _Mirror {
 @_silgen_name("swift_getSummary")
 public // COMPILER_INTRINSIC
 func _getSummary<T>(out: UnsafeMutablePointer<String>, x: T) {
-  out.initializePointee(String(reflecting: x))
+  out.initialize(with: String(reflecting: x))
 }
 
 /// Produce a mirror for any value. If the value's type conforms to

Diff for: stdlib/public/core/Sequence.swift

@@ -609,7 +609,7 @@ extension Sequence {
     -> UnsafeMutablePointer<Iterator.Element> {
     var p = UnsafeMutablePointer<Iterator.Element>(ptr)
     for x in IteratorSequence(self.iterator()) {
-      p.initializePointee(x)
+      p.initialize(with: x)
       p += 1
     }
     return p

Diff for: stdlib/public/core/String.swift

@@ -529,7 +529,7 @@ extension String {
     start: UnsafeMutablePointer<UTF8.CodeUnit>,
     utf8CodeUnitCount: Int
   ) {
-    resultStorage.initializePointee(
+    resultStorage.initialize(with: 
       String._fromWellFormedCodeUnitSequence(
         UTF8.self,
         input: UnsafeBufferPointer(start: start, count: utf8CodeUnitCount)))

Diff for: stdlib/public/core/UnsafePointer.swift.gyb

@@ -143,9 +143,9 @@ public struct ${Self}<Pointee>
   /// - Postcondition: The pointee is initialized; the value should eventually
   ///   be destroyed or moved from to avoid leaks.
   // FIXME: add tests (since the `count` has been added)
-  public func initializePointee(newValue: Pointee, count: Int = 1) {
+  public func initialize(with: newValue: Pointee, count: Int = 1) {
     _stdlibAssert(count >= 0,
-      "${Self}.initializePointee with negative count")
+      "${Self}.initialize(with:): negative count")
     // Must not use `initializeFrom` with a `Collection` as that will introduce
     // a cycle.
     for offset in 0..<count {
@@ -243,7 +243,7 @@ public struct ${Self}<Pointee>
       Pointee.self, self._rawValue, source._rawValue, count._builtinWordValue)
     // This builtin is equivalent to:
     // for i in 0..<count {
-    //   (self + i).initializePointee((source + i).move())
+    //   (self + i).initialize(with: (source + i).move())
     // }
   }
 
@@ -276,7 +276,7 @@ public struct ${Self}<Pointee>
     // var src = source + count
     // var dst = self + count
     // while dst != self {
-    //   (--dst).initializePointee((--src).move())
+    //   (--dst).initialize(with: (--src).move())
     // }
   }
 
@@ -305,7 +305,7 @@ public struct ${Self}<Pointee>
       Pointee.self, self._rawValue, source._rawValue, count._builtinWordValue)
     // This builtin is equivalent to:
     // for i in 0..<count {
-    //   (self + i).initializePointee(source[i])
+    //   (self + i).initialize(with: source[i])
     // }
   }
 
@@ -569,7 +569,7 @@ extension ${Self} {
     }
   }
 
-  @available(*, unavailable, renamed="initializePointee")
+  @available(*, unavailable, renamed="initialize(with:)")
   public func initialize(newvalue: Pointee) {
     fatalError("unavailable function can't be called")
   }

Diff for: test/1_stdlib/Builtins.swift

@@ -139,8 +139,8 @@ struct ContainsP { var p: P }
 func exerciseArrayValueWitnesses<T>(value: T) {
   let buf = UnsafeMutablePointer<T>(allocatingCapacity: 5)
 
-  (buf + 0).initializePointee(value)
-  (buf + 1).initializePointee(value)
+  (buf + 0).initialize(with: value)
+  (buf + 1).initialize(with: value)
 
   Builtin.copyArray(T.self, (buf + 2)._rawValue, buf._rawValue, 2._builtinWordValue)
   Builtin.takeArrayBackToFront(T.self, (buf + 1)._rawValue, buf._rawValue, 4._builtinWordValue)

Diff for: test/1_stdlib/HeapBuffer.swift

@@ -20,7 +20,7 @@ a.value.name = "DaveA"
 a.value.locations.append("Princeton")
 a.value.locations.append("San Jose")
 for x in 0..<10 {
-  (a.baseAddress + x).initializePointee(x)
+  (a.baseAddress + x).initialize(with: x)
 }
 
 print("buffer has storage: \(a.storage != nil)")

Diff for: test/1_stdlib/ManagedBuffer.swift

@@ -117,7 +117,7 @@ final class TestManagedBuffer<T> : ManagedBuffer<CountAndCapacity, T> {
 
     withUnsafeMutablePointerToElements {
       (p: UnsafeMutablePointer<T>) -> () in
-      (p + count).initializePointee(x)
+      (p + count).initialize(with: x)
     }
     self.count = count + 2
   }

Diff for: test/1_stdlib/Reflection.swift

@@ -204,7 +204,7 @@ dump(randomUnsafeMutablePointerString)
 
 // CHECK-NEXT: Hello panda
 var sanePointerString = UnsafeMutablePointer<String>(allocatingCapacity: 1)
-sanePointerString.initializePointee("Hello panda")
+sanePointerString.initialize(with: "Hello panda")
 dump(sanePointerString.pointee)
 sanePointerString.deinitializePointee()
 sanePointerString.deallocateCapacity(1)