Replace let/nil-check patterns with guard let

stdlib/public/core/ArrayBuffer.swift

@@ -247,29 +247,26 @@ extension _ArrayBuffer {
       // Look for contiguous storage in the NSArray
       let nonNative = self._nonNative
       let cocoa = _CocoaArrayWrapper(nonNative)
-      let cocoaStorageBaseAddress = cocoa.contiguousStorage(self.indices)
-
-      if cocoaStorageBaseAddress != nil {
-        return _SliceBuffer(
-          owner: nonNative,
-          subscriptBaseAddress: UnsafeMutablePointer(cocoaStorageBaseAddress),
-          indices: subRange,
-          hasNativeBuffer: false)
+      guard let cocoaStorageBaseAddress = cocoa.contiguousStorage(self.indices) else {
+        // No contiguous storage found; we must allocate
+        let subRangeCount = subRange.count
+        let result = _ContiguousArrayBuffer<Element>(
+          count: subRangeCount, minimumCapacity: 0)
+
+        // Tell Cocoa to copy the objects into our storage
+        cocoa.buffer.getObjects(
+          UnsafeMutablePointer(result.firstElementAddress),
+          range: _SwiftNSRange(
+            location: subRange.startIndex,
+            length: subRangeCount))
+
+        return _SliceBuffer(result, shiftedToStartIndex: subRange.startIndex)
       }
-
-      // No contiguous storage found; we must allocate
-      let subRangeCount = subRange.count
-      let result = _ContiguousArrayBuffer<Element>(
-        count: subRangeCount, minimumCapacity: 0)
-
-      // Tell Cocoa to copy the objects into our storage
-      cocoa.buffer.getObjects(
-        UnsafeMutablePointer(result.firstElementAddress),
-        range: _SwiftNSRange(
-          location: subRange.startIndex,
-          length: subRangeCount))
-
-      return _SliceBuffer(result, shiftedToStartIndex: subRange.startIndex)
+      return _SliceBuffer(
+        owner: nonNative,
+        subscriptBaseAddress: UnsafeMutablePointer(cocoaStorageBaseAddress),
+        indices: subRange,
+        hasNativeBuffer: false)
     }
     set {
       fatalError("not implemented")

stdlib/public/core/Collection.swift

@@ -584,19 +584,17 @@ extension SequenceType
   // A fast implementation for when you are backed by a contiguous array.
   public func _initializeTo(ptr: UnsafeMutablePointer<Generator.Element>)
     -> UnsafeMutablePointer<Generator.Element> {
-    let s = self._baseAddressIfContiguous
-    if s != nil {
-      let count = self.count
-      ptr.initializeFrom(s, count: count)
-      _fixLifetime(self._owner)
-      return ptr + count
-    } else {
+    guard let s = self._baseAddressIfContiguous else {
       var p = ptr
       for x in self {
         p++.initialize(x)
       }
       return p
     }
+    let count = self.count
+    ptr.initializeFrom(s, count: count)
+    _fixLifetime(self._owner)
+    return ptr + count
   }
 }
 

stdlib/public/core/Map.swift

@@ -26,11 +26,10 @@ public struct LazyMapGenerator<
   ///   since the copy was made, and no preceding call to `self.next()`
   ///   has returned `nil`.
   public mutating func next() -> Element? {
-    let x = _base.next()
-    if x != nil {
-      return _transform(x!)
+    guard let x = _base.next() else {
+          return nil
     }
-    return nil
+    return _transform(x)
   }
 
   public var base: Base { return _base }

stdlib/public/core/Runtime.swift.gyb

@@ -247,12 +247,11 @@ public // @testable
 func _stdlib_atomicLoadARCRef(
   object target: UnsafeMutablePointer<AnyObject?>
 ) -> AnyObject? {
-  let result = _swift_stdlib_atomicLoadPtrImpl(
-    object: UnsafeMutablePointer(target))
-  if result != nil {
-    return Unmanaged<AnyObject>.fromOpaque(result).takeUnretainedValue()
+  guard let result = _swift_stdlib_atomicLoadPtrImpl(
+    object: UnsafeMutablePointer(target)) {
+    return nil
   }
-  return nil
+  return Unmanaged<AnyObject>.fromOpaque(result).takeUnretainedValue()
 }
 
 % for operation in [ 'Add', 'And', 'Or', 'Xor' ]: