Move stdlib off ++ and --

Author: lattner

stdlib/public/core/Algorithm.swift

@@ -168,7 +168,8 @@ public struct EnumerateGenerator<
   /// - Requires: No preceding call to `self.next()` has returned `nil`.
   public mutating func next() -> Element? {
     guard let b = base.next() else { return nil }
-    return (index: count++, element: b)
+    defer { count += 1 }
+    return (index: count, element: b)
   }
 }
 

stdlib/public/core/Arrays.swift.gyb

@@ -1241,7 +1241,8 @@ internal func _arrayAppendSequence<
     let base = buffer.firstElementAddress
 
     while (nextItem != nil) && count < capacity {
-      (base + count++).initialize(nextItem!)
+      (base + count).initialize(nextItem!)
+      count += 1
       nextItem = stream.next()
     }
     buffer.count = count

stdlib/public/core/CString.swift

@@ -60,7 +60,7 @@ public func _persistCString(s: UnsafePointer<CChar>) -> [CChar]? {
   }
   let length = Int(_swift_stdlib_strlen(s))
   var result = [CChar](count: length + 1, repeatedValue: 0)
-  for var i = 0; i < length; ++i {
+  for var i = 0; i < length; i += 1 {
     // FIXME: this will not compile on platforms where 'CChar' is unsigned.
     result[i] = s[i]
   }

stdlib/public/core/Character.swift

@@ -120,7 +120,7 @@ public struct Character :
   @warn_unused_result
   static func _smallSize(value: UInt64) -> Int {
     var mask: UInt64 = 0xFF
-    for var i = 0; i < 8; ++i {
+    for var i = 0; i < 8; i += 1 {
       if (value & mask) == mask {
         return i
       }

stdlib/public/core/Flatten.swift.gyb

@@ -144,11 +144,18 @@ public struct ${Index}<
   /// - Requires: The previous value is representable.
   public func predecessor() -> ${Index} {
     var prevOuter = _outer
-    var prevInnerCollection = _innerCollection ?? _base[--prevOuter]
+    var prevInnerCollection : BaseElements.Generator.Element
+    if let ic = _innerCollection {
+      prevInnerCollection = ic
+    } else {
+      prevOuter._predecessorInPlace()
+      prevInnerCollection = _base[prevOuter]
+    }
     var prevInner = _inner ?? prevInnerCollection.endIndex
 
     while prevInner == prevInnerCollection.startIndex {
-      prevInnerCollection = _base[--prevOuter]
+      prevOuter._predecessorInPlace()
+      prevInnerCollection = _base[prevOuter]
       prevInner = prevInnerCollection.endIndex
     }
 

stdlib/public/core/HashedCollections.swift.gyb

@@ -2113,7 +2113,7 @@ struct _Native${Self}Storage<${TypeParametersDecl}> :
   var description: String {
     var result = ""
 #if INTERNAL_CHECKS_ENABLED
-    for var i = 0; i != capacity; ++i {
+    for var i = 0; i != capacity; i += 1 {
       if isInitializedEntry(i) {
         let key = keyAt(i)
         result += "bucket \(i), ideal bucket = \(_bucket(key)), key = \(key)\n"
@@ -2231,7 +2231,7 @@ struct _Native${Self}Storage<${TypeParametersDecl}> :
         continue
       }
       nativeStorage.initializeKey(key, at: i.offset)
-      ++count
+      count += 1
     }
     nativeStorage.count = count
 
@@ -2601,7 +2601,7 @@ final internal class _Native${Self}StorageOwner<${TypeParametersDecl}>
     let bridged = _createBridgedNativeStorage(nativeStorage.capacity)
 
     // Bridge everything.
-    for var i = 0; i < nativeStorage.capacity; ++i {
+    for var i = 0; i < nativeStorage.capacity; i += 1 {
       if nativeStorage.isInitializedEntry(i) {
         let key = _bridgeToObjectiveCUnconditional(nativeStorage.keyAt(i))
 %if Self == 'Set':
@@ -2684,9 +2684,9 @@ final internal class _Native${Self}StorageOwner<${TypeParametersDecl}>
         while position < count {
           if bridgedNativeStorage.isInitializedEntry(position) {
             unmanagedObjects[i] = bridgedNativeStorage.valueAt(position)
-            i++
+            i += 1
           }
-          position++
+          position += 1
         }
       }
     } else {
@@ -2695,19 +2695,19 @@ final internal class _Native${Self}StorageOwner<${TypeParametersDecl}>
         while position < count {
           if bridgedNativeStorage.isInitializedEntry(position) {
             unmanagedKeys[i] = bridgedNativeStorage.keyAt(position)
-            i++
+            i += 1
           }
-          position++
+          position += 1
         }
       } else {
         // keys nonnull, objects nonnull
         while position < count {
           if bridgedNativeStorage.isInitializedEntry(position) {
             unmanagedObjects[i] = bridgedNativeStorage.valueAt(position)
             unmanagedKeys[i] = bridgedNativeStorage.keyAt(position)
-            i++
+            i += 1
           }
-          position++
+          position += 1
         }
       }
     }
@@ -2766,7 +2766,7 @@ final internal class _Native${Self}StorageOwner<${TypeParametersDecl}>
 
       let bridgedKey: AnyObject = _getBridgedKey(currIndex)
       unmanagedObjects[i] = bridgedKey
-      ++stored
+      stored += 1
       currIndex._successorInPlace()
     }
     theState.extra.0 = CUnsignedLong(currIndex.offset)
@@ -3187,15 +3187,15 @@ internal enum _Variant${Self}Storage<${TypeParametersDecl}> : _HashStorageType {
       native.setKey(key, at: i.offset)
     } else {
       native.initializeKey(key, at: i.offset)
-      ++native.count
+      native.count += 1
     }
 %elif Self == 'Dictionary':
     let oldValue: Value? = found ? native.valueAt(i.offset) : nil
     if found {
       native.setKey(key, value: value, at: i.offset)
     } else {
       native.initializeKey(key, value: value, at: i.offset)
-      ++native.count
+      native.count += 1
     }
 %end
 
@@ -3234,7 +3234,7 @@ internal enum _Variant${Self}Storage<${TypeParametersDecl}> : _HashStorageType {
 
     // remove the element
     nativeStorage.destroyEntryAt(offset)
-    --nativeStorage.count
+    nativeStorage.count -= 1
 
     // If we've put a hole in a chain of contiguous elements, some
     // element after the hole may belong where the new hole is.
@@ -3409,7 +3409,7 @@ internal enum _Variant${Self}Storage<${TypeParametersDecl}> : _HashStorageType {
       nativeStorage = native
     }
 
-    for var b = 0; b != nativeStorage.capacity; ++b {
+    for var b = 0; b != nativeStorage.capacity; b  += 1 {
       if nativeStorage.isInitializedEntry(b) {
         nativeStorage.destroyEntryAt(b)
       }
@@ -3510,7 +3510,7 @@ internal struct _Native${Self}Index<${TypeParametersDecl}> :
         break
       }
       // end workaround
-      ++i
+      i += 1
     }
     return NativeIndex(nativeStorage: nativeStorage, offset: i)
   }
@@ -3832,7 +3832,7 @@ final internal class _Cocoa${Self}Generator : GeneratorType {
       UnsafeMutablePointer(_fastEnumerationState.itemsPtr)
     let itemsPtr = _UnmanagedAnyObjectArray(itemsPtrUP)
     let key: AnyObject = itemsPtr[itemIndex]
-    ++itemIndex
+    itemIndex += 1
 %if Self == 'Set':
     return key
 %elif Self == 'Dictionary':
@@ -4094,7 +4094,7 @@ public struct _${Self}Builder<${TypeParametersDecl}> {
   public mutating func add(key newKey: Key, value: Value) {
     _nativeStorage.unsafeAddNew(key: newKey, value: value)
 %end
-    _actualCount++
+    _actualCount += 1
   }
 
   @warn_unused_result

stdlib/public/core/Prespecialized.swift

@@ -29,8 +29,8 @@ struct _Prespecialize {
         a[0] = a[j]
       }
 
-      for var i1 = 0; i1 < a.count; ++i1 {
-        for var i2 = 0; i2 < a.count; ++i2 {
+      for var i1 = 0; i1 < a.count; i1 += 1 {
+        for var i2 = 0; i2 < a.count; i2 += 1 {
           a[i1] = a[i2]
         }
       }

stdlib/public/core/Sort.swift.gyb

@@ -74,8 +74,8 @@ func _insertionSort<
 
         // Move y forward
         elements[i] = predecessor
-      }
-      while --i != start
+        i._predecessorInPlace()
+      } while i != start
 
       if i != sortedEnd {
         // Plop x into position
@@ -141,16 +141,18 @@ Loop: while true {
     } while false
 
   FindHi: repeat {
-      while --hi != lo {
+      hi._predecessorInPlace()
+      while hi != lo {
         if ${cmp("elements[hi]", "pivot", p)} { break FindHi }
+        hi._predecessorInPlace()
       }
       break Loop
     } while false
 
     swap(&elements[lo], &elements[hi])
   }
 
-  --lo
+  lo._predecessorInPlace()
   if lo != range.startIndex {
     // swap the pivot into place
     swap(&elements[lo], &elements[range.startIndex])
@@ -263,7 +265,8 @@ func _heapify<
   // any children.
   let root = range.startIndex
   var node = root.advancedBy(C.Index.Distance(range.count.toIntMax()/2))
-  while node-- != root {
+  while node != root {
+    node._predecessorInPlace()
     _siftDown(&elements, node, range ${", &isOrderedBefore" if p else ""})
   }
 }
@@ -278,9 +281,11 @@ func _heapSort<
   var hi = range.endIndex
   let lo = range.startIndex
   _heapify(&elements, range ${", &isOrderedBefore" if p else ""})
-  while --hi != lo {
+  hi._predecessorInPlace()
+  while hi != lo {
     swap(&elements[lo], &elements[hi])
     _siftDown(&elements, lo, lo..<hi ${", &isOrderedBefore" if p else ""})
+    hi._predecessorInPlace()
   }
 }
 

stdlib/public/core/String.swift

@@ -272,7 +272,7 @@ extension String {
     Encoding: UnicodeCodecType
   >(encoding: Encoding.Type) -> Int {
     var codeUnitCount = 0
-    let output: (Encoding.CodeUnit) -> Void = { _ in ++codeUnitCount }
+    let output: (Encoding.CodeUnit) -> Void = { _ in codeUnitCount += 1 }
     self._encode(encoding, output: output)
     return codeUnitCount
   }

stdlib/public/core/StringCharacterView.swift

@@ -182,14 +182,14 @@ extension String.CharacterView : CollectionType {
 
       var graphemeClusterStart = end
 
-      --graphemeClusterStart
+      graphemeClusterStart._predecessorInPlace()
       var gcb0 = graphemeClusterBreakProperty.getPropertyRawValue(
           unicodeScalars[graphemeClusterStart].value)
 
       var graphemeClusterStartUTF16 = graphemeClusterStart._position
 
       while graphemeClusterStart != start {
-        --graphemeClusterStart
+        graphemeClusterStart._predecessorInPlace()
         let gcb1 = graphemeClusterBreakProperty.getPropertyRawValue(
             unicodeScalars[graphemeClusterStart].value)
         if segmenter.isBoundary(gcb1, gcb0) {

stdlib/public/core/StringUnicodeScalarView.swift

@@ -46,7 +46,8 @@ extension String {
         if idx == core.endIndex {
           return nil
         }
-        return self.core[idx++]
+        defer { idx += 1 }
+        return self.core[idx]
       }
     }
 
@@ -73,8 +74,8 @@ extension String {
       /// - Requires: The previous value is representable.
       @warn_unused_result
       public func predecessor() -> Index {
-        var i = _position
-        let codeUnit = _core[--i]
+        var i = _position-1
+        let codeUnit = _core[i]
         if _slowPath((codeUnit >> 10) == 0b1101_11) {
           if i != 0 && (_core[i - 1] >> 10) == 0b1101_10 {
             i -= 1

stdlib/public/core/UnsafePointer.swift.gyb

@@ -210,8 +210,10 @@ ${comment}
     _debugPrecondition(
       source < self || source >= self + count,
       "${Self}.assignBackwardFrom non-preceding overlapping range; use assignFrom instead")
-    for var i = count; --i >= 0; {
+    var i = count-1
+    while i >= 0 {
       self[i] = source[i]
+      i -= 1
     }
   }
 

stdlib/public/core/VarArgs.swift

@@ -403,7 +403,8 @@ final public class VaListBuilder {
       sseRegistersUsed += 1
     }
     else if encoded.count == 1 && gpRegistersUsed < _x86_64CountGPRegisters {
-      storage[gpRegistersUsed++] = encoded[0]
+      storage[gpRegistersUsed] = encoded[0]
+      gpRegistersUsed += 1
     }
     else {
       for w in encoded {