diff --git a/CoreFoundation/Base.subproj/ForFoundationOnly.h b/CoreFoundation/Base.subproj/ForFoundationOnly.h
index a7ec33ea63..0d819de9aa 100644
--- a/CoreFoundation/Base.subproj/ForFoundationOnly.h
+++ b/CoreFoundation/Base.subproj/ForFoundationOnly.h
@@ -588,7 +588,7 @@ enum {
 // This is for NSNumberFormatter use only!
 CF_EXPORT void *_CFNumberFormatterGetFormatter(CFNumberFormatterRef formatter);
 
-CF_EXPORT void _CFDataInit(CFMutableDataRef memory, CFOptionFlags flags, CFIndex capacity, const uint8_t * _Nullable bytes, CFIndex length, Boolean noCopy);
+CF_EXPORT void _CFDataInit(CFMutableDataRef memory, CFOptionFlags flags, CFIndex capacity, const uint8_t *bytes, CFIndex length, Boolean noCopy);
 CF_EXPORT CFRange _CFDataFindBytes(CFDataRef data, CFDataRef dataToFind, CFRange searchRange, CFDataSearchFlags compareOptions);
 
 
diff --git a/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h b/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h
index 8820c68c05..6290f163c9 100644
--- a/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h
+++ b/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h
@@ -54,7 +54,7 @@ struct _NSObjectBridge {
 struct _NSArrayBridge {
     CFIndex (*_Nonnull count)(CFTypeRef obj);
     _Nonnull CFTypeRef (*_Nonnull objectAtIndex)(CFTypeRef obj, CFIndex index);
-    void (*_Nonnull getObjects)(CFTypeRef array, CFRange range, CFTypeRef _Nullable *_Nonnull values);
+    void (*_Nonnull getObjects)(CFTypeRef array, CFRange range, CFTypeRef _Nonnull * _Nonnull values);
 };
 
 struct _NSMutableArrayBridge {
@@ -73,11 +73,11 @@ struct _NSDictionaryBridge {
     CFIndex (*countForKey)(CFTypeRef dictionary, CFTypeRef key);
     bool (*containsKey)(CFTypeRef dictionary, CFTypeRef key);
     _Nullable CFTypeRef (*_Nonnull objectForKey)(CFTypeRef dictionary, CFTypeRef key);
-    bool (*_getValueIfPresent)(CFTypeRef dictionary, CFTypeRef key, CFTypeRef _Nullable *_Nullable value);
+    bool (*_getValueIfPresent)(CFTypeRef dictionary, CFTypeRef key, CFTypeRef _Nonnull * _Nullable value);
     CFIndex (*__getValue)(CFTypeRef dictionary, CFTypeRef value, CFTypeRef key);
     bool (*containsObject)(CFTypeRef dictionary, CFTypeRef value);
     CFIndex (*countForObject)(CFTypeRef dictionary, CFTypeRef value);
-    void (*getObjects)(CFTypeRef dictionary, CFTypeRef _Nullable *_Nullable valuebuf, CFTypeRef _Nullable *_Nullable keybuf);
+    void (*getObjects)(CFTypeRef dictionary, CFTypeRef _Nonnull * _Nonnull valuebuf, CFTypeRef _Nonnull * _Nonnull keybuf);
     void (*__apply)(CFTypeRef dictionary, void (*applier)(CFTypeRef key, CFTypeRef value, void *context), void *context);
 };
 
@@ -104,7 +104,7 @@ struct _NSStringBridge {
     CFIndex (*length)(CFTypeRef str);
     UniChar (*characterAtIndex)(CFTypeRef str, CFIndex idx);
     void (*getCharacters)(CFTypeRef str, CFRange range, UniChar *buffer);
-    CFIndex (*__getBytes)(CFTypeRef str, CFStringEncoding encoding, CFRange range, uint8_t *_Nullable buffer, CFIndex maxBufLen, CFIndex *_Nullable usedBufLen);
+    CFIndex (*__getBytes)(CFTypeRef str, CFStringEncoding encoding, CFRange range, uint8_t *buffer, CFIndex maxBufLen, CFIndex *usedBufLen);
     const char *_Nullable (*_Nonnull _fastCStringContents)(CFTypeRef str);
     const UniChar *_Nullable (*_Nonnull _fastCharacterContents)(CFTypeRef str);
     bool (*_getCString)(CFTypeRef str, char *buffer, size_t len, UInt32 encoding);
@@ -123,7 +123,7 @@ struct _NSMutableStringBridge {
 
 struct _NSXMLParserBridge {
     _CFXMLInterface _Nullable (*_Nonnull currentParser)();
-    _CFXMLInterfaceParserInput _Nullable (*_Nonnull _xmlExternalEntityWithURL)(_CFXMLInterface interface, const char *url, const char * identifier, _CFXMLInterfaceParserContext context, _CFXMLInterfaceExternalEntityLoader originalLoaderFunction);
+    _CFXMLInterfaceParserInput _Nonnull (*_Nonnull _xmlExternalEntityWithURL)(_CFXMLInterface interface, const char *url, const char * identifier, _CFXMLInterfaceParserContext context, _CFXMLInterfaceExternalEntityLoader originalLoaderFunction);
     
     _CFXMLInterfaceParserContext _Nonnull (*_Nonnull getContext)(_CFXMLInterface ctx);
     
@@ -131,7 +131,7 @@ struct _NSXMLParserBridge {
     int (*isStandalone)(_CFXMLInterface ctx);
     int (*hasInternalSubset)(_CFXMLInterface ctx);
     int (*hasExternalSubset)(_CFXMLInterface ctx);
-    _CFXMLInterfaceEntity _Nullable (*_Nonnull getEntity)(_CFXMLInterface ctx, const unsigned char *name);
+    _CFXMLInterfaceEntity _Nonnull (*_Nonnull getEntity)(_CFXMLInterface ctx, const unsigned char *name);
     void (*notationDecl)(_CFXMLInterface ctx,
                          const unsigned char *name,
                          const unsigned char *publicId,
@@ -156,16 +156,16 @@ struct _NSXMLParserBridge {
     void (*endDocument)(_CFXMLInterface ctx);
     void (*startElementNs)(_CFXMLInterface ctx,
                            const unsigned char *localname,
-                           const unsigned char *_Nullable prefix,
+                           const unsigned char *prefix,
                            const unsigned char *URI,
                            int nb_namespaces,
-                           const unsigned char *_Nullable *_Nonnull namespaces,
+                           const unsigned char *_Nonnull *_Nonnull namespaces,
                            int nb_attributes,
                            int nb_defaulted,
-                           const unsigned char *_Nullable *_Nonnull attributes);
+                           const unsigned char *_Nonnull *_Nonnull attributes);
     void (*endElementNs)(_CFXMLInterface ctx,
                          const unsigned char *localname,
-                         const unsigned char *_Nullable prefix,
+                         const unsigned char *prefix,
                          const unsigned char *URI);
     void (*characters)(_CFXMLInterface ctx,
                        const unsigned char *ch,
@@ -239,7 +239,7 @@ extern CFWriteStreamRef _CFWriteStreamCreateFromFileDescriptor(CFAllocatorRef al
 extern _Nullable CFDateRef CFCalendarCopyGregorianStartDate(CFCalendarRef calendar);
 extern void CFCalendarSetGregorianStartDate(CFCalendarRef calendar, CFDateRef date);
 
-CF_PRIVATE CF_EXPORT char *_Nullable *_Nonnull _CFEnviron(void);
+CF_PRIVATE CF_EXPORT char *_Nonnull*_Nonnull _CFEnviron(void);
 
 CF_EXPORT void CFLog1(CFLogLevel lev, CFStringRef message);
 
diff --git a/CoreFoundation/Parsing.subproj/CFXMLInterface.h b/CoreFoundation/Parsing.subproj/CFXMLInterface.h
index 2cc5610314..13d64c66d6 100644
--- a/CoreFoundation/Parsing.subproj/CFXMLInterface.h
+++ b/CoreFoundation/Parsing.subproj/CFXMLInterface.h
@@ -136,7 +136,7 @@ typedef void* _CFXMLEntityPtr;
 typedef void* _CFXMLDTDPtr;
 typedef void* _CFXMLDTDNodePtr;
 
-_CFXMLNodePtr _CFXMLNewNode(_CFXMLNamespacePtr _Nullable namespace, const char* name);
+_CFXMLNodePtr _CFXMLNewNode(_CFXMLNamespacePtr namespace, const char* name);
 _CFXMLNodePtr _CFXMLCopyNode(_CFXMLNodePtr node, bool recursive);
 
 _CFXMLDocPtr _CFXMLNewDoc(const unsigned char* version);
@@ -147,7 +147,7 @@ _CFXMLNodePtr _CFXMLNewProperty(_CFXMLNodePtr _Nullable node, const unsigned cha
 _CFXMLNamespacePtr _CFXMLNewNamespace(_CFXMLNodePtr _Nullable node, const unsigned char* uri, const unsigned char* prefix);
 
 CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLNodeURI(_CFXMLNodePtr node);
-void _CFXMLNodeSetURI(_CFXMLNodePtr node, const unsigned char* _Nullable URI);
+void _CFXMLNodeSetURI(_CFXMLNodePtr node, const unsigned char* URI);
 
 void _CFXMLNodeSetPrivateData(_CFXMLNodePtr node, void* data);
 void* _Nullable  _CFXMLNodeGetPrivateData(_CFXMLNodePtr node);
@@ -156,7 +156,7 @@ CFIndex _CFXMLNodeGetType(_CFXMLNodePtr node);
 const char* _CFXMLNodeGetName(_CFXMLNodePtr node);
 void _CFXMLNodeSetName(_CFXMLNodePtr node, const char* name);
 CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLNodeGetContent(_CFXMLNodePtr node);
-void _CFXMLNodeSetContent(_CFXMLNodePtr node,  const unsigned char* _Nullable content);
+void _CFXMLNodeSetContent(_CFXMLNodePtr node,  const unsigned char* _Nullable  content);
 void _CFXMLUnlinkNode(_CFXMLNodePtr node);
 
 _CFXMLNodePtr _Nullable _CFXMLNodeGetFirstChild(_CFXMLNodePtr node);
@@ -179,13 +179,13 @@ void _CFXMLDocSetRootElement(_CFXMLDocPtr doc, _CFXMLNodePtr node);
 CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDocCharacterEncoding(_CFXMLDocPtr doc);
 void _CFXMLDocSetCharacterEncoding(_CFXMLDocPtr doc,  const unsigned char* _Nullable  encoding);
 CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDocVersion(_CFXMLDocPtr doc);
-void _CFXMLDocSetVersion(_CFXMLDocPtr doc, const unsigned char* _Nullable version);
+void _CFXMLDocSetVersion(_CFXMLDocPtr doc, const unsigned char* version);
 int _CFXMLDocProperties(_CFXMLDocPtr doc);
 void _CFXMLDocSetProperties(_CFXMLDocPtr doc, int newProperties);
 _CFXMLDTDPtr _Nullable _CFXMLDocDTD(_CFXMLDocPtr doc);
 void _CFXMLDocSetDTD(_CFXMLDocPtr doc, _CFXMLDTDPtr _Nullable dtd);
 
-CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLEncodeEntities(_CFXMLDocPtr _Nullable doc, const unsigned char* string);
+CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLEncodeEntities(_CFXMLDocPtr doc, const unsigned char* string);
 _CFXMLEntityPtr _Nullable _CFXMLGetDocEntity(_CFXMLDocPtr doc, const char* entity);
 _CFXMLEntityPtr _Nullable _CFXMLGetDTDEntity(_CFXMLDocPtr doc, const char* entity);
 _CFXMLEntityPtr _Nullable _CFXMLGetParameterEntity(_CFXMLDocPtr doc, const char* entity);
@@ -205,14 +205,14 @@ CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLNodePrefix(_CFXMLNodePtr node);
 
 bool _CFXMLDocValidate(_CFXMLDocPtr doc, CFErrorRef _Nullable * error);
 
-_CFXMLDTDPtr _CFXMLNewDTD(_CFXMLDocPtr _Nullable doc, const unsigned char* name, const unsigned char* publicID, const unsigned char* systemID);
+_CFXMLDTDPtr _CFXMLNewDTD(_CFXMLDocPtr doc, const unsigned char* name, const unsigned char* publicID, const unsigned char* systemID);
 _CFXMLDTDNodePtr _Nullable _CFXMLParseDTDNode(const unsigned char* xmlString);
 _CFXMLDTDPtr _Nullable _CFXMLParseDTD(const unsigned char* URL);
 _CFXMLDTDPtr _Nullable _CFXMLParseDTDFromData(CFDataRef data, CFErrorRef _Nullable * error);
 CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDTDExternalID(_CFXMLDTDPtr dtd);
-void _CFXMLDTDSetExternalID(_CFXMLDTDPtr dtd, const unsigned char* _Nullable externalID);
+void _CFXMLDTDSetExternalID(_CFXMLDTDPtr dtd, const unsigned char* externalID);
 CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDTDSystemID(_CFXMLDTDPtr dtd);
-void _CFXMLDTDSetSystemID(_CFXMLDTDPtr dtd, const unsigned char* _Nullable systemID);
+void _CFXMLDTDSetSystemID(_CFXMLDTDPtr dtd, const unsigned char* systemID);
 
 _CFXMLDTDNodePtr _Nullable _CFXMLDTDGetElementDesc(_CFXMLDTDPtr dtd, const unsigned char* name);
 _CFXMLDTDNodePtr _Nullable _CFXMLDTDGetAttributeDesc(_CFXMLDTDPtr dtd, const unsigned char* elementName, const unsigned char* name);
@@ -220,7 +220,7 @@ _CFXMLDTDNodePtr _Nullable _CFXMLDTDGetNotationDesc(_CFXMLDTDPtr dtd, const unsi
 _CFXMLDTDNodePtr _Nullable _CFXMLDTDGetEntityDesc(_CFXMLDTDPtr dtd, const unsigned char* name);
 _CFXMLDTDNodePtr _Nullable _CFXMLDTDGetPredefinedEntity(const unsigned char* name);
 
-_CFXMLDTDNodePtr _Nullable _CFXMLDTDNewElementDesc(_CFXMLDTDPtr _Nullable dtd, const unsigned char* _Nullable name);
+_CFXMLDTDNodePtr _Nullable _CFXMLDTDNewElementDesc(_CFXMLDTDPtr dtd, const unsigned char* name);
 _CFXMLDTDNodePtr _Nullable _CFXMLDTDNewAttributeDesc(_CFXMLDTDPtr dtd, const unsigned char* name);
 
 CFIndex _CFXMLDTDElementNodeGetType(_CFXMLDTDNodePtr node);
@@ -228,9 +228,9 @@ CFIndex _CFXMLDTDEntityNodeGetType(_CFXMLDTDNodePtr node);
 CFIndex _CFXMLDTDAttributeNodeGetType(_CFXMLDTDNodePtr node);
 
 CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDTDNodeGetSystemID(_CFXMLDTDNodePtr node);
-void _CFXMLDTDNodeSetSystemID(_CFXMLDTDNodePtr node, const unsigned char* _Nullable systemID);
+void _CFXMLDTDNodeSetSystemID(_CFXMLDTDNodePtr node, const unsigned char* systemID);
 CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDTDNodeGetPublicID(_CFXMLDTDNodePtr node);
-void _CFXMLDTDNodeSetPublicID(_CFXMLDTDNodePtr node, const unsigned char* _Nullable publicID);
+void _CFXMLDTDNodeSetPublicID(_CFXMLDTDNodePtr node, const unsigned char* publicID);
 
 void _CFXMLFreeNode(_CFXMLNodePtr node);
 void _CFXMLFreeDocument(_CFXMLDocPtr doc);
diff --git a/Foundation/NSArray.swift b/Foundation/NSArray.swift
index d85e73d9d0..d14763eb3c 100644
--- a/Foundation/NSArray.swift
+++ b/Foundation/NSArray.swift
@@ -55,7 +55,7 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS
     }
     
     public convenience override init() {
-        self.init(objects: [], count:0)
+        self.init(objects: nil, count:0)
     }
     
     public required init(objects: UnsafePointer<AnyObject?>, count cnt: Int) {
@@ -359,13 +359,13 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS
         return NSData(bytesNoCopy: unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), length: count * sizeof(Int), freeWhenDone: true)
     }
     
-    public func sortedArrayUsingFunction(_ comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>?) -> Int, context: UnsafeMutablePointer<Void>?) -> [AnyObject] {
+    public func sortedArrayUsingFunction(_ comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Int, context: UnsafeMutablePointer<Void>) -> [AnyObject] {
         return sortedArrayWithOptions([]) { lhs, rhs in
             return NSComparisonResult(rawValue: comparator(lhs, rhs, context))!
         }
     }
     
-    public func sortedArrayUsingFunction(_ comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>?) -> Int, context: UnsafeMutablePointer<Void>?, hint: NSData?) -> [AnyObject] {
+    public func sortedArrayUsingFunction(_ comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Int, context: UnsafeMutablePointer<Void>, hint: NSData?) -> [AnyObject] {
         return sortedArrayWithOptions([]) { lhs, rhs in
             return NSComparisonResult(rawValue: comparator(lhs, rhs, context))!
         }
@@ -653,7 +653,7 @@ public class NSMutableArray : NSArray {
     }
     
     public init(capacity numItems: Int) {
-        super.init(objects: [], count: 0)
+        super.init(objects: nil, count: 0)
 
         if self.dynamicType === NSMutableArray.self {
             _storage.reserveCapacity(numItems)
@@ -807,7 +807,7 @@ public class NSMutableArray : NSArray {
         }
     }
 
-    public func sortUsingFunction(_ compare: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>?) -> Int, context: UnsafeMutablePointer<Void>?) {
+    public func sortUsingFunction(_ compare: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Int, context: UnsafeMutablePointer<Void>) {
         self.setArray(self.sortedArrayUsingFunction(compare, context: context))
     }
 
diff --git a/Foundation/NSCFArray.swift b/Foundation/NSCFArray.swift
index f3e09fe774..1440980e80 100644
--- a/Foundation/NSCFArray.swift
+++ b/Foundation/NSCFArray.swift
@@ -89,7 +89,7 @@ internal func _CFSwiftArrayRemoveAllValues(_ array: AnyObject) {
     (array as! NSMutableArray).removeAllObjects()
 }
 
-internal func _CFSwiftArrayReplaceValues(_ array: AnyObject, _ range: CFRange, _ newValues: UnsafeMutablePointer<Unmanaged<AnyObject>>, _ newCount: CFIndex) {
+internal func _CFSwiftArrayReplaceValues(_ array: AnyObject, _ range: CFRange, _ newValues: UnsafeMutablePointer<Unmanaged<AnyObject>?>, _ newCount: CFIndex) {
     NSUnimplemented()
 //    (array as! NSMutableArray).replaceObjectsInRange(NSMakeRange(range.location, range.length), withObjectsFromArray: newValues.array(newCount))
 }
diff --git a/Foundation/NSCFDictionary.swift b/Foundation/NSCFDictionary.swift
index d68a73b854..7c82de9e17 100644
--- a/Foundation/NSCFDictionary.swift
+++ b/Foundation/NSCFDictionary.swift
@@ -64,11 +64,11 @@ internal final class _NSCFDictionary : NSMutableDictionary {
             let cf = dict._cfObject
             count = CFDictionaryGetCount(cf)
             
-            let keys = UnsafeMutablePointer<UnsafePointer<Void>?>(allocatingCapacity: count)            
+            let keys = UnsafeMutablePointer<UnsafePointer<Void>>(allocatingCapacity: count)            
             CFDictionaryGetKeysAndValues(cf, keys, nil)
             
             for idx in 0..<count {
-                let key = unsafeBitCast(keys.advanced(by: idx).pointee!, to: NSObject.self)
+                let key = unsafeBitCast(keys.advanced(by: idx).pointee, to: NSObject.self)
                 keyArray.append(key)
             }
             keys.deinitialize()
@@ -118,12 +118,12 @@ internal func _CFSwiftDictionaryGetValue(_ dictionary: AnyObject, key: AnyObject
     }
 }
 
-internal func _CFSwiftDictionaryGetValueIfPresent(_ dictionary: AnyObject, key: AnyObject, value: UnsafeMutablePointer<Unmanaged<AnyObject>?>?) -> Bool {
+internal func _CFSwiftDictionaryGetValueIfPresent(_ dictionary: AnyObject, key: AnyObject, value: UnsafeMutablePointer<Unmanaged<AnyObject>?>) -> Bool {
     if let val = _CFSwiftDictionaryGetValue(dictionary, key: key) {
-        value?.pointee = val
+        value.pointee = val
         return true
     } else {
-        value?.pointee = nil
+        value.pointee = nil
         return false
     }
 }
@@ -140,14 +140,18 @@ internal func _CFSwiftDictionaryContainsValue(_ dictionary: AnyObject, value: An
     NSUnimplemented()
 }
 
-internal func _CFSwiftDictionaryGetValuesAndKeys(_ dictionary: AnyObject, valuebuf: UnsafeMutablePointer<Unmanaged<AnyObject>?>?, keybuf: UnsafeMutablePointer<Unmanaged<AnyObject>?>?) {
+internal func _CFSwiftDictionaryGetValuesAndKeys(_ dictionary: AnyObject, valuebuf: UnsafeMutablePointer<Unmanaged<AnyObject>?>, keybuf: UnsafeMutablePointer<Unmanaged<AnyObject>?>) {
     var idx = 0
     if valuebuf == nil && keybuf == nil {
         return
     }
     (dictionary as! NSDictionary).enumerateKeysAndObjectsUsingBlock { key, value, _ in
-        valuebuf?[idx] = Unmanaged<AnyObject>.passUnretained(value)
-        keybuf?[idx] = Unmanaged<AnyObject>.passUnretained(key)
+	if valuebuf != nil {
+	    valuebuf[idx] = Unmanaged<AnyObject>.passUnretained(value)
+	}
+	if keybuf != nil {
+	    keybuf[idx] = Unmanaged<AnyObject>.passUnretained(key)
+	}
         idx += 1
     }
 }
diff --git a/Foundation/NSCFString.swift b/Foundation/NSCFString.swift
index 4fb5640b81..2cb2747e5a 100644
--- a/Foundation/NSCFString.swift
+++ b/Foundation/NSCFString.swift
@@ -125,24 +125,26 @@ internal func _CFSwiftStringGetCharacters(_ str: AnyObject, range: CFRange, buff
     (str as! NSString).getCharacters(buffer, range: NSMakeRange(range.location, range.length))
 }
 
-internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncoding, range: CFRange, buffer: UnsafeMutablePointer<UInt8>?, maxBufLen: CFIndex, usedBufLen: UnsafeMutablePointer<CFIndex>?) -> CFIndex {
+internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncoding, range: CFRange, buffer: UnsafeMutablePointer<UInt8>, maxBufLen: CFIndex, usedBufLen: UnsafeMutablePointer<CFIndex>) -> CFIndex {
     switch encoding {
         // TODO: Don't treat many encodings like they are UTF8
     case CFStringEncoding(kCFStringEncodingUTF8), CFStringEncoding(kCFStringEncodingISOLatin1), CFStringEncoding(kCFStringEncodingMacRoman), CFStringEncoding(kCFStringEncodingASCII), CFStringEncoding(kCFStringEncodingNonLossyASCII):
         let encodingView = (str as! NSString)._swiftObject.utf8
         let start = encodingView.startIndex
-        if let buffer = buffer {
+        if buffer != nil {
             for idx in 0..<range.length {
                 let character = encodingView[start.advanced(by: idx + range.location)]
                 buffer.advanced(by: idx).initialize(with: character)
             }
         }
-        usedBufLen?.pointee = range.length
+        if usedBufLen != nil {
+            usedBufLen.pointee = range.length
+        }
         
     case CFStringEncoding(kCFStringEncodingUTF16):
         let encodingView = (str as! NSString)._swiftObject.utf16
         let start = encodingView.startIndex
-        if let buffer = buffer {
+        if buffer != nil {
             for idx in 0..<range.length {
                 // Since character is 2 bytes but the buffer is in term of 1 byte values, we have to split it up
                 let character = encodingView[start.advanced(by: idx + range.location)]
@@ -152,8 +154,10 @@ internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncodin
                 buffer.advanced(by: (idx * 2) + 1).initialize(with: byte1)
             }
         }
-        // Every character was 2 bytes
-        usedBufLen?.pointee = range.length * 2
+        if usedBufLen != nil {
+            // Every character was 2 bytes
+            usedBufLen.pointee = range.length * 2
+        }
 
 
     default:
@@ -176,11 +180,11 @@ internal func _CFSwiftStringCreateMutableCopy(_ str: AnyObject) -> Unmanaged<Any
     return Unmanaged<AnyObject>.passRetained((str as! NSString).mutableCopyWithZone(nil))
 }
 
-internal func _CFSwiftStringFastCStringContents(_ str: AnyObject) -> UnsafePointer<Int8>? {
+internal func _CFSwiftStringFastCStringContents(_ str: AnyObject) -> UnsafePointer<Int8> {
     return (str as! NSString)._fastCStringContents
 }
 
-internal func _CFSwiftStringFastContents(_ str: AnyObject) -> UnsafePointer<UniChar>? {
+internal func _CFSwiftStringFastContents(_ str: AnyObject) -> UnsafePointer<UniChar> {
     return (str as! NSString)._fastContents
 }
 
diff --git a/Foundation/NSCalendar.swift b/Foundation/NSCalendar.swift
index 77da27926b..642f14dd6c 100644
--- a/Foundation/NSCalendar.swift
+++ b/Foundation/NSCalendar.swift
@@ -96,11 +96,11 @@ public struct NSCalendarOptions : OptionSet {
 public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
     typealias CFType = CFCalendar
     private var _base = _CFInfo(typeID: CFCalendarGetTypeID())
-    private var _identifier: UnsafeMutablePointer<Void>? = nil
-    private var _locale: UnsafeMutablePointer<Void>? = nil
-    private var _localeID: UnsafeMutablePointer<Void>? = nil
-    private var _tz: UnsafeMutablePointer<Void>? = nil
-    private var _cal: UnsafeMutablePointer<Void>? = nil
+    private var _identifier: UnsafeMutablePointer<Void> = nil
+    private var _locale: UnsafeMutablePointer<Void> = nil
+    private var _localeID: UnsafeMutablePointer<Void> = nil
+    private var _tz: UnsafeMutablePointer<Void> = nil
+    private var _cal: UnsafeMutablePointer<Void> = nil
     
     internal var _cfObject: CFType {
         return unsafeBitCast(self, to: CFCalendar.self)
@@ -435,7 +435,7 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
         var at: CFAbsoluteTime = 0.0
         let res: Bool = withUnsafeMutablePointer(&at) { t in
             return vector.withUnsafeMutableBufferPointer { (vectorBuffer: inout UnsafeMutableBufferPointer<Int32>) in
-                return _CFCalendarComposeAbsoluteTimeV(_cfObject, t, compDesc, vectorBuffer.baseAddress!, Int32(vectorBuffer.count))
+                return _CFCalendarComposeAbsoluteTimeV(_cfObject, t, compDesc, vectorBuffer.baseAddress, Int32(vector.count))
             }
         }
         
@@ -519,11 +519,11 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
         var ints = [Int32](repeating: 0, count: 20)
         let res = ints.withUnsafeMutableBufferPointer { (intArrayBuffer: inout UnsafeMutableBufferPointer<Int32>) -> Bool in
             var vector: [UnsafeMutablePointer<Int32>] = (0..<20).map { idx in
-                intArrayBuffer.baseAddress!.advanced(by: idx)
+                intArrayBuffer.baseAddress.advanced(by: idx)
             }
 
             return vector.withUnsafeMutableBufferPointer { (vecBuffer: inout UnsafeMutableBufferPointer<UnsafeMutablePointer<Int32>>) in
-                return _CFCalendarDecomposeAbsoluteTimeV(_cfObject, date.timeIntervalSinceReferenceDate, compDesc, vecBuffer.baseAddress!, Int32(compDesc.count - 1))
+                return _CFCalendarDecomposeAbsoluteTimeV(_cfObject, date.timeIntervalSinceReferenceDate, compDesc, vecBuffer.baseAddress, Int32(compDesc.count - 1))
             }
         }
         if res {
@@ -539,7 +539,7 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
         
         let res: Bool = withUnsafeMutablePointer(&at) { t in
             return vector.withUnsafeMutableBufferPointer { (vectorBuffer: inout UnsafeMutableBufferPointer<Int32>) in
-                return _CFCalendarAddComponentsV(_cfObject, t, CFOptionFlags(opts.rawValue), compDesc, vectorBuffer.baseAddress!, Int32(vector.count))
+                return _CFCalendarAddComponentsV(_cfObject, t, CFOptionFlags(opts.rawValue), compDesc, vectorBuffer.baseAddress, Int32(vector.count))
             }
         }
         
@@ -555,11 +555,11 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
         var ints = [Int32](repeating: 0, count: 20)
         let res = ints.withUnsafeMutableBufferPointer { (intArrayBuffer: inout UnsafeMutableBufferPointer<Int32>) -> Bool in
             var vector: [UnsafeMutablePointer<Int32>] = (0..<20).map { idx in
-                return intArrayBuffer.baseAddress!.advanced(by: idx)
+                return intArrayBuffer.baseAddress.advanced(by: idx)
             }
 
             return vector.withUnsafeMutableBufferPointer { (vecBuffer: inout UnsafeMutableBufferPointer<UnsafeMutablePointer<Int32>>) in
-                _CFCalendarGetComponentDifferenceV(_cfObject, startingDate.timeIntervalSinceReferenceDate, resultDate.timeIntervalSinceReferenceDate, CFOptionFlags(opts.rawValue), compDesc, vecBuffer.baseAddress!, Int32(vector.count))
+                _CFCalendarGetComponentDifferenceV(_cfObject, startingDate.timeIntervalSinceReferenceDate, resultDate.timeIntervalSinceReferenceDate, CFOptionFlags(opts.rawValue), compDesc, vecBuffer.baseAddress, Int32(vector.count))
                 return false
             }
         }
@@ -573,12 +573,20 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
     This API is a convenience for getting era, year, month, and day of a given date.
     Pass NULL for a NSInteger pointer parameter if you don't care about that value.
     */
-    public func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>?, year yearValuePointer: UnsafeMutablePointer<Int>?, month monthValuePointer: UnsafeMutablePointer<Int>?, day dayValuePointer: UnsafeMutablePointer<Int>?, fromDate date: NSDate) {
+    public func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>, year yearValuePointer: UnsafeMutablePointer<Int>, month monthValuePointer: UnsafeMutablePointer<Int>, day dayValuePointer: UnsafeMutablePointer<Int>, fromDate date: NSDate) {
         if let comps = components([.Era, .Year, .Month, .Day], fromDate: date) {
-            eraValuePointer?.pointee = comps.era
-            yearValuePointer?.pointee = comps.year
-            monthValuePointer?.pointee = comps.month
-            dayValuePointer?.pointee = comps.day
+            if eraValuePointer != nil {
+                eraValuePointer.pointee = comps.era
+            }
+            if yearValuePointer != nil {
+                yearValuePointer.pointee = comps.year
+            }
+            if monthValuePointer != nil {
+                monthValuePointer.pointee = comps.month
+            }
+            if dayValuePointer != nil {
+                dayValuePointer.pointee = comps.day
+            }
         }
     }
     
@@ -586,12 +594,20 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
     This API is a convenience for getting era, year for week-of-year calculations, week of year, and weekday of a given date.
     Pass NULL for a NSInteger pointer parameter if you don't care about that value.
     */
-    public func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>?, yearForWeekOfYear yearValuePointer: UnsafeMutablePointer<Int>?, weekOfYear weekValuePointer: UnsafeMutablePointer<Int>?, weekday weekdayValuePointer: UnsafeMutablePointer<Int>?, fromDate date: NSDate) {
+    public func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>, yearForWeekOfYear yearValuePointer: UnsafeMutablePointer<Int>, weekOfYear weekValuePointer: UnsafeMutablePointer<Int>, weekday weekdayValuePointer: UnsafeMutablePointer<Int>, fromDate date: NSDate) {
         if let comps = components([.Era, .YearForWeekOfYear, .WeekOfYear, .Weekday], fromDate: date) {
-            eraValuePointer?.pointee = comps.era
-            yearValuePointer?.pointee = comps.yearForWeekOfYear
-            weekValuePointer?.pointee = comps.weekOfYear
-            weekdayValuePointer?.pointee = comps.weekday
+            if eraValuePointer != nil {
+                eraValuePointer.pointee = comps.era
+            }
+            if yearValuePointer != nil {
+                yearValuePointer.pointee = comps.yearForWeekOfYear
+            }
+            if weekValuePointer != nil {
+                weekValuePointer.pointee = comps.weekOfYear
+            }
+            if weekdayValuePointer != nil {
+                weekdayValuePointer.pointee = comps.weekday
+            }
         }
     }
     
@@ -599,12 +615,20 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
     This API is a convenience for getting hour, minute, second, and nanoseconds of a given date.
     Pass NULL for a NSInteger pointer parameter if you don't care about that value.
     */
-    public func getHour(_ hourValuePointer: UnsafeMutablePointer<Int>?, minute minuteValuePointer: UnsafeMutablePointer<Int>?, second secondValuePointer: UnsafeMutablePointer<Int>?, nanosecond nanosecondValuePointer: UnsafeMutablePointer<Int>?, fromDate date: NSDate) {
+    public func getHour(_ hourValuePointer: UnsafeMutablePointer<Int>, minute minuteValuePointer: UnsafeMutablePointer<Int>, second secondValuePointer: UnsafeMutablePointer<Int>, nanosecond nanosecondValuePointer: UnsafeMutablePointer<Int>, fromDate date: NSDate) {
         if let comps = components([.Hour, .Minute, .Second, .Nanosecond], fromDate: date) {
-            hourValuePointer?.pointee = comps.hour
-            minuteValuePointer?.pointee = comps.minute
-            secondValuePointer?.pointee = comps.second
-            nanosecondValuePointer?.pointee = comps.nanosecond
+            if hourValuePointer != nil {
+                hourValuePointer.pointee = comps.hour
+            }
+            if minuteValuePointer != nil {
+                minuteValuePointer.pointee = comps.minute
+            }
+            if secondValuePointer != nil {
+                secondValuePointer.pointee = comps.second
+            }
+            if nanosecondValuePointer != nil {
+                nanosecondValuePointer.pointee = comps.nanosecond
+            }
         }
     }
     
diff --git a/Foundation/NSCharacterSet.swift b/Foundation/NSCharacterSet.swift
index c0d49dcfa2..41c7e9158d 100644
--- a/Foundation/NSCharacterSet.swift
+++ b/Foundation/NSCharacterSet.swift
@@ -33,9 +33,9 @@ public class NSCharacterSet : NSObject, NSCopying, NSMutableCopying, NSCoding {
     typealias CFType = CFCharacterSet
     private var _base = _CFInfo(typeID: CFCharacterSetGetTypeID())
     private var _hashValue = CFHashCode(0)
-    private var _buffer: UnsafeMutablePointer<Void>? = nil
+    private var _buffer: UnsafeMutablePointer<Void> = nil
     private var _length = CFIndex(0)
-    private var _annex: UnsafeMutablePointer<Void>? = nil
+    private var _annex: UnsafeMutablePointer<Void> = nil
     
     internal var _cfObject: CFType {
         return unsafeBitCast(self, to: CFType.self)
diff --git a/Foundation/NSCoder.swift b/Foundation/NSCoder.swift
index 2e753a4ba8..933ca3d10a 100644
--- a/Foundation/NSCoder.swift
+++ b/Foundation/NSCoder.swift
@@ -130,15 +130,12 @@ public class NSCoder : NSObject {
         encodeValueOfObjCType("[\(count)\(String(cString: type))]", at: array)
     }
     
-    public func encodeBytes(_ byteaddr: UnsafePointer<Void>?, length: Int) {
+    public func encodeBytes(_ byteaddr: UnsafePointer<Void>, length: Int) {
         var newLength = UInt32(length)
         withUnsafePointer(&newLength) { (ptr: UnsafePointer<UInt32>) -> Void in
             encodeValueOfObjCType("I", at: ptr)
         }
-        var empty: [Int8] = []
-        withUnsafePointer(&empty) {
-            encodeArrayOfObjCType("c", count: length, at: byteaddr ?? UnsafePointer($0))
-        }
+        encodeArrayOfObjCType("c", count: length, at: byteaddr)
     }
     
     public func decodeObject() -> AnyObject? {
@@ -254,7 +251,7 @@ public class NSCoder : NSObject {
         NSRequiresConcreteImplementation()
     }
     
-    public func decodeBytesForKey(_ key: String, returnedLength lengthp: UnsafeMutablePointer<Int>?) -> UnsafePointer<UInt8>? { // returned bytes immutable!
+    public func decodeBytesForKey(_ key: String, returnedLength lengthp: UnsafeMutablePointer<Int>) -> UnsafePointer<UInt8> { // returned bytes immutable!
         NSRequiresConcreteImplementation()
     }
     
diff --git a/Foundation/NSConcreteValue.swift b/Foundation/NSConcreteValue.swift
index 9385a2db60..ab8247f1f3 100644
--- a/Foundation/NSConcreteValue.swift
+++ b/Foundation/NSConcreteValue.swift
@@ -92,7 +92,9 @@ internal class NSConcreteValue : NSValue {
         self._typeInfo = typeInfo!
 
         self._storage = UnsafeMutablePointer<UInt8>(allocatingCapacity: self._typeInfo.size)
-        self._storage.initializeFrom(unsafeBitCast(value, to: UnsafeMutablePointer<UInt8>.self), count: self._typeInfo.size)
+        if value != nil {
+            self._storage.initializeFrom(unsafeBitCast(value, to: UnsafeMutablePointer<UInt8>.self), count: self._typeInfo.size)
+        }
     }
 
     deinit {
@@ -105,7 +107,7 @@ internal class NSConcreteValue : NSValue {
     }
     
     override var objCType : UnsafePointer<Int8> {
-        return NSString(self._typeInfo.name).UTF8String! // XXX leaky
+        return NSString(self._typeInfo.name).UTF8String // XXX leaky
     }
     
     override var classForCoder: AnyClass {
@@ -125,9 +127,8 @@ internal class NSConcreteValue : NSValue {
             }
             
             let typep = type._swiftObject
-
-            // FIXME: This will result in reading garbage memory.
-            self.init(bytes: [], objCType: typep)
+            
+            self.init(bytes: nil, objCType: typep)
             aDecoder.decodeValueOfObjCType(typep, at: self.value)
         }
     }
diff --git a/Foundation/NSData.swift b/Foundation/NSData.swift
index 30ce04b0c8..534193899a 100644
--- a/Foundation/NSData.swift
+++ b/Foundation/NSData.swift
@@ -75,21 +75,20 @@ public class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
     private var _base = _CFInfo(typeID: CFDataGetTypeID())
     private var _length: CFIndex = 0
     private var _capacity: CFIndex = 0
-    private var _deallocator: UnsafeMutablePointer<Void>? = nil // for CF only
+    private var _deallocator: UnsafeMutablePointer<Void> = nil // for CF only
     private var _deallocHandler: _NSDataDeallocator? = _NSDataDeallocator() // for Swift
-    private var _bytes: UnsafeMutablePointer<UInt8>? = nil
+    private var _bytes: UnsafeMutablePointer<UInt8> = nil
     
     internal var _cfObject: CFType {
         if self.dynamicType === NSData.self || self.dynamicType === NSMutableData.self {
             return unsafeBitCast(self, to: CFType.self)
         } else {
-            return CFDataCreate(kCFAllocatorSystemDefault, UnsafePointer<UInt8>(self.bytes), self.length)
+            return CFDataCreate(kCFAllocatorSystemDefault, unsafeBitCast(self.bytes, to: UnsafePointer<UInt8>.self), self.length)
         }
     }
     
     public override required convenience init() {
-        let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutablePointer<Void>.self)
-        self.init(bytes: dummyPointer, length: 0, copy: false, deallocator: nil)
+        self.init(bytes: nil, length: 0, copy: false, deallocator: nil)
     }
     
     public override var hash: Int {
@@ -105,21 +104,21 @@ public class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
     }
     
     deinit {
-        if let allocatedBytes = _bytes {
-            _deallocHandler?.handler(allocatedBytes, _length)
+        if _bytes != nil {
+            _deallocHandler?.handler(_bytes, _length)
         }
         if self.dynamicType === NSData.self || self.dynamicType === NSMutableData.self {
             _CFDeinit(self._cfObject)
         }
     }
     
-    internal init(bytes: UnsafeMutablePointer<Void>?, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
+    internal init(bytes: UnsafeMutablePointer<Void>, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
         super.init()
         let options : CFOptionFlags = (self.dynamicType == NSMutableData.self) ? __kCFMutable | __kCFGrowable : 0x0
         if copy {
             _CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options, length, UnsafeMutablePointer<UInt8>(bytes), length, false)
             if let handler = deallocator {
-                handler(bytes!, length)
+                handler(bytes, length)
             }
         } else {
             if let handler = deallocator {
@@ -225,7 +224,7 @@ public class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
 
 extension NSData {
     
-    public convenience init(bytes: UnsafePointer<Void>?, length: Int) {
+    public convenience init(bytes: UnsafePointer<Void>, length: Int) {
         self.init(bytes: UnsafeMutablePointer<Void>(bytes), length: length, copy: true, deallocator: nil)
     }
 
@@ -584,7 +583,7 @@ public class NSMutableData : NSData {
         self.init(bytes: nil, length: 0)
     }
     
-    internal override init(bytes: UnsafeMutablePointer<Void>?, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
+    internal override init(bytes: UnsafeMutablePointer<Void>, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
         super.init(bytes: bytes, length: length, copy: copy, deallocator: deallocator)
     }
     
diff --git a/Foundation/NSDictionary.swift b/Foundation/NSDictionary.swift
index f60cf55a24..55d27e88a1 100644
--- a/Foundation/NSDictionary.swift
+++ b/Foundation/NSDictionary.swift
@@ -57,14 +57,14 @@ extension Dictionary : _ObjectTypeBridgeable {
             let cf = x._cfObject
             let cnt = CFDictionaryGetCount(cf)
 
-            let keys = UnsafeMutablePointer<UnsafePointer<Void>?>(allocatingCapacity: cnt)
-            let values = UnsafeMutablePointer<UnsafePointer<Void>?>(allocatingCapacity: cnt)
+            let keys = UnsafeMutablePointer<UnsafePointer<Void>>(allocatingCapacity: cnt)
+            let values = UnsafeMutablePointer<UnsafePointer<Void>>(allocatingCapacity: cnt)
             
             CFDictionaryGetKeysAndValues(cf, keys, values)
             
             for idx in 0..<cnt {
-                let key = unsafeBitCast(keys.advanced(by: idx).pointee!, to: AnyObject.self)
-                let value = unsafeBitCast(values.advanced(by: idx).pointee!, to: AnyObject.self)
+                let key = unsafeBitCast(keys.advanced(by: idx).pointee, to: AnyObject.self)
+                let value = unsafeBitCast(values.advanced(by: idx).pointee, to: AnyObject.self)
                 if let k = key as? Key {
                     if let v = value as? Value {
                         dict[k] = v
@@ -122,7 +122,7 @@ public class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCodin
     }
     
     public override convenience init() {
-        self.init(objects: [], forKeys: [], count: 0)
+        self.init(objects: nil, forKeys: nil, count: 0)
     }
     
     public required init(objects: UnsafePointer<AnyObject>, forKeys keys: UnsafePointer<NSObject>, count cnt: Int) {
@@ -603,8 +603,8 @@ public class NSMutableDictionary : NSDictionary {
         self.init(capacity: 0)
     }
     
-    public convenience init(capacity numItems: Int) {
-        self.init(objects: [], forKeys: [], count: 0)
+    public init(capacity numItems: Int) {
+        super.init(objects: nil, forKeys: nil, count: 0)
     }
     
     public required init(objects: UnsafePointer<AnyObject>, forKeys keys: UnsafePointer<NSObject>, count cnt: Int) {
diff --git a/Foundation/NSFileHandle.swift b/Foundation/NSFileHandle.swift
index 2f701dcf5f..a7c60e5d2b 100644
--- a/Foundation/NSFileHandle.swift
+++ b/Foundation/NSFileHandle.swift
@@ -30,7 +30,7 @@ public class NSFileHandle : NSObject, NSSecureCoding {
     
     public func readDataOfLength(_ length: Int) -> NSData {
         var statbuf = stat()
-        var dynamicBuffer: UnsafeMutablePointer<UInt8>? = nil
+        var dynamicBuffer: UnsafeMutablePointer<UInt8> = nil
         var total = 0
         if _closed || fstat(_fd, &statbuf) < 0 {
             fatalError("Unable to read file")
@@ -45,11 +45,11 @@ public class NSFileHandle : NSObject, NSSecureCoding {
                 // Make sure there is always at least amountToRead bytes available in the buffer.
                 if (currentAllocationSize - total) < amountToRead {
                     currentAllocationSize *= 2
-                    dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer!), currentAllocationSize))
+                    dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer), currentAllocationSize))
                     if dynamicBuffer == nil {
                         fatalError("unable to allocate backing buffer")
                     }
-                    let amtRead = read(_fd, dynamicBuffer!.advanced(by: total), amountToRead)
+                    let amtRead = read(_fd, dynamicBuffer.advanced(by: total), amountToRead)
                     if 0 > amtRead {
                         free(dynamicBuffer)
                         fatalError("read failure")
@@ -81,7 +81,7 @@ public class NSFileHandle : NSObject, NSSecureCoding {
                 }
                 
                 while remaining > 0 {
-                    let count = read(_fd, dynamicBuffer!.advanced(by: total), remaining)
+                    let count = read(_fd, dynamicBuffer.advanced(by: total), remaining)
                     if count < 0 {
                         free(dynamicBuffer)
                         fatalError("Unable to read from fd")
@@ -96,7 +96,7 @@ public class NSFileHandle : NSObject, NSSecureCoding {
         }
 
         if length == Int.max && total > 0 {
-            dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer!), total))
+            dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer), total))
         }
         
         if (0 == total) {
@@ -104,7 +104,7 @@ public class NSFileHandle : NSObject, NSSecureCoding {
         }
         
         if total > 0 {
-            return NSData(bytesNoCopy: UnsafeMutablePointer<Void>(dynamicBuffer!), length: total)
+            return NSData(bytesNoCopy: UnsafeMutablePointer<Void>(dynamicBuffer), length: total)
         }
         
         return NSData()
diff --git a/Foundation/NSFileManager.swift b/Foundation/NSFileManager.swift
index f2c77920a3..977b6d5c36 100644
--- a/Foundation/NSFileManager.swift
+++ b/Foundation/NSFileManager.swift
@@ -248,16 +248,21 @@ public class NSFileManager : NSObject {
         defer {
             closedir(dir)
         }
-
-        while let entry = readdir(dir) {
+        
+        var entry: UnsafeMutablePointer<dirent> = readdir(dir)
+        
+        while entry != nil {
             if let entryName = withUnsafePointer(&entry.pointee.d_name, { (ptr) -> String? in
-                return String(cString: UnsafePointer<Int8>(ptr))
+                let int8Ptr = unsafeBitCast(ptr, to: UnsafePointer<Int8>.self)
+                return String(cString: int8Ptr)
             }) {
                 // TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
                 if entryName != "." && entryName != ".." {
                     contents.append(entryName)
                 }
             }
+            
+            entry = readdir(dir)
         }
         
         return contents
@@ -465,7 +470,7 @@ public class NSFileManager : NSObject {
         } else if errno == ENOTEMPTY {
 
             let fsRep = NSFileManager.defaultManager().fileSystemRepresentationWithPath(path)
-            let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 2)
+            let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: 2)
             ps.initialize(with: UnsafeMutablePointer(fsRep))
             ps.advanced(by: 1).initialize(with: nil)
             let stream = fts_open(ps, FTS_PHYSICAL | FTS_XDEV | FTS_NOCHDIR, nil)
@@ -585,10 +590,10 @@ public class NSFileManager : NSObject {
         return self.fileExistsAtPath(path, isDirectory: nil)
     }
     
-    public func fileExistsAtPath(_ path: String, isDirectory: UnsafeMutablePointer<ObjCBool>?) -> Bool {
+    public func fileExistsAtPath(_ path: String, isDirectory: UnsafeMutablePointer<ObjCBool>) -> Bool {
         var s = stat()
         if lstat(path, &s) >= 0 {
-            if let isDirectory = isDirectory {
+            if isDirectory != nil {
                 if (s.st_mode & S_IFMT) == S_IFLNK {
                     if stat(path, &s) >= 0 {
                         isDirectory.pointee = (s.st_mode & S_IFMT) == S_IFDIR
@@ -693,7 +698,7 @@ public class NSFileManager : NSObject {
         precondition(path != "", "Empty path argument")
         let len = CFStringGetMaximumSizeOfFileSystemRepresentation(path._cfObject)
         if len == kCFNotFound {
-            fatalError("string could not be converted")
+            return nil
         }
         let buf = UnsafeMutablePointer<Int8>(allocatingCapacity: len)
         for i in 0..<len {
@@ -702,7 +707,7 @@ public class NSFileManager : NSObject {
         if !path._nsObject.getFileSystemRepresentation(buf, maxLength: len) {
             buf.deinitialize(count: len)
             buf.deallocateCapacity(len)
-            fatalError("string could not be converted")
+            return nil
         }
         return UnsafePointer(buf)
     }
@@ -894,8 +899,8 @@ internal class NSURLDirectoryEnumerator : NSDirectoryEnumerator {
     var _url : NSURL
     var _options : NSDirectoryEnumerationOptions
     var _errorHandler : ((NSURL, NSError) -> Bool)?
-    var _stream : UnsafeMutablePointer<FTS>? = nil
-    var _current : UnsafeMutablePointer<FTSENT>? = nil
+    var _stream : UnsafeMutablePointer<FTS> = nil
+    var _current : UnsafeMutablePointer<FTSENT> = nil
     var _rootError : NSError? = nil
     var _gotRoot : Bool = false
     
@@ -907,7 +912,7 @@ internal class NSURLDirectoryEnumerator : NSDirectoryEnumerator {
         if let path = _url.path {
             if NSFileManager.defaultManager().fileExistsAtPath(path) {
                 let fsRep = NSFileManager.defaultManager().fileSystemRepresentationWithPath(path)
-                let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 2)
+                let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: 2)
                 ps.initialize(with: UnsafeMutablePointer(fsRep))
                 ps.advanced(by: 1).initialize(with: nil)
                 _stream = fts_open(ps, FTS_PHYSICAL | FTS_XDEV | FTS_NOCHDIR, nil)
@@ -923,50 +928,50 @@ internal class NSURLDirectoryEnumerator : NSDirectoryEnumerator {
     }
     
     deinit {
-        if let stream = _stream {
-            fts_close(stream)
+        if _stream != nil {
+            fts_close(_stream)
         }
     }
     
     override func nextObject() -> AnyObject? {
-        if let stream = _stream {
+        if _stream != nil {
             
             if !_gotRoot  {
                 _gotRoot = true
                 
                 // Skip the root.
-                _current = fts_read(stream)
+                _current = fts_read(_stream)
                 
             }
 
-            _current = fts_read(stream)
-            while let current = _current {
-                switch Int32(current.pointee.fts_info) {
+            _current = fts_read(_stream)
+            while _current != nil {
+                switch Int32(_current.pointee.fts_info) {
                     case FTS_D:
                         if _options.contains(.SkipsSubdirectoryDescendants) {
                             fts_set(_stream, _current, FTS_SKIP)
                         }
                         fallthrough
                     case FTS_DEFAULT, FTS_F, FTS_NSOK, FTS_SL, FTS_SLNONE:
-                        let str = NSString(bytes: current.pointee.fts_path, length: Int(strlen(current.pointee.fts_path)), encoding: NSUTF8StringEncoding)!._swiftObject
+                        let str = NSString(bytes: _current.pointee.fts_path, length: Int(strlen(_current.pointee.fts_path)), encoding: NSUTF8StringEncoding)!._swiftObject
                         return NSURL(fileURLWithPath: str)
                     case FTS_DNR, FTS_ERR, FTS_NS:
                         let keepGoing : Bool
                         if let handler = _errorHandler {
-                            let str = NSString(bytes: current.pointee.fts_path, length: Int(strlen(current.pointee.fts_path)), encoding: NSUTF8StringEncoding)!._swiftObject
-                            keepGoing = handler(NSURL(fileURLWithPath: str), _NSErrorWithErrno(current.pointee.fts_errno, reading: true))
+                            let str = NSString(bytes: _current.pointee.fts_path, length: Int(strlen(_current.pointee.fts_path)), encoding: NSUTF8StringEncoding)!._swiftObject
+                            keepGoing = handler(NSURL(fileURLWithPath: str), _NSErrorWithErrno(_current.pointee.fts_errno, reading: true))
                         } else {
                             keepGoing = true
                         }
                         if !keepGoing {
-                            fts_close(stream)
+                            fts_close(_stream)
                             _stream = nil
                             return nil
                         }
                     default:
                         break
                 }
-                _current = fts_read(stream)
+                _current = fts_read(_stream)
             }
             // TODO: Error handling if fts_read fails.
             
@@ -988,12 +993,16 @@ internal class NSURLDirectoryEnumerator : NSDirectoryEnumerator {
     }
     
     override var level: Int {
-        return Int(_current?.pointee.fts_level ?? 0)
+        if _current != nil {
+            return Int(_current.pointee.fts_level)
+        } else {
+            return 0
+        }
     }
     
     override func skipDescendants() {
-        if let stream = _stream, current = _current {
-            fts_set(stream, current, FTS_SKIP)
+        if _stream != nil && _current != nil {
+            fts_set(_stream, _current, FTS_SKIP)
         }
     }
 }
diff --git a/Foundation/NSHost.swift b/Foundation/NSHost.swift
index 84edbf56ec..ea59c93b47 100644
--- a/Foundation/NSHost.swift
+++ b/Foundation/NSHost.swift
@@ -77,23 +77,24 @@ public class NSHost : NSObject {
             hints.ai_socktype = _CF_SOCK_STREAM()
             hints.ai_flags = flags
             
-            var res0: UnsafeMutablePointer<addrinfo>? = nil
-            let r = getaddrinfo(info, nil, &hints, &res0)
+            var res0: UnsafeMutablePointer<addrinfo> = nil
+            let r = withUnsafeMutablePointers(&hints, &res0) { hintsPtr, res0Ptr in
+                return getaddrinfo(info, nil, hintsPtr, res0Ptr)
+            }
             if r != 0 {
                 return
             }
-            var res: UnsafeMutablePointer<addrinfo>? = res0
+            var res: UnsafeMutablePointer<addrinfo> = res0
             while res != nil {
-                let info = res!.pointee
-                let family = info.ai_family
+                let family = res.pointee.ai_family
                 if family != AF_INET && family != AF_INET6 {
-                    res = info.ai_next
+                    res = res.pointee.ai_next
                     continue
                 }
                 let sa_len: socklen_t = socklen_t((family == AF_INET6) ? sizeof(sockaddr_in6) : sizeof(sockaddr_in))
                 let lookupInfo = { (content: inout [String], flags: Int32) in
                     let hname = UnsafeMutablePointer<Int8>(allocatingCapacity: 1024)
-                    if (getnameinfo(info.ai_addr, sa_len, hname, 1024, nil, 0, flags) == 0) {
+                    if (getnameinfo(res.pointee.ai_addr, sa_len, hname, 1024, nil, 0, flags) == 0) {
                         content.append(String(hname))
                     }
                     hname.deinitialize()
@@ -102,7 +103,7 @@ public class NSHost : NSObject {
                 lookupInfo(&_addresses, NI_NUMERICHOST)
                 lookupInfo(&_names, NI_NAMEREQD)
                 lookupInfo(&_names, NI_NOFQDN|NI_NAMEREQD)
-                res = info.ai_next
+                res = res.pointee.ai_next
             }
             
             freeaddrinfo(res0)
diff --git a/Foundation/NSIndexSet.swift b/Foundation/NSIndexSet.swift
index 6602bdcce1..67c7baa5b9 100644
--- a/Foundation/NSIndexSet.swift
+++ b/Foundation/NSIndexSet.swift
@@ -209,12 +209,12 @@ public class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding
     
     /* Fills up to bufferSize indexes in the specified range into the buffer and returns the number of indexes actually placed in the buffer; also modifies the optional range passed in by pointer to be "positioned" after the last index filled into the buffer.Example: if the index set contains the indexes 0, 2, 4, ..., 98, 100, for a buffer of size 10 and the range (20, 80) the buffer would contain 20, 22, ..., 38 and the range would be modified to (40, 60).
     */
-    public func getIndexes(_ indexBuffer: UnsafeMutablePointer<Int>, maxCount bufferSize: Int, inIndexRange range: NSRangePointer?) -> Int {
+    public func getIndexes(_ indexBuffer: UnsafeMutablePointer<Int>, maxCount bufferSize: Int, inIndexRange range: NSRangePointer) -> Int {
         let minIndex : Int
         let maxIndex : Int
-        if let initialRange = range {
-            minIndex = initialRange.pointee.location
-            maxIndex = NSMaxRange(initialRange.pointee) - 1
+        if range != nil {
+            minIndex = range.pointee.location
+            maxIndex = NSMaxRange(range.pointee) - 1
         } else {
             minIndex = firstIndex
             maxIndex = lastIndex
@@ -250,10 +250,10 @@ public class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding
                 }
             }
             
-            if counter > 0, let resultRange = range {
+            if counter > 0 && range != nil {
                 let delta = indexBuffer.advanced(by: counter - 1).pointee - minIndex + 1
-                resultRange.pointee.location += delta
-                resultRange.pointee.length -= delta
+                range.pointee.location += delta
+                range.pointee.length -= delta
             }
             return counter
         } else {
diff --git a/Foundation/NSJSONSerialization.swift b/Foundation/NSJSONSerialization.swift
index 7fade40bf8..0dce0a6857 100644
--- a/Foundation/NSJSONSerialization.swift
+++ b/Foundation/NSJSONSerialization.swift
@@ -109,7 +109,7 @@ public class NSJSONSerialization : NSObject {
             pretty: opt.contains(.PrettyPrinted),
             writer: { (str: String?) in
                 if let str = str {
-                    result.appendBytes(str.bridge().cStringUsingEncoding(NSUTF8StringEncoding)!, length: str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
+                    result.appendBytes(str.bridge().cStringUsingEncoding(NSUTF8StringEncoding), length: str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
                 }
             }
         )
@@ -455,7 +455,7 @@ private struct JSONReader {
 
         func takeString(_ begin: Index, end: Index) throws -> String {
             let byteLength = begin.distance(to: end)
-            guard let chunk = NSString(bytes: buffer.baseAddress!.advanced(by: begin), length: byteLength, encoding: encoding)?.bridge() else {
+            guard let chunk = NSString(bytes: buffer.baseAddress.advanced(by: begin), length: byteLength, encoding: encoding)?.bridge() else {
                 throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.PropertyListReadCorruptError.rawValue, userInfo: [
                     "NSDebugDescription" : "Unable to convert data to a string using the detected encoding. The data may be corrupt."
                     ])
@@ -627,12 +627,11 @@ private struct JSONReader {
     func parseNumber(_ input: Index) throws -> (Double, Index)? {
         func parseDouble(_ address: UnsafePointer<UInt8>) -> (Double, Index.Distance)? {
             let startPointer = UnsafePointer<Int8>(address)
-            let endPointer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 1)
+            let endPointer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: 1)
             defer { endPointer.deallocateCapacity(1) }
             
             let result = strtod(startPointer, endPointer)
-            let distance = startPointer.distance(to: endPointer[0]!)
-            
+            let distance = startPointer.distance(to: endPointer[0])
             guard distance > 0 else {
                 return nil
             }
@@ -641,7 +640,7 @@ private struct JSONReader {
         }
         
         if source.encoding == NSUTF8StringEncoding {
-            return parseDouble(source.buffer.baseAddress!.advanced(by: input)).map { return ($0.0, input + $0.1) }
+            return parseDouble(source.buffer.baseAddress.advanced(by: input)).map { return ($0.0, input + $0.1) }
         }
         else {
             var numberCharacters = [UInt8]()
@@ -653,7 +652,7 @@ private struct JSONReader {
             
             numberCharacters.append(0)
             
-            return numberCharacters.withUnsafeBufferPointer { parseDouble($0.baseAddress!) }.map { return ($0.0, index) }
+            return numberCharacters.withUnsafeBufferPointer { parseDouble($0.baseAddress) }.map { return ($0.0, index) }
         }
     }
 
diff --git a/Foundation/NSKeyedCoderOldStyleArray.swift b/Foundation/NSKeyedCoderOldStyleArray.swift
index c800f91087..e65e660b15 100644
--- a/Foundation/NSKeyedCoderOldStyleArray.swift
+++ b/Foundation/NSKeyedCoderOldStyleArray.swift
@@ -11,7 +11,7 @@ import CoreFoundation
 
 internal final class _NSKeyedCoderOldStyleArray : NSObject, NSCopying, NSSecureCoding, NSCoding {
 
-    private var _addr : UnsafeMutablePointer<UInt8> // free if decoding
+    private var _addr : UnsafeMutablePointer<UInt8> = nil // free if decoding
     private var _count : Int
     private var _size : Int
     private var _type : _NSSimpleObjCType
diff --git a/Foundation/NSKeyedUnarchiver.swift b/Foundation/NSKeyedUnarchiver.swift
index eefeff41a7..69f44e7dbf 100644
--- a/Foundation/NSKeyedUnarchiver.swift
+++ b/Foundation/NSKeyedUnarchiver.swift
@@ -752,11 +752,11 @@ public class NSKeyedUnarchiver : NSCoder {
     }
     
     // returned bytes immutable, and they go away with the unarchiver, not the containing autorelease pool
-    public override func decodeBytesForKey(_ key: String, returnedLength lengthp: UnsafeMutablePointer<Int>?) -> UnsafePointer<UInt8>? {
+    public override func decodeBytesForKey(_ key: String, returnedLength lengthp: UnsafeMutablePointer<Int>) -> UnsafePointer<UInt8> {
         let ns : NSData? = _decodeValue(forKey: key)
         
         if let value = ns {
-            lengthp?.pointee = Int(value.length)
+            lengthp.pointee = Int(value.length)
             return UnsafePointer<UInt8>(value.bytes)
         }
         
@@ -828,7 +828,7 @@ public class NSKeyedUnarchiver : NSCoder {
             break
         case .CharPtr:
             if let ns = decodeObject() as? NSString {
-                let string = ns.UTF8String! // XXX leaky
+                let string = ns.UTF8String // XXX leaky
                 unsafeBitCast(addr, to: UnsafeMutablePointer<UnsafePointer<Int8>>.self).pointee = string
             }
             break
diff --git a/Foundation/NSLocale.swift b/Foundation/NSLocale.swift
index b8c7d9b10f..d17c098d9e 100644
--- a/Foundation/NSLocale.swift
+++ b/Foundation/NSLocale.swift
@@ -13,9 +13,9 @@ import CoreFoundation
 public class NSLocale : NSObject, NSCopying, NSSecureCoding {
     typealias CFType = CFLocale
     private var _base = _CFInfo(typeID: CFLocaleGetTypeID())
-    private var _identifier: UnsafeMutablePointer<Void>? = nil
-    private var _cache: UnsafeMutablePointer<Void>? = nil
-    private var _prefs: UnsafeMutablePointer<Void>? = nil
+    private var _identifier: UnsafeMutablePointer<Void> = nil
+    private var _cache: UnsafeMutablePointer<Void> = nil
+    private var _prefs: UnsafeMutablePointer<Void> = nil
 #if os(OSX) || os(iOS)
     private var _lock = pthread_mutex_t()
 #elseif os(Linux)
diff --git a/Foundation/NSNumber.swift b/Foundation/NSNumber.swift
index 2b2b63e667..d666046f42 100644
--- a/Foundation/NSNumber.swift
+++ b/Foundation/NSNumber.swift
@@ -281,18 +281,18 @@ public class NSNumber : NSValue {
     
     public required convenience init?(coder aDecoder: NSCoder) {
         if !aDecoder.allowsKeyedCoding {
-            var objCType: UnsafeMutablePointer<Int8>? = nil
-            withUnsafeMutablePointer(&objCType, { (ptr: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>) -> Void in
+            var objCType: UnsafeMutablePointer<Int8> = nil
+            var size: Int = 0
+            NSGetSizeAndAlignment(objCType, &size, nil)
+            let buffer = malloc(size)
+            aDecoder.decodeValueOfObjCType(objCType, at: buffer)
+            withUnsafeMutablePointer(&objCType, { (ptr: UnsafeMutablePointer<UnsafeMutablePointer<Int8>>) -> Void in
                 aDecoder.decodeValueOfObjCType(String(_NSSimpleObjCType.CharPtr), at: UnsafeMutablePointer<Void>(ptr))
             })
             if objCType == nil {
                 return nil
             }
-            var size: Int = 0
-            NSGetSizeAndAlignment(objCType!, &size, nil)
-            let buffer = malloc(size)
-            aDecoder.decodeValueOfObjCType(objCType!, at: buffer)
-            self.init(bytes: buffer, objCType: objCType!)
+            self.init(bytes: buffer, objCType: objCType)
             free(buffer)
         } else if aDecoder.dynamicType == NSKeyedUnarchiver.self || aDecoder.containsValueForKey("NS.number") {
             let number = aDecoder._decodePropertyListForKey("NS.number")
diff --git a/Foundation/NSObjCRuntime.swift b/Foundation/NSObjCRuntime.swift
index 8bf47bc38a..f85464d68b 100644
--- a/Foundation/NSObjCRuntime.swift
+++ b/Foundation/NSObjCRuntime.swift
@@ -116,21 +116,24 @@ internal func _NSGetSizeAndAlignment(_ type: _NSSimpleObjCType,
 }
 
 public func NSGetSizeAndAlignment(_ typePtr: UnsafePointer<Int8>,
-                                  _ sizep: UnsafeMutablePointer<Int>?,
-                                  _ alignp: UnsafeMutablePointer<Int>?) -> UnsafePointer<Int8> {
+                                  _ sizep: UnsafeMutablePointer<Int>,
+                                  _ alignp: UnsafeMutablePointer<Int>) -> UnsafePointer<Int8> {
     let type = _NSSimpleObjCType(UInt8(typePtr.pointee))!
 
     var size : Int = 0
     var align : Int = 0
     
     if !_NSGetSizeAndAlignment(type, &size, &align) {
-        // FIXME: This used to return nil, but the corresponding Darwin
-        // implementation is defined as returning a non-optional value.
-        fatalError("invalid type encoding")
+        return nil
+    }
+    
+    if sizep != nil {
+        sizep.pointee = size
     }
     
-    sizep?.pointee = size
-    alignp?.pointee = align
+    if alignp != nil {
+        alignp.pointee = align
+    }
 
     return typePtr.advanced(by: 1)
 }
diff --git a/Foundation/NSOrderedSet.swift b/Foundation/NSOrderedSet.swift
index d87bcff0aa..54e86b92b6 100644
--- a/Foundation/NSOrderedSet.swift
+++ b/Foundation/NSOrderedSet.swift
@@ -84,7 +84,7 @@ public class NSOrderedSet : NSObject, NSCopying, NSMutableCopying, NSSecureCodin
     }
 
     public convenience override init() {
-        self.init(objects: [], count: 0)
+        self.init(objects: nil, count: 0)
     }
 
     public init(objects: UnsafePointer<AnyObject?>, count cnt: Int) {
@@ -361,7 +361,7 @@ public class NSMutableOrderedSet : NSOrderedSet {
     }
 
     public init(capacity numItems: Int) {
-        super.init(objects: [], count: 0)
+        super.init(objects: nil, count: 0)
     }
 
     required public convenience init(arrayLiteral elements: AnyObject...) {
diff --git a/Foundation/NSPropertyList.swift b/Foundation/NSPropertyList.swift
index 9f61e23fc9..13c223d9a3 100644
--- a/Foundation/NSPropertyList.swift
+++ b/Foundation/NSPropertyList.swift
@@ -64,17 +64,20 @@ public class NSPropertyListSerialization : NSObject {
     }
     
     /// - Experiment: Note that the return type of this function is different than on Darwin Foundation (Any instead of AnyObject). This is likely to change once we have a more complete story for bridging in place.
-    public class func propertyListWithData(_ data: NSData, options opt: NSPropertyListReadOptions, format: UnsafeMutablePointer<NSPropertyListFormat>?) throws -> Any {
+    public class func propertyListWithData(_ data: NSData, options opt: NSPropertyListReadOptions, format: UnsafeMutablePointer<NSPropertyListFormat>) throws -> Any {
         var fmt = kCFPropertyListBinaryFormat_v1_0
         var error: Unmanaged<CFError>? = nil
         let decoded = withUnsafeMutablePointers(&fmt, &error) { (outFmt: UnsafeMutablePointer<CFPropertyListFormat>, outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> NSObject? in
             return unsafeBitCast(CFPropertyListCreateWithData(kCFAllocatorSystemDefault, unsafeBitCast(data, to: CFData.self), CFOptionFlags(CFIndex(opt.rawValue)), outFmt, outErr), to: NSObject.self)
         }
+        if format != nil {
 #if os(OSX) || os(iOS)
-        format?.pointee = NSPropertyListFormat(rawValue: UInt(fmt.rawValue))!
+            format.pointee = NSPropertyListFormat(rawValue: UInt(fmt.rawValue))!
 #else
-        format?.pointee = NSPropertyListFormat(rawValue: UInt(fmt))!
+            format.pointee = NSPropertyListFormat(rawValue: UInt(fmt))!
 #endif
+        }
+
         if let err = error {
             throw err.takeUnretainedValue()._nsObject
         } else {
@@ -82,17 +85,19 @@ public class NSPropertyListSerialization : NSObject {
         }
     }
     
-    internal class func propertyListWithStream(_ stream: CFReadStream, length streamLength: Int, options opt: NSPropertyListReadOptions, format: UnsafeMutablePointer <NSPropertyListFormat>?) throws -> Any {
+    internal class func propertyListWithStream(_ stream: CFReadStream, length streamLength: Int, options opt: NSPropertyListReadOptions, format: UnsafeMutablePointer <NSPropertyListFormat>) throws -> Any {
         var fmt = kCFPropertyListBinaryFormat_v1_0
         var error: Unmanaged<CFError>? = nil
         let decoded = withUnsafeMutablePointers(&fmt, &error) { (outFmt: UnsafeMutablePointer<CFPropertyListFormat>, outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> NSObject? in
             return unsafeBitCast(CFPropertyListCreateWithStream(kCFAllocatorSystemDefault, stream, streamLength, CFOptionFlags(CFIndex(opt.rawValue)), outFmt, outErr), to: NSObject.self)
         }
+        if format != nil {
 #if os(OSX) || os(iOS)
-        format?.pointee = NSPropertyListFormat(rawValue: UInt(fmt.rawValue))!
+            format.pointee = NSPropertyListFormat(rawValue: UInt(fmt.rawValue))!
 #else
-        format?.pointee = NSPropertyListFormat(rawValue: UInt(fmt))!
+            format.pointee = NSPropertyListFormat(rawValue: UInt(fmt))!
 #endif
+        }
         if let err = error {
             throw err.takeUnretainedValue()._nsObject
         } else {
diff --git a/Foundation/NSRegularExpression.swift b/Foundation/NSRegularExpression.swift
index 019411e182..ac9ac7a498 100644
--- a/Foundation/NSRegularExpression.swift
+++ b/Foundation/NSRegularExpression.swift
@@ -118,7 +118,7 @@ internal class _NSRegularExpressionMatcher {
     }
 }
 
-internal func _NSRegularExpressionMatch(_ context: UnsafeMutablePointer<Void>?, ranges: UnsafeMutablePointer<CFRange>?, count: CFIndex, options: _CFRegularExpressionMatchingOptions, stop: UnsafeMutablePointer<_DarwinCompatibleBoolean>) -> Void {
+internal func _NSRegularExpressionMatch(_ context: UnsafeMutablePointer<Void>, ranges: UnsafeMutablePointer<CFRange>, count: CFIndex, options: _CFRegularExpressionMatchingOptions, stop: UnsafeMutablePointer<_DarwinCompatibleBoolean>) -> Void {
     let matcher = unsafeBitCast(context, to: _NSRegularExpressionMatcher.self)
     if ranges == nil {
 #if os(OSX) || os(iOS)
@@ -128,7 +128,7 @@ internal func _NSRegularExpressionMatch(_ context: UnsafeMutablePointer<Void>?,
 #endif
         matcher.block(nil, NSMatchingFlags(rawValue: opts), UnsafeMutablePointer<ObjCBool>(stop))
     } else {
-        let result = NSTextCheckingResult.regularExpressionCheckingResultWithRanges(NSRangePointer(ranges!), count: count, regularExpression: matcher.regex)
+        let result = NSTextCheckingResult.regularExpressionCheckingResultWithRanges(NSRangePointer(ranges), count: count, regularExpression: matcher.regex)
 #if os(OSX) || os(iOS)
         let flags = NSMatchingFlags(rawValue: options.rawValue)
 #else
diff --git a/Foundation/NSScanner.swift b/Foundation/NSScanner.swift
index d863c93016..604285f147 100644
--- a/Foundation/NSScanner.swift
+++ b/Foundation/NSScanner.swift
@@ -95,7 +95,7 @@ internal struct _NSStringBuffer {
             let range = NSMakeRange(_stringLoc, bufferLen)
             bufferLoc = 1
             buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
-                self.string.getCharacters(ptr.baseAddress!, range: range)
+                self.string.getCharacters(ptr.baseAddress, range: range)
             })
             curChar = buffer[0]
         } else {
@@ -115,7 +115,7 @@ internal struct _NSStringBuffer {
             let range = NSMakeRange(_stringLoc, bufferLen)
             bufferLoc = 1
             buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
-                self.string.getCharacters(ptr.baseAddress!, range: range)
+                self.string.getCharacters(ptr.baseAddress, range: range)
             })
             curChar = buffer[0]
         } else {
@@ -137,7 +137,7 @@ internal struct _NSStringBuffer {
         bufferLen = min(32, stringLen - _stringLoc);
         let range = NSMakeRange(_stringLoc, bufferLen)
         buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
-            string.getCharacters(ptr.baseAddress!, range: range)
+            string.getCharacters(ptr.baseAddress, range: range)
         })
         bufferLoc = 1
         curChar = buffer[0]
@@ -166,7 +166,7 @@ internal struct _NSStringBuffer {
             _stringLoc -= bufferLen
             let range = NSMakeRange(_stringLoc, bufferLen)
             buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
-                string.getCharacters(ptr.baseAddress!, range: range)
+                string.getCharacters(ptr.baseAddress, range: range)
             })
         } else {
             bufferLoc = 0
diff --git a/Foundation/NSSet.swift b/Foundation/NSSet.swift
index e20feb2d8b..ed8cbcd09f 100644
--- a/Foundation/NSSet.swift
+++ b/Foundation/NSSet.swift
@@ -43,7 +43,7 @@ extension Set : _ObjectTypeBridgeable {
             let cf = x._cfObject
             let cnt = CFSetGetCount(cf)
             
-            let objs = UnsafeMutablePointer<UnsafePointer<Void>?>(allocatingCapacity: cnt)
+            let objs = UnsafeMutablePointer<UnsafePointer<Void>>(allocatingCapacity: cnt)
             
             CFSetGetValues(cf, objs)
             
@@ -102,7 +102,8 @@ public class NSSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
     }
 
     public convenience override init() {
-        self.init(objects: [], count: 0)
+        let objects: UnsafePointer<AnyObject?> = nil
+        self.init(objects: objects, count: 0)
     }
     
     public init(objects: UnsafePointer<AnyObject?>, count cnt: Int) {
@@ -381,7 +382,7 @@ public class NSMutableSet : NSSet {
     }
     
     public required init(capacity numItems: Int) {
-        super.init(objects: [], count: 0)
+        super.init(objects: nil, count: 0)
     }
     
     public required convenience init?(coder: NSCoder) {
diff --git a/Foundation/NSSpecialValue.swift b/Foundation/NSSpecialValue.swift
index b8833c9301..e3600898e4 100644
--- a/Foundation/NSSpecialValue.swift
+++ b/Foundation/NSSpecialValue.swift
@@ -121,7 +121,7 @@ internal class NSSpecialValue : NSValue {
     
     override var objCType : UnsafePointer<Int8> {
         let typeName = NSSpecialValue._objCTypeFromType(_value.dynamicType)
-        return typeName!.bridge().UTF8String! // leaky
+        return typeName!.bridge().UTF8String // leaky
     }
     
     override var classForCoder: AnyClass {
diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift
index 9324b19946..dbfac9b5b2 100644
--- a/Foundation/NSString.swift
+++ b/Foundation/NSString.swift
@@ -104,7 +104,7 @@ extension String : _ObjectTypeBridgeable {
             let len = x.length
             var characters = [unichar](repeating: 0, count: len)
             result = characters.withUnsafeMutableBufferPointer() { (buffer: inout UnsafeMutableBufferPointer<unichar>) -> String? in
-                x.getCharacters(buffer.baseAddress!, range: NSMakeRange(0, len))
+                x.getCharacters(buffer.baseAddress, range: NSMakeRange(0, len))
                 return String._fromCodeUnitSequence(UTF16.self, input: buffer)
             }
         }
@@ -163,7 +163,7 @@ internal func _createRegexForPattern(_ pattern: String, _ options: NSRegularExpr
     return nil
 }
 
-internal func _bytesInEncoding(_ str: NSString, _ encoding: NSStringEncoding, _ fatalOnError: Bool, _ externalRep: Bool, _ lossy: Bool) -> UnsafePointer<Int8>? {
+internal func _bytesInEncoding(_ str: NSString, _ encoding: NSStringEncoding, _ fatalOnError: Bool, _ externalRep: Bool, _ lossy: Bool) -> UnsafePointer<Int8> {
     let theRange = NSMakeRange(0, str.length)
     var cLength = 0
     var used = 0
@@ -253,7 +253,7 @@ public class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, N
             self.init(string: str)
         } else {
             var length = 0
-            let buffer = UnsafeMutablePointer<Void>(aDecoder.decodeBytesForKey("NS.bytes", returnedLength: &length)!)
+            let buffer = UnsafeMutablePointer<Void>(aDecoder.decodeBytesForKey("NS.bytes", returnedLength: &length))
             self.init(bytes: buffer, length: length, encoding: NSUTF8StringEncoding)
         }
     }
@@ -276,7 +276,8 @@ public class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, N
     
     public func mutableCopyWithZone(_ zone: NSZone) -> AnyObject {
         if self.dynamicType === NSString.self || self.dynamicType === NSMutableString.self {
-            if let contents = _fastContents {
+            let contents = _fastContents
+            if contents != nil {
                 return NSMutableString(characters: contents, length: length)
             }
         }
@@ -316,7 +317,7 @@ public class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, N
         _storage = String(value)
     }
     
-    internal var _fastCStringContents: UnsafePointer<Int8>? {
+    internal var _fastCStringContents: UnsafePointer<Int8> {
         if self.dynamicType == NSString.self || self.dynamicType == NSMutableString.self {
             if _storage._core.isASCII {
                 return unsafeBitCast(_storage._core.startASCII, to: UnsafePointer<Int8>.self)
@@ -325,7 +326,7 @@ public class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, N
         return nil
     }
     
-    internal var _fastContents: UnsafePointer<UniChar>? {
+    internal var _fastContents: UnsafePointer<UniChar> {
         if self.dynamicType == NSString.self || self.dynamicType == NSMutableString.self {
             if !_storage._core.isASCII {
                 return unsafeBitCast(_storage._core.startUTF16, to: UnsafePointer<UniChar>.self)
@@ -708,15 +709,19 @@ extension NSString {
         return mutableCopy._swiftObject
     }
     
-    internal func _getBlockStart(_ startPtr: UnsafeMutablePointer<Int>?, end endPtr: UnsafeMutablePointer<Int>?, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>?, forRange range: NSRange, stopAtLineSeparators line: Bool) {
+    internal func _getBlockStart(_ startPtr: UnsafeMutablePointer<Int>, end endPtr: UnsafeMutablePointer<Int>, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>, forRange range: NSRange, stopAtLineSeparators line: Bool) {
         let len = length
         var ch: unichar
         
         precondition(range.length <= len && range.location < len - range.length, "Range {\(range.location), \(range.length)} is out of bounds of length \(len)")
         
         if range.location == 0 && range.length == len && contentsEndPtr == nil { // This occurs often
-            startPtr?.pointee = 0
-            endPtr?.pointee = range.length
+            if startPtr != nil {
+                startPtr.pointee = 0
+            }
+            if endPtr != nil {
+                endPtr.pointee = range.length
+            }
             return
         }
         /* Find the starting point first */
@@ -744,7 +749,7 @@ extension NSString {
                         buf.rewind()
                     }
                 }
-                startPtr!.pointee = start
+                startPtr.pointee = start
             }
         }
 
@@ -781,12 +786,16 @@ extension NSString {
                 }
             }
             
-            contentsEndPtr?.pointee = endOfContents
-            endPtr?.pointee = endOfContents + lineSeparatorLength
+            if contentsEndPtr != nil {
+                contentsEndPtr.pointee = endOfContents
+            }
+            if endPtr != nil {
+                endPtr.pointee = endOfContents + lineSeparatorLength
+            }
         }
     }
     
-    public func getLineStart(_ startPtr: UnsafeMutablePointer<Int>?, end lineEndPtr: UnsafeMutablePointer<Int>?, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>?, forRange range: NSRange) {
+    public func getLineStart(_ startPtr: UnsafeMutablePointer<Int>, end lineEndPtr: UnsafeMutablePointer<Int>, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>, forRange range: NSRange) {
         _getBlockStart(startPtr, end: lineEndPtr, contentsEnd: contentsEndPtr, forRange: range, stopAtLineSeparators: true)
     }
     
@@ -797,7 +806,7 @@ extension NSString {
         return NSMakeRange(start, lineEnd - start)
     }
     
-    public func getParagraphStart(_ startPtr: UnsafeMutablePointer<Int>?, end parEndPtr: UnsafeMutablePointer<Int>?, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>?, forRange range: NSRange) {
+    public func getParagraphStart(_ startPtr: UnsafeMutablePointer<Int>, end parEndPtr: UnsafeMutablePointer<Int>, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>, forRange range: NSRange) {
         _getBlockStart(startPtr, end: parEndPtr, contentsEnd: contentsEndPtr, forRange: range, stopAtLineSeparators: false)
     }
     
@@ -818,7 +827,7 @@ extension NSString {
         }
     }
     
-    public var UTF8String: UnsafePointer<Int8>? {
+    public var UTF8String: UnsafePointer<Int8> {
         return _bytesInEncoding(self, NSUTF8StringEncoding, false, false, false)
     }
     
@@ -871,7 +880,7 @@ extension NSString {
         return __CFStringEncodeByteStream(_cfObject, 0, length, false, CFStringConvertNSStringEncodingToEncoding(encoding), 0, nil, 0, nil) == length
     }
     
-    public func cStringUsingEncoding(_ encoding: UInt) -> UnsafePointer<Int8>? {
+    public func cStringUsingEncoding(_ encoding: UInt) -> UnsafePointer<Int8> {
         return _bytesInEncoding(self, encoding, false, false, false)
     }
     
@@ -893,7 +902,7 @@ extension NSString {
         return false
     }
     
-    public func getBytes(_ buffer: UnsafeMutablePointer<Void>?, maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>?, encoding: UInt, options: NSStringEncodingConversionOptions, range: NSRange, remainingRange leftover: NSRangePointer?) -> Bool {
+    public func getBytes(_ buffer: UnsafeMutablePointer<Void>, maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding: UInt, options: NSStringEncodingConversionOptions, range: NSRange, remainingRange leftover: NSRangePointer) -> Bool {
         var totalBytesWritten = 0
         var numCharsProcessed = 0
         let cfStringEncoding = CFStringConvertNSStringEncodingToEncoding(encoding)
@@ -911,8 +920,12 @@ extension NSString {
                 result = false /* ??? Need other encodings */
             }
         }
-        usedBufferCount?.pointee = totalBytesWritten
-        leftover?.pointee = NSMakeRange(range.location + numCharsProcessed, range.length - numCharsProcessed)
+        if usedBufferCount != nil {
+            usedBufferCount.pointee = totalBytesWritten
+        }
+        if leftover != nil {
+            leftover.pointee = NSMakeRange(range.location + numCharsProcessed, range.length - numCharsProcessed)
+        }
         return result
     }
     
@@ -1278,11 +1291,11 @@ extension NSString {
         try self.init(contentsOfURL: NSURL(fileURLWithPath: path), encoding: enc)
     }
     
-    public convenience init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<UInt>?) throws {
+    public convenience init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<UInt>) throws {
         NSUnimplemented()    
     }
     
-    public convenience init(contentsOfFile path: String, usedEncoding enc: UnsafeMutablePointer<UInt>?) throws {
+    public convenience init(contentsOfFile path: String, usedEncoding enc: UnsafeMutablePointer<UInt>) throws {
         NSUnimplemented()    
     }
 }
@@ -1307,7 +1320,7 @@ public class NSMutableString : NSString {
     }
     
     public required init(capacity: Int) {
-        super.init(characters: [], length: 0)
+        super.init(characters: nil, length: 0)
     }
 
     public convenience required init?(coder aDecoder: NSCoder) {
@@ -1394,7 +1407,7 @@ extension NSMutableString {
         if let findResults = CFStringCreateArrayWithFindResults(kCFAllocatorSystemDefault, _cfObject, target._cfObject, CFRange(searchRange), options._cfValue(true)) {
             let numOccurrences = CFArrayGetCount(findResults)
             for cnt in 0..<numOccurrences {
-                let range = UnsafePointer<CFRange>(CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1)!)
+                let range = UnsafePointer<CFRange>(CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1))
                 replaceCharactersInRange(NSRange(range.pointee), withString: replacement)
             }
             return numOccurrences
@@ -1404,12 +1417,14 @@ extension NSMutableString {
 
     }
     
-    public func applyTransform(_ transform: String, reverse: Bool, range: NSRange, updatedRange resultingRange: NSRangePointer?) -> Bool {
+    public func applyTransform(_ transform: String, reverse: Bool, range: NSRange, updatedRange resultingRange: NSRangePointer) -> Bool {
         var cfRange = CFRangeMake(range.location, range.length)
         return withUnsafeMutablePointer(&cfRange) { (rangep: UnsafeMutablePointer<CFRange>) -> Bool in
             if CFStringTransform(_cfMutableObject, rangep, transform._cfObject, reverse) {
-                resultingRange?.pointee.location = rangep.pointee.location
-                resultingRange?.pointee.length = rangep.pointee.length
+                if resultingRange != nil {
+                    resultingRange.pointee.location = rangep.pointee.location
+                    resultingRange.pointee.length = rangep.pointee.length
+                }
                 return true
             }
             return false
diff --git a/Foundation/NSSwiftRuntime.swift b/Foundation/NSSwiftRuntime.swift
index 40cf6a0189..1d6aa9fb90 100644
--- a/Foundation/NSSwiftRuntime.swift
+++ b/Foundation/NSSwiftRuntime.swift
@@ -350,9 +350,9 @@ extension Unmanaged {
         return self.fromOpaque(OpaquePointer(value))
     }
     
-    internal static func fromOptionalOpaque(_ value: UnsafePointer<Void>?) -> Unmanaged<Instance>? {
-        if let opaqueValue = value {
-            return self.fromOpaque(OpaquePointer(opaqueValue))
+    internal static func fromOptionalOpaque(_ value: UnsafePointer<Void>) -> Unmanaged<Instance>? {
+        if value != nil {
+            return self.fromOpaque(OpaquePointer(value))
         } else {
             return nil
         }
@@ -360,8 +360,8 @@ extension Unmanaged {
 }
 
 extension Array {
-    internal mutating func withUnsafeMutablePointerOrAllocation<R>(_ count: Int, fastpath: UnsafeMutablePointer<Element>? = nil, @noescape body: (UnsafeMutablePointer<Element>) -> R) -> R {
-        if let fastpath = fastpath {
+    internal mutating func withUnsafeMutablePointerOrAllocation<R>(_ count: Int, fastpath: UnsafeMutablePointer<Element> = nil, @noescape body: (UnsafeMutablePointer<Element>) -> R) -> R {
+        if fastpath != nil {
             return body(fastpath)
         } else if self.count > count {
             let buffer = UnsafeMutablePointer<Element>(allocatingCapacity: count)
@@ -371,7 +371,7 @@ extension Array {
             return res
         } else {
             return withUnsafeMutableBufferPointer() { (bufferPtr: inout UnsafeMutableBufferPointer<Element>) -> R in
-                return body(bufferPtr.baseAddress!)
+                return body(bufferPtr.baseAddress)
             }
         }
     }
diff --git a/Foundation/NSTask.swift b/Foundation/NSTask.swift
index cc6f559d30..0348003b34 100644
--- a/Foundation/NSTask.swift
+++ b/Foundation/NSTask.swift
@@ -27,7 +27,7 @@ private func WEXITSTATUS(_ status: CInt) -> CInt {
 private var managerThreadSetupOnceToken = pthread_once_t()
 // these are different sadly...
 #if os(OSX) || os(iOS)
-private var threadID: pthread_t? = nil
+private var threadID: pthread_t = nil
 #elseif os(Linux)
 private var threadID = pthread_t()
 #endif
@@ -40,24 +40,24 @@ private var managerThreadRunLoopIsRunningCondition = NSCondition()
 internal let kCFSocketDataCallBack = CFSocketCallBackType.dataCallBack.rawValue
 #endif
 
-private func emptyRunLoopCallback(_ context : UnsafeMutablePointer<Void>!) -> Void {}
+private func emptyRunLoopCallback(_ context : UnsafeMutablePointer<Void>) -> Void {}
 
 
 // Retain method for run loop source
-private func runLoopSourceRetain(_ pointer : UnsafePointer<Void>!) -> UnsafePointer<Void>! {
+private func runLoopSourceRetain(_ pointer : UnsafePointer<Void>) -> UnsafePointer<Void> {
     let ref = Unmanaged<AnyObject>.fromOpaque(OpaquePointer(pointer)).takeUnretainedValue()
     let retained = Unmanaged<AnyObject>.passRetained(ref)
     return unsafeBitCast(retained, to: UnsafePointer<Void>.self)
 }
 
 // Release method for run loop source
-private func runLoopSourceRelease(_ pointer : UnsafePointer<Void>!) -> Void {
+private func runLoopSourceRelease(_ pointer : UnsafePointer<Void>) -> Void {
     Unmanaged<AnyObject>.fromOpaque(OpaquePointer(pointer)).release()
 }
 
 // Equal method for run loop source
 
-private func runloopIsEqual(_ a : UnsafePointer<Void>!, b : UnsafePointer<Void>!) -> _DarwinCompatibleBoolean {
+private func runloopIsEqual(_ a : UnsafePointer<Void>, b : UnsafePointer<Void>) -> _DarwinCompatibleBoolean {
     
     let unmanagedrunLoopA = Unmanaged<AnyObject>.fromOpaque(OpaquePointer(a))
     guard let runLoopA = unmanagedrunLoopA.takeUnretainedValue() as? NSRunLoop else {
@@ -76,7 +76,7 @@ private func runloopIsEqual(_ a : UnsafePointer<Void>!, b : UnsafePointer<Void>!
     return true
 }
 
-@noreturn private func managerThread(_ x: UnsafeMutablePointer<Void>!) -> UnsafeMutablePointer<Void>! {
+@noreturn private func managerThread(_ x: UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void> {
     
     managerThreadRunLoop = NSRunLoop.currentRunLoop()
     var emptySourceContext = CFRunLoopSourceContext (version: 0, info: UnsafeMutablePointer<Void>(OpaquePointer(bitPattern: Unmanaged.passUnretained(managerThreadRunLoop!))),
@@ -111,7 +111,7 @@ private func managerThreadSetup() -> Void {
 
 
 // Equal method for task in run loop source
-private func nstaskIsEqual(_ a : UnsafePointer<Void>!, b : UnsafePointer<Void>!) -> _DarwinCompatibleBoolean {
+private func nstaskIsEqual(_ a : UnsafePointer<Void>, b : UnsafePointer<Void>) -> _DarwinCompatibleBoolean {
     
     let unmanagedTaskA = Unmanaged<AnyObject>.fromOpaque(OpaquePointer(a))
     guard let taskA = unmanagedTaskA.takeUnretainedValue() as? NSTask else {
@@ -184,9 +184,9 @@ public class NSTask : NSObject {
             args.append(contentsOf: arguments)
         }
         
-        let argv : UnsafeMutablePointer<UnsafeMutablePointer<Int8>?> = args.withUnsafeBufferPointer {
+        let argv : UnsafeMutablePointer<UnsafeMutablePointer<Int8>> = args.withUnsafeBufferPointer {
             let array : UnsafeBufferPointer<String> = $0
-            let buffer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: array.count + 1)
+            let buffer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: array.count + 1)
             buffer.initializeFrom(array.map { $0.withCString(strdup) })
             buffer[array.count] = nil
             return buffer
@@ -200,11 +200,11 @@ public class NSTask : NSObject {
             argv.deallocateCapacity(args.count + 1)
         }
         
-        let envp: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>
+        let envp: UnsafeMutablePointer<UnsafeMutablePointer<Int8>>
         
         if let env = environment {
             let nenv = env.count
-            envp = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 1 + nenv)
+            envp = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: 1 + nenv)
             envp.initializeFrom(env.map { strdup("\($0)=\($1)") })
             envp[env.count] = nil
             
@@ -250,11 +250,11 @@ public class NSTask : NSObject {
             
             if task.terminationHandler != nil {
                 #if os(OSX) || os(iOS)
-                var threadID: pthread_t? = nil
+                var threadID: pthread_t = nil
                 #elseif os(Linux)
                 var threadID = pthread_t()
                 #endif
-                pthread_create(&threadID, nil, { (context) -> UnsafeMutablePointer<Void>! in
+                pthread_create(&threadID, nil, { (context) -> UnsafeMutablePointer<Void> in
                     
                     let unmanagedTask : Unmanaged<NSTask> = Unmanaged.fromOpaque(context)
                     let task = unmanagedTask.takeRetainedValue()
diff --git a/Foundation/NSThread.swift b/Foundation/NSThread.swift
index 0ccd9730d7..162e3dbcef 100644
--- a/Foundation/NSThread.swift
+++ b/Foundation/NSThread.swift
@@ -16,7 +16,7 @@ import Glibc
 
 import CoreFoundation
 
-private func disposeTLS(_ ctx: UnsafeMutablePointer<Void>!) -> Void {
+private func disposeTLS(_ ctx: UnsafeMutablePointer<Void>) -> Void {
     Unmanaged<AnyObject>.fromOpaque(OpaquePointer(ctx)).release()
 }
 
@@ -73,7 +73,7 @@ internal enum _NSThreadStatus {
     case Finished
 }
 
-private func NSThreadStart(_ context: UnsafeMutablePointer<Void>!) -> UnsafeMutablePointer<Void>! {
+private func NSThreadStart(_ context: UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void> {
     let unmanaged: Unmanaged<NSThread> = Unmanaged.fromOpaque(OpaquePointer(context))
     let thread = unmanaged.takeUnretainedValue()
     NSThread._currentThread.set(thread)
@@ -155,7 +155,7 @@ public class NSThread : NSObject {
     
     internal var _main: (Void) -> Void = {}
 #if os(OSX) || os(iOS)
-    private var _thread: pthread_t? = nil
+    private var _thread: pthread_t = nil
 #elseif os(Linux)
     private var _thread = pthread_t()
 #endif
@@ -166,7 +166,6 @@ public class NSThread : NSObject {
     public var threadDictionary = [String:AnyObject]()
     
     internal init(thread: pthread_t) {
-        // Note: even on Darwin this is a non-optional pthread_t; this is only used for valid threads, which are never null pointers.
         _thread = thread
     }
     
diff --git a/Foundation/NSTimeZone.swift b/Foundation/NSTimeZone.swift
index 2fc9830c88..da4397b40e 100644
--- a/Foundation/NSTimeZone.swift
+++ b/Foundation/NSTimeZone.swift
@@ -13,9 +13,9 @@ import CoreFoundation
 public class NSTimeZone : NSObject, NSCopying, NSSecureCoding, NSCoding {
     typealias CFType = CFTimeZone
     private var _base = _CFInfo(typeID: CFTimeZoneGetTypeID())
-    private var _name: UnsafeMutablePointer<Void>? = nil
-    private var _data: UnsafeMutablePointer<Void>? = nil
-    private var _periods: UnsafeMutablePointer<Void>? = nil
+    private var _name: UnsafeMutablePointer<Void> = nil
+    private var _data: UnsafeMutablePointer<Void> = nil
+    private var _periods: UnsafeMutablePointer<Void> = nil
     private var _periodCnt = Int32(0)
     
     internal var _cfObject: CFType {
diff --git a/Foundation/NSTimer.swift b/Foundation/NSTimer.swift
index 4fd5ef2657..dfe7d3e0ed 100644
--- a/Foundation/NSTimer.swift
+++ b/Foundation/NSTimer.swift
@@ -10,7 +10,7 @@
 
 import CoreFoundation
 
-internal func __NSFireTimer(_ timer: CFRunLoopTimer!, info: UnsafeMutablePointer<Void>!) -> Void {
+internal func __NSFireTimer(_ timer: CFRunLoopTimer!, info: UnsafeMutablePointer<Void>) -> Void {
     let t = Unmanaged<NSTimer>.fromOpaque(info).takeUnretainedValue()
     t._fire(t)
 }
diff --git a/Foundation/NSURL.swift b/Foundation/NSURL.swift
index 0ad7f1dc32..34a5befbe3 100644
--- a/Foundation/NSURL.swift
+++ b/Foundation/NSURL.swift
@@ -33,10 +33,10 @@ public class NSURL : NSObject, NSSecureCoding, NSCopying {
     internal var _base = _CFInfo(typeID: CFURLGetTypeID())
     internal var _flags : UInt32 = 0
     internal var _encoding : CFStringEncoding = 0
-    internal var _string : UnsafeMutablePointer<CFString>? = nil
-    internal var _baseURL : UnsafeMutablePointer<CFURL>? = nil
-    internal var _extra : OpaquePointer? = nil
-    internal var _resourceInfo : OpaquePointer? = nil
+    internal var _string : UnsafeMutablePointer<CFString> = nil
+    internal var _baseURL : UnsafeMutablePointer<CFURL> = nil
+    internal var _extra : OpaquePointer = nil
+    internal var _resourceInfo : OpaquePointer = nil
     internal var _range1 = NSRange(location: 0, length: 0)
     internal var _range2 = NSRange(location: 0, length: 0)
     internal var _range3 = NSRange(location: 0, length: 0)
@@ -314,7 +314,7 @@ public class NSURL : NSObject, NSSecureCoding, NSCopying {
         
         let passwordBuf = buf[passwordRange.location ..< passwordRange.location+passwordRange.length]
         return passwordBuf.withUnsafeBufferPointer { ptr in
-            NSString(bytes: ptr.baseAddress!, length: passwordBuf.count, encoding: NSUTF8StringEncoding)?._swiftObject
+            NSString(bytes: ptr.baseAddress, length: passwordBuf.count, encoding: NSUTF8StringEncoding)?._swiftObject
         }
     }
     
@@ -369,10 +369,7 @@ public class NSURL : NSObject, NSSecureCoding, NSCopying {
             return UnsafePointer(_fsrBuffer)
         }
 
-        // FIXME: This used to return nil, but the corresponding Darwin
-        // implementation is marked as non-nullable.
-        fatalError("URL cannot be expressed in the filesystem representation;" +
-                   "use getFileSystemRepresentation to handle this case")
+        return nil
     }
     
     // Whether the scheme is file:; if [myURL isFileURL] is YES, then [myURL path] is suitable for input into NSFileManager or NSPathUtilities.
diff --git a/Foundation/NSUUID.swift b/Foundation/NSUUID.swift
index 745b4a136b..341368234f 100644
--- a/Foundation/NSUUID.swift
+++ b/Foundation/NSUUID.swift
@@ -32,7 +32,11 @@ public class NSUUID : NSObject, NSCopying, NSSecureCoding, NSCoding {
     }
     
     public init(UUIDBytes bytes: UnsafePointer<UInt8>) {
-        memcpy(unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), UnsafePointer<Void>(bytes), 16)
+        if (bytes != nil) {
+            memcpy(unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), UnsafePointer<Void>(bytes), 16)
+        } else {
+            memset(unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), 0, 16)
+        }
     }
     
     public func getUUIDBytes(_ uuid: UnsafeMutablePointer<UInt8>) {
@@ -62,7 +66,7 @@ public class NSUUID : NSObject, NSCopying, NSSecureCoding, NSCoding {
             var length : Int = 0
             let bytes = coder.decodeBytesForKey("NS.uuidbytes", returnedLength: &length)
             if (length == 16) {
-                self.init(UUIDBytes: bytes!)
+                self.init(UUIDBytes: bytes)
             } else {
                 self.init() // failure to decode the entire uuid_t results in a new uuid
             }
diff --git a/Foundation/NSXMLDTD.swift b/Foundation/NSXMLDTD.swift
index c4de595d4c..ced84c3781 100644
--- a/Foundation/NSXMLDTD.swift
+++ b/Foundation/NSXMLDTD.swift
@@ -21,7 +21,8 @@ public class NSXMLDTD : NSXMLNode {
     public convenience init(contentsOfURL url: NSURL, options mask: Int) throws {
         let urlString = url.absoluteString
 
-        guard let node = _CFXMLParseDTD(urlString) else {
+        let node = _CFXMLParseDTD(urlString)
+        if node == nil {
             //TODO: throw error
             fatalError("parsing dtd string failed")
         }
@@ -30,13 +31,11 @@ public class NSXMLDTD : NSXMLNode {
 
     public convenience init(data: NSData, options mask: Int) throws {
         var unmanagedError: Unmanaged<CFError>? = nil
-        
-        guard let node = _CFXMLParseDTDFromData(data._cfObject, &unmanagedError) else {
+        let node = _CFXMLParseDTDFromData(data._cfObject, &unmanagedError)
+        if node == nil {
             if let error = unmanagedError?.takeRetainedValue()._nsObject {
                 throw error
             }
-            //TODO: throw a generic error?
-            fatalError("parsing dtd from data failed")
         }
 
         self.init(ptr: node)
@@ -131,7 +130,10 @@ public class NSXMLDTD : NSXMLNode {
         @abstract Returns the entity declaration matching this name.
     */
     public func entityDeclarationForName(_ name: String) -> NSXMLDTDNode? {
-        guard let node = _CFXMLDTDGetEntityDesc(_xmlDTD, name) else { return nil }
+        let node = _CFXMLDTDGetEntityDesc(_xmlDTD, name)
+        if node == nil {
+            return nil
+        }
         return NSXMLDTDNode._objectNodeForNode(node)
     } //primitive
     
@@ -140,7 +142,11 @@ public class NSXMLDTD : NSXMLNode {
         @abstract Returns the notation declaration matching this name.
     */
     public func notationDeclarationForName(_ name: String) -> NSXMLDTDNode? {
-        guard let node = _CFXMLDTDGetNotationDesc(_xmlDTD, name) else { return nil }
+        let node = _CFXMLDTDGetNotationDesc(_xmlDTD, name)
+
+        if node == nil {
+            return nil
+        }
         return NSXMLDTDNode._objectNodeForNode(node)
     } //primitive
     
@@ -149,7 +155,11 @@ public class NSXMLDTD : NSXMLNode {
         @abstract Returns the element declaration matching this name.
     */
     public func elementDeclarationForName(_ name: String) -> NSXMLDTDNode? {
-        guard let node = _CFXMLDTDGetElementDesc(_xmlDTD, name) else { return nil }
+        let node = _CFXMLDTDGetElementDesc(_xmlDTD, name)
+
+        if node == nil {
+            return nil
+        }
         return NSXMLDTDNode._objectNodeForNode(node)
     } //primitive
     
@@ -158,7 +168,11 @@ public class NSXMLDTD : NSXMLNode {
         @abstract Returns the attribute declaration matching this name.
     */
     public func attributeDeclarationForName(_ name: String, elementName: String) -> NSXMLDTDNode? {
-        guard let node = _CFXMLDTDGetAttributeDesc(_xmlDTD, elementName, name) else { return nil }
+        let node = _CFXMLDTDGetAttributeDesc(_xmlDTD, elementName, name)
+
+        if node == nil {
+            return nil
+        }
         return NSXMLDTDNode._objectNodeForNode(node)
     } //primitive
     
@@ -169,15 +183,20 @@ public class NSXMLDTD : NSXMLNode {
     	<ul><li>&amp;lt; - &lt;</li><li>&amp;gt; - &gt;</li><li>&amp;amp; - &amp;</li><li>&amp;quot; - &quot;</li><li>&amp;apos; - &amp;</li></ul>
     */
     public class func predefinedEntityDeclarationForName(_ name: String) -> NSXMLDTDNode? {
-        guard let node = _CFXMLDTDGetPredefinedEntity(name) else { return nil }
+        let node = _CFXMLDTDGetPredefinedEntity(name)
+
+        if node == nil {
+            return nil
+        }
+
         return NSXMLDTDNode._objectNodeForNode(node)
     }
     
     internal override class func _objectNodeForNode(_ node: _CFXMLNodePtr) -> NSXMLDTD {
         precondition(_CFXMLNodeGetType(node) == _kCFXMLTypeDTD)
 
-        if let privateData = _CFXMLNodeGetPrivateData(node) {
-            let unmanaged = Unmanaged<NSXMLDTD>.fromOpaque(privateData)
+        if _CFXMLNodeGetPrivateData(node) != nil {
+            let unmanaged = Unmanaged<NSXMLDTD>.fromOpaque(_CFXMLNodeGetPrivateData(node))
             return unmanaged.takeUnretainedValue()
         }
         
diff --git a/Foundation/NSXMLDTDNode.swift b/Foundation/NSXMLDTDNode.swift
index db402510a9..15cc361c66 100644
--- a/Foundation/NSXMLDTDNode.swift
+++ b/Foundation/NSXMLDTDNode.swift
@@ -54,16 +54,20 @@ public class NSXMLDTDNode : NSXMLNode {
         @abstract Returns an element, attribute, entity, or notation DTD node based on the full XML string.
     */
     public init?(XMLString string: String) {
-        guard let ptr = _CFXMLParseDTDNode(string) else { return nil }
-        super.init(ptr: ptr)
+        let ptr = _CFXMLParseDTDNode(string)
+        if ptr == nil {
+            return nil
+        } else {
+            super.init(ptr: ptr)
+        }
     } //primitive
     
     public override init(kind: NSXMLNodeKind, options: Int) {
-        let ptr: _CFXMLNodePtr
+        var ptr: _CFXMLNodePtr = nil
 
         switch kind {
         case .ElementDeclarationKind:
-            ptr = _CFXMLDTDNewElementDesc(nil, nil)!
+            ptr = _CFXMLDTDNewElementDesc(nil, nil)
 
         default:
             super.init(kind: kind, options: options)
@@ -238,8 +242,8 @@ public class NSXMLDTDNode : NSXMLNode {
                      type == _kCFXMLDTDNodeTypeEntity    ||
                      type == _kCFXMLDTDNodeTypeElement)
 
-        if let privateData = _CFXMLNodeGetPrivateData(node) {
-            let unmanaged = Unmanaged<NSXMLDTDNode>.fromOpaque(privateData)
+        if _CFXMLNodeGetPrivateData(node) != nil {
+            let unmanaged = Unmanaged<NSXMLDTDNode>.fromOpaque(_CFXMLNodeGetPrivateData(node))
             return unmanaged.takeUnretainedValue()
         }
 
diff --git a/Foundation/NSXMLDocument.swift b/Foundation/NSXMLDocument.swift
index 2b2f89917b..6e36ff6a49 100644
--- a/Foundation/NSXMLDocument.swift
+++ b/Foundation/NSXMLDocument.swift
@@ -197,10 +197,11 @@ public class NSXMLDocument : NSXMLNode {
     */
     /*@NSCopying*/ public var DTD: NSXMLDTD? {
         get {
-            return NSXMLDTD._objectNodeForNode(_CFXMLDocDTD(_xmlDoc)!);
+            return NSXMLDTD._objectNodeForNode(_CFXMLDocDTD(_xmlDoc));
         }
         set {
-            if let currDTD = _CFXMLDocDTD(_xmlDoc) {
+            let currDTD = _CFXMLDocDTD(_xmlDoc)
+            if currDTD != nil {
                 if _CFXMLNodeGetPrivateData(currDTD) != nil {
                     let DTD = NSXMLDTD._objectNodeForNode(currDTD)
                     _CFXMLUnlinkNode(currDTD)
@@ -242,7 +243,8 @@ public class NSXMLDocument : NSXMLNode {
         @abstract The root element.
     */
     public func rootElement() -> NSXMLElement? {
-        guard let rootPtr = _CFXMLDocRootElement(_xmlDoc) else {
+        let rootPtr = _CFXMLDocRootElement(_xmlDoc)
+        if rootPtr == nil {
             return nil
         }
 
@@ -345,8 +347,8 @@ public class NSXMLDocument : NSXMLNode {
     internal override class func _objectNodeForNode(_ node: _CFXMLNodePtr) -> NSXMLDocument {
         precondition(_CFXMLNodeGetType(node) == _kCFXMLTypeDocument)
 
-        if let privateData = _CFXMLNodeGetPrivateData(node) {
-            let unmanaged = Unmanaged<NSXMLDocument>.fromOpaque(privateData)
+        if _CFXMLNodeGetPrivateData(node) != nil {
+            let unmanaged = Unmanaged<NSXMLDocument>.fromOpaque(_CFXMLNodeGetPrivateData(node))
             return unmanaged.takeUnretainedValue()
         }
 
diff --git a/Foundation/NSXMLElement.swift b/Foundation/NSXMLElement.swift
index 32ee5cb812..f967ad69a8 100644
--- a/Foundation/NSXMLElement.swift
+++ b/Foundation/NSXMLElement.swift
@@ -83,7 +83,8 @@ public class NSXMLElement : NSXMLNode {
         @abstract Removes an attribute based on its name.
     */
     public func removeAttributeForName(_ name: String) {
-        if let prop = _CFXMLNodeHasProp(_xmlNode, name) {
+        let prop = _CFXMLNodeHasProp(_xmlNode, name)
+        if prop != nil {
             let propNode = NSXMLNode._objectNodeForNode(_CFXMLNodePtr(prop))
             _childNodes.remove(propNode)
             // We can't use `xmlRemoveProp` because someone else may still have a reference to this attribute
@@ -98,10 +99,10 @@ public class NSXMLElement : NSXMLNode {
     public var attributes: [NSXMLNode]? {
         get {
             var result: [NSXMLNode] = []
-            var nextAttribute = _CFXMLNodeProperties(_xmlNode)
-            while let attribute = nextAttribute {
+            var attribute = _CFXMLNodeProperties(_xmlNode)
+            while attribute != nil {
                 result.append(NSXMLNode._objectNodeForNode(attribute))
-                nextAttribute = _CFXMLNodeGetNextSibling(attribute)
+                attribute = _CFXMLNodeGetNextSibling(attribute)
             }
             return result.count > 0 ? result : nil // This appears to be how Darwin does it
         }
@@ -120,11 +121,11 @@ public class NSXMLElement : NSXMLNode {
     }
 
     private func removeAttributes() {
-        var nextAttribute = _CFXMLNodeProperties(_xmlNode)
-        while let attribute = nextAttribute {
+        var attribute = _CFXMLNodeProperties(_xmlNode)
+        while attribute != nil {
             var shouldFreeNode = true
-            if let privateData = _CFXMLNodeGetPrivateData(attribute) {
-                let nodeUnmanagedRef = Unmanaged<NSXMLNode>.fromOpaque(privateData)
+            if _CFXMLNodeGetPrivateData(attribute) != nil {
+                let nodeUnmanagedRef = Unmanaged<NSXMLNode>.fromOpaque(_CFXMLNodeGetPrivateData(attribute))
                 let node = nodeUnmanagedRef.takeUnretainedValue()
                 _childNodes.remove(node)
 
@@ -137,7 +138,7 @@ public class NSXMLElement : NSXMLNode {
                 _CFXMLFreeNode(attribute)
             }
 
-            nextAttribute = temp
+            attribute = temp
         }
     }
 
@@ -157,7 +158,8 @@ public class NSXMLElement : NSXMLNode {
         @abstract Returns an attribute matching this name.
     */
     public func attributeForName(_ name: String) -> NSXMLNode? {
-        guard let attribute = _CFXMLNodeHasProp(_xmlNode, name) else { return nil }
+        let attribute = _CFXMLNodeHasProp(_xmlNode, name)
+        if attribute == nil { return nil }
         return NSXMLNode._objectNodeForNode(attribute)
     }
 
@@ -260,8 +262,8 @@ public class NSXMLElement : NSXMLNode {
     internal override class func _objectNodeForNode(_ node: _CFXMLNodePtr) -> NSXMLElement {
         precondition(_CFXMLNodeGetType(node) == _kCFXMLTypeElement)
 
-        if let privateData = _CFXMLNodeGetPrivateData(node) {
-            let unmanaged = Unmanaged<NSXMLElement>.fromOpaque(privateData)
+        if _CFXMLNodeGetPrivateData(node) != nil {
+            let unmanaged = Unmanaged<NSXMLElement>.fromOpaque(_CFXMLNodeGetPrivateData(node))
             return unmanaged.takeUnretainedValue()
         }
 
diff --git a/Foundation/NSXMLNode.swift b/Foundation/NSXMLNode.swift
index 33d0cf24d4..dcbb9b6744 100644
--- a/Foundation/NSXMLNode.swift
+++ b/Foundation/NSXMLNode.swift
@@ -93,7 +93,7 @@ public class NSXMLNode : NSObject, NSCopying {
             _xmlNode = _CFXMLNewDTD(nil, "", "", "")
             
         default:
-            fatalError("invalid node kind for this initializer")
+            _xmlNode = nil
         }
 
         super.init()
@@ -216,7 +216,10 @@ public class NSXMLNode : NSObject, NSCopying {
         @abstract Returns an element, attribute, entity, or notation DTD node based on the full XML string.
     */
     public class func DTDNodeWithXMLString(_ string: String) -> AnyObject? {
-        guard let node = _CFXMLParseDTDNode(string) else { return nil }
+        let node = _CFXMLParseDTDNode(string)
+        if node == nil {
+            return nil
+        }
 
         return NSXMLDTDNode(ptr: node)
     }
@@ -226,6 +229,7 @@ public class NSXMLNode : NSObject, NSCopying {
         @abstract Returns an element, attribute, entity, or notation DTD node based on the full XML string.
     */
     public var kind: NSXMLNodeKind  {
+        guard _xmlNode != nil else { return .InvalidKind }
         switch _CFXMLNodeGetType(_xmlNode) {
         case _kCFXMLTypeElement:
             return .ElementKind
@@ -335,10 +339,10 @@ public class NSXMLNode : NSObject, NSCopying {
     }
 
     internal func _removeAllChildren() {
-        var nextChild = _CFXMLNodeGetFirstChild(_xmlNode)
-        while let child = nextChild {
+        var child = _CFXMLNodeGetFirstChild(_xmlNode)
+        while child != nil {
             _CFXMLUnlinkNode(child)
-            nextChild = _CFXMLNodeGetNextSibling(child)
+            child = _CFXMLNodeGetNextSibling(child)
         }
         _childNodes.removeAll(keepingCapacity: true)
     }
@@ -379,7 +383,7 @@ public class NSXMLNode : NSObject, NSCopying {
         }
 
         var result: [Character] = Array(string.characters)
-        let doc = _CFXMLNodeGetDocument(_xmlNode)!
+        let doc = _CFXMLNodeGetDocument(_xmlNode)
         for (range, entity) in entities {
             var entityPtr = _CFXMLGetDocEntity(doc, entity)
             if entityPtr == nil {
@@ -388,8 +392,8 @@ public class NSXMLNode : NSObject, NSCopying {
             if entityPtr == nil {
                 entityPtr = _CFXMLGetParameterEntity(doc, entity)
             }
-            if let validEntity = entityPtr {
-                let replacement = _CFXMLGetEntityContent(validEntity)?._swiftObject ?? ""
+            if entityPtr != nil {
+                let replacement = _CFXMLGetEntityContent(entityPtr)?._swiftObject ?? ""
                 result.replaceSubrange(range, with: replacement.characters)
             } else {
                 result.replaceSubrange(range, with: []) // This appears to be how Darwin Foundation does it
@@ -417,10 +421,10 @@ public class NSXMLNode : NSObject, NSCopying {
     */
     public var level: Int {
         var result = 0
-        var nextParent = _CFXMLNodeGetParent(_xmlNode)
-        while let parent = nextParent {
+        var parent = _CFXMLNodeGetParent(_xmlNode)
+        while parent != nil {
             result += 1
-            nextParent = _CFXMLNodeGetParent(parent)
+            parent = _CFXMLNodeGetParent(parent)
         }
 
         return result
@@ -431,7 +435,8 @@ public class NSXMLNode : NSObject, NSCopying {
         @abstract The encompassing document or nil.
     */
     public var rootDocument: NSXMLDocument? {
-        guard let doc = _CFXMLNodeGetDocument(_xmlNode) else { return nil }
+        let doc = _CFXMLNodeGetDocument(_xmlNode)
+        guard doc != nil else { return nil }
 
         return NSXMLNode._objectNodeForNode(_CFXMLNodePtr(doc)) as? NSXMLDocument
     }
@@ -441,7 +446,8 @@ public class NSXMLNode : NSObject, NSCopying {
         @abstract The parent of this node. Documents and standalone Nodes have a nil parent; there is not a 1-to-1 relationship between parent and children, eg a namespace cannot be a child but has a parent element.
     */
     /*@NSCopying*/ public var parent: NSXMLNode? {
-        guard let parentPtr = _CFXMLNodeGetParent(_xmlNode) else { return nil }
+        let parentPtr = _CFXMLNodeGetParent(_xmlNode)
+        guard parentPtr != nil else { return nil }
 
         return NSXMLNode._objectNodeForNode(parentPtr)
     } //primitive
@@ -493,7 +499,8 @@ public class NSXMLNode : NSObject, NSCopying {
         @abstract Returns the previous sibling, or nil if there isn't one.
     */
     /*@NSCopying*/ public var previousSibling: NSXMLNode? {
-        guard let prev = _CFXMLNodeGetPrevSibling(_xmlNode) else { return nil }
+        let prev = _CFXMLNodeGetPrevSibling(_xmlNode)
+        guard prev != nil else { return nil }
 
         return NSXMLNode._objectNodeForNode(prev)
     }
@@ -503,7 +510,8 @@ public class NSXMLNode : NSObject, NSCopying {
         @abstract Returns the next sibling, or nil if there isn't one.
     */
     /*@NSCopying*/ public var nextSibling: NSXMLNode? {
-        guard let next = _CFXMLNodeGetNextSibling(_xmlNode) else { return nil }
+        let next = _CFXMLNodeGetNextSibling(_xmlNode)
+        guard next != nil else { return nil }
 
         return NSXMLNode._objectNodeForNode(next)
     }
@@ -514,8 +522,8 @@ public class NSXMLNode : NSObject, NSCopying {
     */
     /*@NSCopying*/ public var previousNode: NSXMLNode? {
         if let previousSibling = self.previousSibling {
-            if let lastChild = _CFXMLNodeGetLastChild(previousSibling._xmlNode) {
-                return NSXMLNode._objectNodeForNode(lastChild)
+            if _CFXMLNodeGetLastChild(previousSibling._xmlNode) != nil {
+                return NSXMLNode._objectNodeForNode(_CFXMLNodeGetLastChild(previousSibling._xmlNode))
             } else {
                 return previousSibling
             }
@@ -531,7 +539,8 @@ public class NSXMLNode : NSObject, NSCopying {
         @abstract Returns the next node in document order. This can be used to walk the tree forwards.
     */
     /*@NSCopying*/ public var nextNode: NSXMLNode? {
-        if let children = _CFXMLNodeGetFirstChild(_xmlNode) {
+        let children = _CFXMLNodeGetFirstChild(_xmlNode)
+        if children != nil {
             return NSXMLNode._objectNodeForNode(children)
         } else if let next = nextSibling {
             return next
@@ -547,10 +556,12 @@ public class NSXMLNode : NSObject, NSCopying {
         @abstract Detaches this node from its parent.
     */
     public func detach() {
-        guard let parentPtr = _CFXMLNodeGetParent(_xmlNode) else { return }
+        let parentPtr = _CFXMLNodeGetParent(_xmlNode)
+        guard parentPtr != nil else { return }
         _CFXMLUnlinkNode(_xmlNode)
 
-        guard let parentNodePtr = _CFXMLNodeGetPrivateData(parentPtr) else { return }
+        let parentNodePtr = _CFXMLNodeGetPrivateData(parentPtr)
+        guard parentNodePtr != nil else { return }
         let parent = Unmanaged<NSXMLNode>.fromOpaque(parentNodePtr).takeUnretainedValue()
         parent._childNodes.remove(self)
     } //primitive
@@ -565,7 +576,7 @@ public class NSXMLNode : NSObject, NSCopying {
         var pathComponents: [String?] = []
         var parent  = _CFXMLNodeGetParent(_xmlNode)
         if parent != nil {
-            let parentObj = NSXMLNode._objectNodeForNode(parent!)
+            let parentObj = NSXMLNode._objectNodeForNode(parent)
             let siblingsWithSameName = parentObj.filter { $0.name == self.name }
 
             if siblingsWithSameName.count > 1 {
@@ -579,15 +590,15 @@ public class NSXMLNode : NSObject, NSCopying {
             return self.name
         }
         while true {
-            if let parentNode = _CFXMLNodeGetParent(parent!) {
-                let grandparent = NSXMLNode._objectNodeForNode(parentNode)
+            if _CFXMLNodeGetParent(parent) != nil {
+                let grandparent = NSXMLNode._objectNodeForNode(_CFXMLNodeGetParent(parent))
                 let possibleParentNodes = grandparent.filter { $0.name == self.parent?.name }
                 let count = possibleParentNodes.reduce(0) {
                     return $0.0 + 1
                 }
 
                 if count <= 1 {
-                    pathComponents.append(NSXMLNode._objectNodeForNode(parent!).name)
+                    pathComponents.append(NSXMLNode._objectNodeForNode(parent).name)
                 } else {
                     var parentNumber = 1
                     for possibleParent in possibleParentNodes {
@@ -600,10 +611,10 @@ public class NSXMLNode : NSObject, NSCopying {
                     pathComponents.append("\(self.parent?.name ?? "")[\(parentNumber)]")
                 }
 
-                parent = _CFXMLNodeGetParent(parent!)
+                parent = _CFXMLNodeGetParent(parent)
 
             } else {
-                pathComponents.append(NSXMLNode._objectNodeForNode(parent!).name)
+                pathComponents.append(NSXMLNode._objectNodeForNode(parent).name)
                 break
             }
         }
@@ -761,12 +772,14 @@ public class NSXMLNode : NSObject, NSCopying {
     }
 
     internal init(ptr: _CFXMLNodePtr) {
+        precondition(ptr != nil)
         precondition(_CFXMLNodeGetPrivateData(ptr) == nil, "Only one NSXMLNode per xmlNodePtr allowed")
 
         _xmlNode = ptr
         super.init()
 
-        if let parent = _CFXMLNodeGetParent(_xmlNode) {
+        let parent = _CFXMLNodeGetParent(_xmlNode)
+        if parent != nil {
             let parentNode = NSXMLNode._objectNodeForNode(parent)
             parentNode._childNodes.insert(self)
         }
@@ -796,7 +809,8 @@ public class NSXMLNode : NSObject, NSCopying {
             return NSXMLDTDNode._objectNodeForNode(node)
 
         default:
-            if let _private = _CFXMLNodeGetPrivateData(node) {
+            let _private = _CFXMLNodeGetPrivateData(node)
+            if _private != nil {
                 let unmanaged = Unmanaged<NSXMLNode>.fromOpaque(_private)
                 return unmanaged.takeUnretainedValue()
             }
@@ -816,7 +830,7 @@ public class NSXMLNode : NSObject, NSCopying {
         _childNodes.insert(child)
 
         if index == 0 {
-            let first = _CFXMLNodeGetFirstChild(_xmlNode)!
+            let first = _CFXMLNodeGetFirstChild(_xmlNode)
             _CFXMLNodeAddPrevSibling(first, child._xmlNode)
         } else {
             let currChild = childAtIndex(index - 1)!._xmlNode
@@ -886,21 +900,21 @@ internal protocol _NSXMLNodeCollectionType: Collection { }
 
 extension NSXMLNode: _NSXMLNodeCollectionType {
     public struct Index: BidirectionalIndex {
-        private let node: _CFXMLNodePtr?
+        private let node: _CFXMLNodePtr
 
         public func predecessor() -> Index {
             guard node != nil else { return self }
-            return Index(node: _CFXMLNodeGetPrevSibling(node!))
+            return Index(node: _CFXMLNodeGetPrevSibling(node))
         }
 
         public func successor() -> Index {
             guard node != nil else { return self }
-            return Index(node: _CFXMLNodeGetNextSibling(node!))
+            return Index(node: _CFXMLNodeGetNextSibling(node))
         }
     }
 
     public subscript(index: Index) -> NSXMLNode {
-        return NSXMLNode._objectNodeForNode(index.node!)
+        return NSXMLNode._objectNodeForNode(index.node)
     }
 
     public var startIndex: Index {
diff --git a/Foundation/NSXMLParser.swift b/Foundation/NSXMLParser.swift
index e0aac1d87e..1ef1d32393 100644
--- a/Foundation/NSXMLParser.swift
+++ b/Foundation/NSXMLParser.swift
@@ -46,7 +46,7 @@ private func UTF8STRING(_ bytes: UnsafePointer<UInt8>) -> String? {
     return str
 }
 
-internal func _NSXMLParserCurrentParser() -> _CFXMLInterface? {
+internal func _NSXMLParserCurrentParser() -> _CFXMLInterface {
     if let parser = NSXMLParser.currentParser() {
         return parser.interface
     } else {
@@ -54,7 +54,7 @@ internal func _NSXMLParserCurrentParser() -> _CFXMLInterface? {
     }
 }
 
-internal func _NSXMLParserExternalEntityWithURL(_ interface: _CFXMLInterface, urlStr: UnsafePointer<Int8>, identifier: UnsafePointer<Int8>, context: _CFXMLInterfaceParserContext, originalLoaderFunction: _CFXMLInterfaceExternalEntityLoader) -> _CFXMLInterfaceParserInput? {
+internal func _NSXMLParserExternalEntityWithURL(_ interface: _CFXMLInterface, urlStr: UnsafePointer<Int8>, identifier: UnsafePointer<Int8>, context: _CFXMLInterfaceParserContext, originalLoaderFunction: _CFXMLInterfaceExternalEntityLoader) -> _CFXMLInterfaceParserInput {
     let parser = interface.parser
     let policy = parser.externalEntityResolvingPolicy
     var a: NSURL?
@@ -126,7 +126,7 @@ internal func _NSXMLParserExternalEntityWithURL(_ interface: _CFXMLInterface, ur
 }
 
 internal func _NSXMLParserGetContext(_ ctx: _CFXMLInterface) -> _CFXMLInterfaceParserContext {
-    return ctx.parser._parserContext!
+    return ctx.parser._parserContext
 }
 
 internal func _NSXMLParserInternalSubset(_ ctx: _CFXMLInterface, name: UnsafePointer<UInt8>, ExternalID: UnsafePointer<UInt8>, SystemID: UnsafePointer<UInt8>) -> Void {
@@ -145,7 +145,7 @@ internal func _NSXMLParserHasExternalSubset(_ ctx: _CFXMLInterface) -> Int32 {
     return _CFXMLInterfaceHasExternalSubset(ctx.parser._parserContext)
 }
 
-internal func _NSXMLParserGetEntity(_ ctx: _CFXMLInterface, name: UnsafePointer<UInt8>) -> _CFXMLInterfaceEntity? {
+internal func _NSXMLParserGetEntity(_ ctx: _CFXMLInterface, name: UnsafePointer<UInt8>) -> _CFXMLInterfaceEntity {
     let parser = ctx.parser
     let context = _NSXMLParserGetContext(ctx)
     var entity = _CFXMLInterfaceGetPredefinedEntity(name)
@@ -235,13 +235,13 @@ internal func _colonSeparatedStringFromPrefixAndSuffix(_ prefix: UnsafePointer<U
     return "\(prefixString!):\(suffixString!)"
 }
 
-internal func _NSXMLParserStartElementNs(_ ctx: _CFXMLInterface, localname: UnsafePointer<UInt8>, prefix: UnsafePointer<UInt8>?, URI: UnsafePointer<UInt8>, nb_namespaces: Int32, namespaces: UnsafeMutablePointer<UnsafePointer<UInt8>?>, nb_attributes: Int32, nb_defaulted: Int32, attributes: UnsafeMutablePointer<UnsafePointer<UInt8>?>) -> Void {
+internal func _NSXMLParserStartElementNs(_ ctx: _CFXMLInterface, localname: UnsafePointer<UInt8>, prefix: UnsafePointer<UInt8>, URI: UnsafePointer<UInt8>, nb_namespaces: Int32, namespaces: UnsafeMutablePointer<UnsafePointer<UInt8>>, nb_attributes: Int32, nb_defaulted: Int32, attributes: UnsafeMutablePointer<UnsafePointer<UInt8>>) -> Void {
     let parser = ctx.parser
     let reportQNameURI = parser.shouldProcessNamespaces
     let reportNamespaces = parser.shouldReportNamespacePrefixes
-    let prefixLen = prefix != nil ? UInt(strlen(UnsafePointer<Int8>(prefix!))) : 0
+    let prefixLen = prefix == nil ? UInt(strlen(UnsafePointer<Int8>(prefix))) : 0
     let localnameString = (prefixLen == 0 || reportQNameURI) ? UTF8STRING(localname) : nil
-    let qualifiedNameString = prefixLen != 0 ? _colonSeparatedStringFromPrefixAndSuffix(prefix!, UInt(prefixLen), localname, UInt(strlen(UnsafePointer<Int8>(localname)))) : localnameString
+    let qualifiedNameString = prefixLen != 0 ? _colonSeparatedStringFromPrefixAndSuffix(prefix, UInt(prefixLen), localname, UInt(strlen(UnsafePointer<Int8>(localname)))) : localnameString
     let namespaceURIString = reportQNameURI ? UTF8STRING(URI) : nil
     
     var nsDict = [String:String]()
@@ -250,16 +250,16 @@ internal func _NSXMLParserStartElementNs(_ ctx: _CFXMLInterface, localname: Unsa
         for idx in stride(from: 0, to: Int(nb_namespaces) * 2, by: 2) {
             var namespaceNameString: String?
             var asAttrNamespaceNameString: String?
-            if let ns = namespaces[idx] {
+            if namespaces[idx] != nil {
                 if reportNamespaces {
-                    namespaceNameString = UTF8STRING(ns)
+                    namespaceNameString = UTF8STRING(namespaces[idx])
                 }
-                asAttrNamespaceNameString = _colonSeparatedStringFromPrefixAndSuffix("xmlns", 5, ns, UInt(strlen(UnsafePointer<Int8>(ns))))
+                asAttrNamespaceNameString = _colonSeparatedStringFromPrefixAndSuffix("xmlns", 5, namespaces[idx], UInt(strlen(UnsafePointer<Int8>(namespaces[idx]))))
             } else {
                 namespaceNameString = ""
                 asAttrNamespaceNameString = "xmlns"
             }
-            let namespaceValueString = namespaces[idx + 1] != nil ? UTF8STRING(namespaces[idx + 1]!) : ""
+            let namespaceValueString = namespaces[idx + 1] == nil ? UTF8STRING(namespaces[idx + 1]) : ""
             if reportNamespaces {
                 if let k = namespaceNameString, v = namespaceValueString {
                     nsDict[k] = v
@@ -282,11 +282,11 @@ internal func _NSXMLParserStartElementNs(_ ctx: _CFXMLInterface, localname: Unsa
             continue
         }
         var attributeQName: String
-        let attrLocalName = attributes[idx]!
+        let attrLocalName = attributes[idx]
         let attrPrefix = attributes[idx + 1]
-        let attrPrefixLen = attrPrefix != nil ? strlen(UnsafePointer<Int8>(attrPrefix!)) : 0
+        let attrPrefixLen = attrPrefix == nil ? strlen(UnsafePointer<Int8>(attrPrefix)) : 0
         if attrPrefixLen != 0 {
-            attributeQName = _colonSeparatedStringFromPrefixAndSuffix(attrPrefix!, UInt(attrPrefixLen), attrLocalName, UInt(strlen((UnsafePointer<Int8>(attrLocalName)))))
+            attributeQName = _colonSeparatedStringFromPrefixAndSuffix(attrPrefix, UInt(attrPrefixLen), attrLocalName, UInt(strlen((UnsafePointer<Int8>(attrLocalName)))))
         } else {
             attributeQName = UTF8STRING(attrLocalName)!
         }
@@ -295,13 +295,13 @@ internal func _NSXMLParserStartElementNs(_ ctx: _CFXMLInterface, localname: Unsa
         // By using XML_PARSE_NOENT the attribute value string will already have entities resolved
         var attributeValue = ""
         if attributes[idx + 3] != nil && attributes[idx + 4] != nil {
-            let numBytesWithoutTerminator = attributes[idx + 4]! - attributes[idx + 3]!
+            let numBytesWithoutTerminator = attributes[idx + 4] - attributes[idx + 3]
             let numBytesWithTerminator = numBytesWithoutTerminator + 1
             if numBytesWithoutTerminator != 0 {
                 var chars = [Int8](repeating: 0, count: numBytesWithTerminator)
                 attributeValue = chars.withUnsafeMutableBufferPointer({ (buffer: inout UnsafeMutableBufferPointer<Int8>) -> String in
-                    strncpy(buffer.baseAddress!, UnsafePointer<Int8>(attributes[idx + 3]!), numBytesWithoutTerminator) //not strlcpy because attributes[i+3] is not Nul terminated
-                    return UTF8STRING(UnsafePointer<UInt8>(buffer.baseAddress!))!
+                    strncpy(buffer.baseAddress, UnsafePointer<Int8>(attributes[idx + 3]), numBytesWithoutTerminator) //not strlcpy because attributes[i+3] is not Nul terminated
+                    return UTF8STRING(UnsafePointer<UInt8>(buffer.baseAddress))!
                 })
             }
             attrDict[attributeQName] = attributeValue
@@ -318,13 +318,13 @@ internal func _NSXMLParserStartElementNs(_ ctx: _CFXMLInterface, localname: Unsa
     }
 }
 
-internal func _NSXMLParserEndElementNs(_ ctx: _CFXMLInterface , localname: UnsafePointer<UInt8>, prefix: UnsafePointer<UInt8>?, URI: UnsafePointer<UInt8>) -> Void {
+internal func _NSXMLParserEndElementNs(_ ctx: _CFXMLInterface , localname: UnsafePointer<UInt8>, prefix: UnsafePointer<UInt8>, URI: UnsafePointer<UInt8>) -> Void {
     let parser = ctx.parser
     let reportQNameURI = parser.shouldProcessNamespaces
-    let prefixLen = prefix != nil ? strlen(UnsafePointer<Int8>(prefix!)) : 0
+    let prefixLen = prefix == nil ? strlen(UnsafePointer<Int8>(prefix)) : 0
     let localnameString = (prefixLen == 0 || reportQNameURI) ? UTF8STRING(localname) : nil
     let nilStr: String? = nil
-    let qualifiedNameString = (prefixLen != 0) ? _colonSeparatedStringFromPrefixAndSuffix(prefix!, UInt(prefixLen), localname, UInt(strlen(UnsafePointer<Int8>(localname)))) : nilStr
+    let qualifiedNameString = (prefixLen != 0) ? _colonSeparatedStringFromPrefixAndSuffix(prefix, UInt(prefixLen), localname, UInt(strlen(UnsafePointer<Int8>(localname)))) : nilStr
     let namespaceURIString = reportQNameURI ? UTF8STRING(URI) : nilStr
     
     
@@ -343,7 +343,7 @@ internal func _NSXMLParserEndElementNs(_ ctx: _CFXMLInterface , localname: Unsaf
 
 internal func _NSXMLParserCharacters(_ ctx: _CFXMLInterface, ch: UnsafePointer<UInt8>, len: Int32) -> Void {
     let parser = ctx.parser
-    let context = parser._parserContext!
+    let context = parser._parserContext
     if _CFXMLInterfaceInRecursiveState(context) != 0 {
         _CFXMLInterfaceResetRecursiveState(context)
     } else {
@@ -398,7 +398,7 @@ public class NSXMLParser : NSObject {
     internal var _chunkSize = Int(4096 * 32) // a suitably large number for a decent chunk size
     internal var _haveDetectedEncoding = false
     internal var _bomChunk: NSData?
-    private var _parserContext: _CFXMLInterfaceParserContext?
+    private var _parserContext: _CFXMLInterfaceParserContext
     internal var _delegateAborted = false
     internal var _url: NSURL?
     internal var _namespaces = [[String:String]]()
@@ -509,7 +509,7 @@ public class NSXMLParser : NSObject {
                     allExistingData = data
                 }
                 
-                var handler: _CFXMLInterfaceSAXHandler? = nil
+                var handler: _CFXMLInterfaceSAXHandler = nil
                 if delegate != nil {
                     handler = _handler
                 }
@@ -587,8 +587,8 @@ public class NSXMLParser : NSObject {
     
     // called by the delegate to stop the parse. The delegate will get an error message sent to it.
     public func abortParsing() {
-        if let context = _parserContext {
-            _CFXMLInterfaceStopParser(context)
+        if _parserContext != nil {
+            _CFXMLInterfaceStopParser(_parserContext)
             _delegateAborted = true
         }
     }
diff --git a/Foundation/String.swift b/Foundation/String.swift
index 4f3a834612..d498a08d96 100644
--- a/Foundation/String.swift
+++ b/Foundation/String.swift
@@ -111,12 +111,14 @@ extension String {
     /// non-`nil`, convert the buffer to an `Index` and write it into the
     /// memory referred to by `index`
     func _withOptionalOutParameter<Result>(
-        _ index: UnsafeMutablePointer<Index>?,
-        @noescape body: (UnsafeMutablePointer<Int>?) -> Result
+        _ index: UnsafeMutablePointer<Index>,
+        @noescape body: (UnsafeMutablePointer<Int>) -> Result
         ) -> Result {
         var utf16Index: Int = 0
-        let result = (index != nil) ? body(&utf16Index) : body(nil)
-        index?.pointee = self._index(utf16Index)
+        let result = index._withBridgeValue(&utf16Index) {
+            body($0)
+        }
+        index._setIfNonNil { self._index(utf16Index) }
         return result
     }
     
@@ -124,12 +126,14 @@ extension String {
     /// from non-`nil`, convert the buffer to a `Range<Index>` and write
     /// it into the memory referred to by `range`
     func _withOptionalOutParameter<Result>(
-        _ range: UnsafeMutablePointer<Range<Index>>?,
-        @noescape body: (UnsafeMutablePointer<NSRange>?) -> Result
+        _ range: UnsafeMutablePointer<Range<Index>>,
+        @noescape body: (UnsafeMutablePointer<NSRange>) -> Result
         ) -> Result {
         var nsRange = NSRange(location: 0, length: 0)
-        let result = (range != nil) ? body(&nsRange) : body(nil)
-        range?.pointee = self._range(nsRange)
+        let result = range._withBridgeValue(&nsRange) {
+            body($0)
+        }
+        range._setIfNonNil { self._range(nsRange) }
         return result
     }
     
@@ -798,7 +802,7 @@ extension String {
     /// interpret the file.
     public init(
         contentsOfFile path: String,
-        usedEncoding: UnsafeMutablePointer<NSStringEncoding>? = nil
+        usedEncoding: UnsafeMutablePointer<NSStringEncoding> = nil
         ) throws {
         let ns = try NSString(contentsOfFile: path, usedEncoding: usedEncoding)
         self = ns._swiftObject
@@ -830,7 +834,7 @@ extension String {
     /// data.  Errors are written into the inout `error` argument.
     public init(
         contentsOfURL url: NSURL,
-        usedEncoding enc: UnsafeMutablePointer<NSStringEncoding>? = nil
+        usedEncoding enc: UnsafeMutablePointer<NSStringEncoding> = nil
         ) throws {
         let ns = try NSString(contentsOfURL: url, usedEncoding: enc)
         self = ns._swiftObject
diff --git a/TestFoundation/TestNSArray.swift b/TestFoundation/TestNSArray.swift
index be20c74082..e0a21f84df 100644
--- a/TestFoundation/TestNSArray.swift
+++ b/TestFoundation/TestNSArray.swift
@@ -358,7 +358,7 @@ class TestNSArray : XCTestCase {
         let mutableInput = inputNumbers.bridge().mutableCopy() as! NSMutableArray
         let expectedNumbers = inputNumbers.sorted()
 
-        func compare(_ left: AnyObject, right:AnyObject,  context: UnsafeMutablePointer<Void>?) -> Int {
+        func compare(_ left: AnyObject, right:AnyObject,  context: UnsafeMutablePointer<Void>) -> Int {
             let l = (left as! NSNumber).integerValue
             let r = (right as! NSNumber).integerValue
             return l < r ? -1 : (l > r ? 0 : 1)
diff --git a/TestFoundation/TestNSKeyedArchiver.swift b/TestFoundation/TestNSKeyedArchiver.swift
index 7c12817181..ad6c54116c 100644
--- a/TestFoundation/TestNSKeyedArchiver.swift
+++ b/TestFoundation/TestNSKeyedArchiver.swift
@@ -129,7 +129,7 @@ class TestNSKeyedArchiver : XCTestCase {
         let array: Array<UInt64> = [12341234123, 23452345234, 23475982345, 9893563243, 13469816598]
         let objctype = "[5Q]"
         array.withUnsafeBufferPointer { cArray in
-            let concrete = NSValue(bytes: cArray.baseAddress!, objCType: objctype)
+            let concrete = NSValue(bytes: cArray.baseAddress, objCType: objctype)
             test_archive(concrete)
         }
     }
@@ -144,14 +144,14 @@ class TestNSKeyedArchiver : XCTestCase {
 
         test_archive({ archiver -> Bool in
             array.withUnsafeBufferPointer { cArray in
-                archiver.encodeValueOfObjCType("[4i]", at: cArray.baseAddress!)
+                archiver.encodeValueOfObjCType("[4i]", at: cArray.baseAddress)
             }
             return true
         },
         decode: {unarchiver -> Bool in
             var expected: Array<Int32> = [0, 0, 0, 0]
             expected.withUnsafeMutableBufferPointer {(p: inout UnsafeMutableBufferPointer<Int32>) in
-                unarchiver.decodeValueOfObjCType("[4i]", at: UnsafeMutablePointer<Void>(p.baseAddress!))
+                unarchiver.decodeValueOfObjCType("[4i]", at: UnsafeMutablePointer<Void>(p.baseAddress))
             }
             XCTAssertEqual(expected, array)
             return true
@@ -229,15 +229,15 @@ class TestNSKeyedArchiver : XCTestCase {
                 guard let value = unarchiver.decodeObjectOfClass(NSValue.self, forKey: "root") else {
                     return false
                 }
-                var expectedCharPtr: UnsafeMutablePointer<CChar>? = nil
+                var expectedCharPtr: UnsafeMutablePointer<CChar> = nil
                 value.getValue(&expectedCharPtr)
                 
                 let s1 = String(cString: charPtr)
-                let s2 = String(cString: expectedCharPtr!)
+                let s2 = String(cString: expectedCharPtr)
                 
                 // On Darwin decoded strings would belong to the autorelease pool, but as we don't have
                 // one in SwiftFoundation let's explicitly deallocate it here.
-                expectedCharPtr!.deallocateCapacity(charArray.count)
+                expectedCharPtr.deallocateCapacity(charArray.count)
                 
                 return s1 == s2
         })
diff --git a/TestFoundation/TestNSKeyedUnarchiver.swift b/TestFoundation/TestNSKeyedUnarchiver.swift
index e724106a7d..47cc00d937 100644
--- a/TestFoundation/TestNSKeyedUnarchiver.swift
+++ b/TestFoundation/TestNSKeyedUnarchiver.swift
@@ -67,7 +67,7 @@ class TestNSKeyedUnarchiver : XCTestCase {
         let array: Array<Int32> = [1, 2, 3]
         let objctype = "[3i]"
         array.withUnsafeBufferPointer { cArray in
-            let concrete = NSValue(bytes: cArray.baseAddress!, objCType: objctype)
+            let concrete = NSValue(bytes: cArray.baseAddress, objCType: objctype)
             test_unarchive_from_file("NSKeyedUnarchiver-ConcreteValueTest", concrete)
         }
     }
diff --git a/TestFoundation/TestNSString.swift b/TestFoundation/TestNSString.swift
index 46b2df4d3e..65454da06b 100644
--- a/TestFoundation/TestNSString.swift
+++ b/TestFoundation/TestNSString.swift
@@ -743,7 +743,7 @@ class TestNSString : XCTestCase {
         let expected: [Int8] = [102, 111, 111, 0]
         var res: Bool = false
         chars.withUnsafeMutableBufferPointer() {
-            let ptr = $0.baseAddress!
+            let ptr = $0.baseAddress
             res = str.getCString(ptr, maxLength: count, encoding: NSASCIIStringEncoding)
         }
         XCTAssertTrue(res, "getCString should work on simple strings with ascii string encoding")
@@ -757,12 +757,12 @@ class TestNSString : XCTestCase {
         let count = chars.count
         var res: Bool = false
         chars.withUnsafeMutableBufferPointer() {
-            let ptr = $0.baseAddress!
+            let ptr = $0.baseAddress
             res = str.getCString(ptr, maxLength: count, encoding: NSASCIIStringEncoding)
         }
         XCTAssertFalse(res, "getCString should not work on non ascii strings accessing as ascii string encoding")
         chars.withUnsafeMutableBufferPointer() {
-            let ptr = $0.baseAddress!
+            let ptr = $0.baseAddress
             res = str.getCString(ptr, maxLength: count, encoding: NSUTF8StringEncoding)
         }
         XCTAssertTrue(res, "getCString should work on UTF8 encoding")
diff --git a/TestFoundation/TestNSUUID.swift b/TestFoundation/TestNSUUID.swift
index 1043e3a9aa..1b0bf0fcfa 100644
--- a/TestFoundation/TestNSUUID.swift
+++ b/TestFoundation/TestNSUUID.swift
@@ -23,6 +23,7 @@ class TestNSUUID : XCTestCase {
         return [
             ("test_Equality", test_Equality),
             ("test_InvalidUUID", test_InvalidUUID),
+            ("test_InitializationWithNil", test_InitializationWithNil),
             ("test_UUIDString", test_UUIDString),
             ("test_description", test_description),
             // Disabled until NSKeyedArchiver and NSKeyedUnarchiver are implemented
@@ -46,6 +47,11 @@ class TestNSUUID : XCTestCase {
         XCTAssertNil(uuid, "The convenience initializer `init?(UUIDString string:)` must return nil for an invalid UUID string.")
     }
     
+    func test_InitializationWithNil() {
+        let uuid = NSUUID(UUIDBytes: nil)
+        XCTAssertEqual(uuid, NSUUID(UUIDBytes: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]), "The convenience initializer `init(UUIDBytes bytes:)` must return the Nil UUID when UUIDBytes is nil.")
+    }
+    
     // `UUIDString` should return an uppercase string
     // See: https://bugs.swift.org/browse/SR-865
     func test_UUIDString() {
diff --git a/TestFoundation/TestNSValue.swift b/TestFoundation/TestNSValue.swift
index 2936f3c260..a4bfe49d9c 100644
--- a/TestFoundation/TestNSValue.swift
+++ b/TestFoundation/TestNSValue.swift
@@ -103,7 +103,7 @@ class TestNSValue : XCTestCase {
         let array: Array<UInt64> = [12341234123, 23452345234, 23475982345, 9893563243, 13469816598]
         array.withUnsafeBufferPointer { cArray in
             var expected = [UInt64](repeating: 0, count: 5)
-            NSValue(bytes: cArray.baseAddress!, objCType: "[5Q]").getValue(&expected)
+            NSValue(bytes: cArray.baseAddress, objCType: "[5Q]").getValue(&expected)
             XCTAssertEqual(array, expected)
         }
     }
@@ -113,7 +113,7 @@ class TestNSValue : XCTestCase {
         let objctype = "[" + String(array.count) + "s]"
         array.withUnsafeBufferPointer { cArray in
             var expected = [Int16](repeating: 0, count: array.count)
-            NSValue(bytes: cArray.baseAddress!, objCType: objctype).getValue(&expected)
+            NSValue(bytes: cArray.baseAddress, objCType: objctype).getValue(&expected)
             XCTAssertEqual(array, expected)
         }
     }
@@ -121,7 +121,7 @@ class TestNSValue : XCTestCase {
     func test_valueWithCharPtr() {
         let charArray = [UInt8]("testing123".utf8)
         var charPtr = UnsafeMutablePointer<UInt8>(charArray)
-        var expectedPtr: UnsafeMutablePointer<UInt8>? = nil
+        var expectedPtr: UnsafeMutablePointer<UInt8> = nil
         
         NSValue(bytes: &charPtr, objCType: "*").getValue(&expectedPtr)
         XCTAssertEqual(charPtr, expectedPtr)