Eliminate all of the uses of ++/-- from stdlib/public/core.

At DaveA's suggestion, I took a mostly mechanical approach to this:
pointers and numeric types start using += 1, and indexes use
i = i.successor().  The index model is likely to be revised in
Swift 3 anyway, so micro-optimizing this code syntactically isn't
super important.

There is some performance concern of this patch, since some
in-place succesor operations are more efficient than
i = i.successor().  The one that seems particularly at issue is the
instance in the implementation of partition(), which I changed to
use i._successorInPlace().  If other instances lead to a perf issue,
they can be changed to use that as well.

Author: lattner

stdlib/public/core/ArrayBufferType.swift

@@ -159,11 +159,13 @@ extension _ArrayBufferType {
       // Assign over the original subRange
       var i = newValues.startIndex
       for j in subRange {
-        elements[j] = newValues[i++]
+        elements[j] = newValues[i]
+        i = i.successor()
       }
       // Initialize the hole left by sliding the tail forward
       for j in oldTailIndex..<newTailIndex {
-        (elements + j).initialize(newValues[i++])
+        (elements + j).initialize(newValues[i])
+        i = i.successor()
       }
       _expectEnd(i, newValues)
     }
@@ -172,7 +174,9 @@ extension _ArrayBufferType {
       var i = subRange.startIndex
       var j = newValues.startIndex
       for _ in 0..<newCount {
-        elements[i++] = newValues[j++]
+        elements[i] = newValues[j]
+        i = i.successor()
+        j = j.successor()
       }
       _expectEnd(j, newValues)
 

stdlib/public/core/ArrayCast.swift

@@ -82,8 +82,9 @@ public func _arrayForceCast<SourceElement, TargetElement>(
         let bridged: AnyObject? = _bridgeToObjectiveC(value)
         _precondition(
           bridged != nil, "array element cannot be bridged to Objective-C")
-        // FIXME: should be an unsafeDowncast, but for <rdar://problem/18638230>
-        p++.initialize(unsafeBitCast(bridged!, TargetElement.self))
+        // FIXME: should be an unsafeDowncast.
+        p.initialize(unsafeBitCast(bridged!, TargetElement.self))
+        p += 1
       }
     }
     return Array(_ArrayBuffer(buf, shiftedToStartIndex: 0))
@@ -162,7 +163,8 @@ ElementwiseBridging:
       if _slowPath(value == nil) {
         break ElementwiseBridging
       }
-      p++.initialize(value!)
+      p.initialize(value!)
+      p += 1
     }
     return Array(_ArrayBuffer(buf, shiftedToStartIndex: 0))
   }

stdlib/public/core/Arrays.swift.gyb

@@ -513,7 +513,8 @@ extension ${Self} : _ArrayType {
     var p: UnsafeMutablePointer<Element>
     (self, p) = ${Self}._allocateUninitialized(count)
     for _ in 0..<count {
-      p++.initialize(repeatedValue)
+      p.initialize(repeatedValue)
+      p += 1
     }
   }
 
@@ -908,7 +909,9 @@ internal struct _InitializeMemoryFromCollection<
     var p = rawMemory
     var q = newValues.startIndex
     for _ in 0..<count {
-      p++.initialize(newValues[q++])
+      p.initialize(newValues[q])
+      q = q.successor()
+      p += 1
     }
     _expectEnd(q, newValues)
   }

stdlib/public/core/Collection.swift

@@ -322,7 +322,8 @@ extension CollectionType {
     var i = self.startIndex
 
     for _ in 0..<count {
-      result.append(try transform(self[i++]))
+      result.append(try transform(self[i]))
+      i = i.successor()
     }
 
     _expectEnd(i, self)
@@ -595,7 +596,8 @@ extension SequenceType
     } else {
       var p = ptr
       for x in self {
-        p++.initialize(x)
+        p.initialize(x)
+        p += 1
       }
       return p
     }
@@ -726,8 +728,8 @@ internal func _writeBackMutableSlice<
     newElementIndex != newElementsEndIndex {
 
     self_[selfElementIndex] = slice[newElementIndex]
-    ++selfElementIndex
-    ++newElementIndex
+    selfElementIndex = selfElementIndex.successor()
+    newElementIndex = newElementIndex.successor()
   }
 
   _precondition(

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -608,7 +608,9 @@ internal func _copyCollectionToNativeArrayBuffer<
   var i = source.startIndex
   for _ in 0..<count {
     // FIXME(performance): use _initializeTo().
-    (p++).initialize(source[i++])
+    p.initialize(source[i])
+    i = i.successor()
+    p = p.successor()
   }
   _expectEnd(i, source)
   return result
@@ -665,7 +667,8 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
       "_UnsafePartiallyInitializedContiguousArrayBuffer has no more capacity")
     remainingCapacity -= 1
 
-    (p++).initialize(element)
+    p.initialize(element)
+    p += 1
   }
 
   /// Finish initializing the buffer, adjusting its count to the final

stdlib/public/core/Existential.swift

@@ -44,7 +44,7 @@ internal struct _CollectionOf<
     return AnyGenerator {
       () -> T? in
       if _fastPath(index != self.endIndex) {
-        ++index
+        index = index.successor()
         return self._subscriptImpl(index)
       }
       return nil

stdlib/public/core/HashedCollections.swift.gyb

@@ -713,7 +713,7 @@ public func == <Element : Hashable>(lhs: Set<Element>, rhs: Set<Element>) -> Boo
     }
 
     let endIndex = lhsNative.endIndex
-    for var i = lhsNative.startIndex; i != endIndex; ++i {
+    for var i = lhsNative.startIndex; i != endIndex; i = i.successor() {
       let key = lhsNative.assertingGet(i)
       let bridgedKey: AnyObject = _bridgeToObjectiveCUnconditional(key)
       let optRhsValue: AnyObject? = rhsCocoa.maybeGet(bridgedKey)
@@ -1230,7 +1230,8 @@ public func == <Key : Equatable, Value : Equatable>(
     }
 
     let endIndex = lhsNative.endIndex
-    for var index = lhsNative.startIndex; index != endIndex; ++index {
+    for var index = lhsNative.startIndex; index != endIndex;
+        index = index.successor() {
       let (key, value) = lhsNative.assertingGet(index)
       let optRhsValue: AnyObject? =
         rhsCocoa.maybeGet(_bridgeToObjectiveCUnconditional(key))

stdlib/public/core/Index.swift

@@ -214,8 +214,10 @@ extension ForwardIndexType {
     _precondition(n >= 0,
         "Only BidirectionalIndexType can be advanced by a negative amount")
     var p = self
-    for var i: Distance = 0; i != n; ++i {
-      ++p
+    var i : Distance = 0
+    while i != n {
+      p = p.successor()
+      i = i + 1
     }
     return p
   }
@@ -227,8 +229,11 @@ extension ForwardIndexType {
     _precondition(n >= 0,
         "Only BidirectionalIndexType can be advanced by a negative amount")
     var p = self
-    for var i: Distance = 0; i != n && p != limit; ++i {
-      ++p
+    var i : Distance = 0
+    while i != n {
+      if p == limit { break }
+      p = p.successor()
+      i = i + 1
     }
     return p
   }
@@ -248,8 +253,8 @@ extension ForwardIndexType {
     var p = self
     var count: Distance = 0
     while p != end {
-      ++count
-      ++p
+      count += 1
+      p = p.successor()
     }
     return count
   }

stdlib/public/core/Sequence.swift

@@ -613,7 +613,8 @@ extension SequenceType {
     -> UnsafeMutablePointer<Generator.Element> {
     var p = UnsafeMutablePointer<Generator.Element>(ptr)
     for x in GeneratorSequence(self.generate()) {
-      p++.initialize(x)
+      p.initialize(x)
+      p += 1
     }
     return p
   }

stdlib/public/core/Sort.swift.gyb

@@ -56,7 +56,8 @@ func _insertionSort<
 
     // One element is trivially already-sorted, thus pre-increment
     // Continue until the sorted elements cover the whole sequence
-    while (++sortedEnd != range.endIndex) {
+    sortedEnd = sortedEnd.successor()
+    while sortedEnd != range.endIndex {
       // get the first unsorted element
       let x: C.Generator.Element = elements[sortedEnd]
 
@@ -80,6 +81,7 @@ func _insertionSort<
         // Plop x into position
         elements[i] = x
       }
+      sortedEnd = sortedEnd.successor()
     }
   }
 }
@@ -130,8 +132,10 @@ func _partition<
 
 Loop: while true {
   FindLo: repeat {
-      while ++lo != hi {
+      lo._successorInPlace()
+      while lo != hi {
         if !${cmp("elements[lo]", "pivot", p)} { break FindLo }
+        lo._successorInPlace()
       }
       break Loop
     } while false

stdlib/public/core/StringBuffer.swift

@@ -106,7 +106,8 @@ public struct _StringBuffer {
     if isAscii {
       var p = UnsafeMutablePointer<UTF8.CodeUnit>(result.start)
       let sink: (UTF32.CodeUnit) -> Void = {
-        (p++).memory = UTF8.CodeUnit($0)
+        p.memory = UTF8.CodeUnit($0)
+        p += 1
       }
       let hadError = transcode(
         encoding, UTF32.self, input.generate(), sink,
@@ -117,7 +118,8 @@ public struct _StringBuffer {
     else {
       var p = result._storage.baseAddress
       let sink: (UTF16.CodeUnit) -> Void = {
-        (p++).memory = $0
+        p.memory = $0
+        p += 1
       }
       let hadError = transcode(
         encoding, UTF16.self, input.generate(), sink,

stdlib/public/core/StringCharacterView.swift

@@ -143,9 +143,9 @@ extension String.CharacterView : CollectionType {
 
       var gcb0 = graphemeClusterBreakProperty.getPropertyRawValue(
           unicodeScalars[start].value)
-      ++start
+      start = start.successor()
 
-      for ; start != end; ++start {
+      for ; start != end; start = start.successor() {
         // FIXME(performance): consider removing this "fast path".  A branch
         // that is hard to predict could be worse for performance than a few
         // loads from cache to fetch the property 'gcb1'.

stdlib/public/core/StringCore.swift

@@ -121,7 +121,9 @@ public struct _StringCore {
       var src = UnsafeMutablePointer<UTF8.CodeUnit>(srcStart)
       let srcEnd = src + count
       while (src != srcEnd) {
-        dest++.memory = UTF16.CodeUnit(src++.memory)
+        dest.memory = UTF16.CodeUnit(src.memory)
+        dest += 1
+        src += 1
       }
     }
     else {
@@ -130,7 +132,9 @@ public struct _StringCore {
       var src = UnsafeMutablePointer<UTF16.CodeUnit>(srcStart)
       let srcEnd = src + count
       while (src != srcEnd) {
-        dest++.memory = UTF8.CodeUnit(src++.memory)
+        dest.memory = UTF8.CodeUnit(src.memory)
+        dest += 1
+        src += 1
       }
     }
   }
@@ -618,13 +622,15 @@ extension _StringCore : RangeReplaceableCollectionType {
       if _fastPath(elementWidth == 1) {
         var dst = rangeStart
         for u in newElements {
-          dst++.memory = UInt8(u & 0xFF)
+          dst.memory = UInt8(u & 0xFF)
+          dst += 1
         }
       }
       else {
         var dst = UnsafeMutablePointer<UTF16.CodeUnit>(rangeStart)
         for u in newElements {
-          dst++.memory = u
+          dst.memory = u
+          dst += 1
         }
       }
 

stdlib/public/core/StringLegacy.swift

@@ -158,7 +158,7 @@ extension String {
     let rng = unicodeScalars
     var startIndex = rng.startIndex
     for _ in 0..<start {
-      ++startIndex
+      startIndex = startIndex.successor()
     }
     return String(rng[startIndex..<rng.endIndex])
   }

stdlib/public/core/UnsafeBufferPointer.swift.gyb

@@ -21,7 +21,11 @@ public struct UnsafeBufferPointerGenerator<Element>
   /// Advance to the next element and return it, or `nil` if no next
   /// element exists.
   public mutating func next() -> Element? {
-    return position == end ? nil : (position++).memory
+    if position == end { return nil }
+
+    let result = position.memory
+    position += 1
+    return result
   }
 
   var position, end: UnsafePointer<Element>