Merge branch 'swift-3.0-branch' into das-darwin-006-merge-swift-3.0-branch

Author: das

src/swift/Block.swift

@@ -41,12 +41,12 @@ public class DispatchWorkItem {
 
 	// Temporary for swift-corelibs-foundation
 	@available(*, deprecated, renamed: "DispatchWorkItem(qos:flags:block:)")
-	public convenience init(group: DispatchGroup, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], block: @convention(block) () -> ()) {
+	public convenience init(group: DispatchGroup, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], block: @escaping @convention(block) () -> ()) {
 		self.init(qos: qos, flags: flags, block: block)
 
 	}
 
-	public init(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], block: @convention(block) () -> ()) {
+	public init(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], block: @escaping @convention(block) () -> ()) {
 		_block =  dispatch_block_create_with_qos_class(dispatch_block_flags_t(flags.rawValue),
 			qos.qosClass.rawValue.rawValue, Int32(qos.relativePriority), block)
 	}
@@ -77,7 +77,7 @@ public class DispatchWorkItem {
 		qos: DispatchQoS = .unspecified, 
 		flags: DispatchWorkItemFlags = [], 
 		queue: DispatchQueue, 
-		execute: @convention(block) () -> Void) 
+		execute: @escaping @convention(block) () -> ()) 
 	{
 		if qos != .unspecified || !flags.isEmpty {
 			let item = DispatchWorkItem(qos: qos, flags: flags, block: execute)

src/swift/Data.swift

@@ -35,7 +35,7 @@ public struct DispatchData : RandomAccessCollection {
 		//        which is only made available on platforms with Objective-C.
 		case custom(DispatchQueue?, () -> Void)
 
-		private var _deallocator: (DispatchQueue?, @convention(block) () -> Void) {
+		fileprivate var _deallocator: (DispatchQueue?, @convention(block) () -> Void) {
 			switch self {
 			case .free: return (nil, _dispatch_data_destructor_free())
 			case .unmap: return (nil, _dispatch_data_destructor_munmap())
@@ -80,19 +80,19 @@ public struct DispatchData : RandomAccessCollection {
 		var size = 0
 		let data = CDispatch.dispatch_data_create_map(__wrapped.__wrapped, &ptr, &size)
 		let contentPtr = ptr!.bindMemory(
-			to: ContentType.self, capacity: size / strideof(ContentType.self))
+			to: ContentType.self, capacity: size / MemoryLayout<ContentType>.stride)
 		defer { _fixLifetime(data) }
 		return try body(contentPtr)
 	}
 
 	public func enumerateBytes(
-		block: @noescape (buffer: UnsafeBufferPointer<UInt8>, byteIndex: Int, stop: inout Bool) -> Void) 
+		block: @noescape (_ buffer: UnsafeBufferPointer<UInt8>, _ byteIndex: Int, _ stop: inout Bool) -> Void) 
 	{
 		_swift_dispatch_data_apply(__wrapped.__wrapped) { (data: dispatch_data_t, offset: Int, ptr: UnsafeRawPointer, size: Int) in
 			let bytePtr = ptr.bindMemory(to: UInt8.self, capacity: size)
 			let bp = UnsafeBufferPointer(start: bytePtr, count: size)
 			var stop = false
-			block(buffer: bp, byteIndex: offset, stop: &stop)
+			block(bp, offset, &stop)
 			return !stop
 		}
 	}
@@ -118,7 +118,10 @@ public struct DispatchData : RandomAccessCollection {
 	///
 	/// - parameter buffer: The buffer of bytes to append. The size is calculated from `SourceType` and `buffer.count`.
 	public mutating func append<SourceType>(_ buffer : UnsafeBufferPointer<SourceType>) {
-		self.append(UnsafePointer(buffer.baseAddress!), count: buffer.count * sizeof(SourceType.self))
+		let count = buffer.count * MemoryLayout<SourceType>.stride;
+		buffer.baseAddress?.withMemoryRebound(to: UInt8.self, capacity: count) {
+			self.append($0, count: count)
+		}
 	}
 
 	private func _copyBytesHelper(to pointer: UnsafeMutablePointer<UInt8>, from range: CountableRange<Index>) {
@@ -151,7 +154,7 @@ public struct DispatchData : RandomAccessCollection {
 
 	/// Copy the contents of the data into a buffer.
 	///
-	/// This function copies the bytes in `range` from the data into the buffer. If the count of the `range` is greater than `sizeof(DestinationType) * buffer.count` then the first N bytes will be copied into the buffer.
+	/// This function copies the bytes in `range` from the data into the buffer. If the count of the `range` is greater than `MemoryLayout<DestinationType>.stride * buffer.count` then the first N bytes will be copied into the buffer.
 	/// - precondition: The range must be within the bounds of the data. Otherwise `fatalError` is called.
 	/// - parameter buffer: A buffer to copy the data into.
 	/// - parameter range: A range in the data to copy into the buffer. If the range is empty, this function will return 0 without copying anything. If the range is nil, as much data as will fit into `buffer` is copied.
@@ -169,15 +172,17 @@ public struct DispatchData : RandomAccessCollection {
 			precondition(r.endIndex >= 0)
 			precondition(r.endIndex <= cnt, "The range is outside the bounds of the data")
 
-			copyRange = r.startIndex..<(r.startIndex + Swift.min(buffer.count * sizeof(DestinationType.self), r.count))
+			copyRange = r.startIndex..<(r.startIndex + Swift.min(buffer.count * MemoryLayout<DestinationType>.stride, r.count))
 		} else {
-			copyRange = 0..<Swift.min(buffer.count * sizeof(DestinationType.self), cnt)
+			copyRange = 0..<Swift.min(buffer.count * MemoryLayout<DestinationType>.stride, cnt)
 		}
 
 		guard !copyRange.isEmpty else { return 0 }
 
-		let pointer : UnsafeMutablePointer<UInt8> = UnsafeMutablePointer<UInt8>(buffer.baseAddress!)
-		_copyBytesHelper(to: pointer, from: copyRange)
+		let bufferCapacity = buffer.count * MemoryLayout<DestinationType>.stride
+		buffer.baseAddress?.withMemoryRebound(to: UInt8.self, capacity: bufferCapacity) {
+			_copyBytesHelper(to: $0, from: copyRange)
+		}
 		return copyRange.count
 	}
 

src/swift/Dispatch.swift

@@ -134,7 +134,7 @@ public enum DispatchTimeoutResult {
 /// dispatch_group
 
 public extension DispatchGroup {
-	public func notify(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], queue: DispatchQueue, execute work: @convention(block) () -> ()) {
+	public func notify(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], queue: DispatchQueue, execute work: @escaping @convention(block) () -> ()) {
 		if #available(OSX 10.10, iOS 8.0, *), qos != .unspecified || !flags.isEmpty {
 			let item = DispatchWorkItem(qos: qos, flags: flags, block: work)
 			dispatch_group_notify(self.__wrapped, queue.__wrapped, item._block)

src/swift/IO.swift

@@ -34,23 +34,23 @@ public extension DispatchIO {
 		public static let strictInterval = IntervalFlags(rawValue: 1)
 	}
 
-	public class func read(fromFileDescriptor: Int32, maxLength: Int, runningHandlerOn queue: DispatchQueue, handler: (data: DispatchData, error: Int32) -> Void) {
+	public class func read(fromFileDescriptor: Int32, maxLength: Int, runningHandlerOn queue: DispatchQueue, handler: @escaping (_ data: DispatchData, _ error: Int32) -> Void) {
 		dispatch_read(fromFileDescriptor, maxLength, queue.__wrapped) { (data: dispatch_data_t, error: Int32) in
-			handler(data: DispatchData(data: data), error: error)
+			handler(DispatchData(data: data), error)
 		}
 	}
 
-	public class func write(toFileDescriptor: Int32, data: DispatchData, runningHandlerOn queue: DispatchQueue, handler: (data: DispatchData?, error: Int32) -> Void) {
+	public class func write(toFileDescriptor: Int32, data: DispatchData, runningHandlerOn queue: DispatchQueue, handler: @escaping (_ data: DispatchData?, _ error: Int32) -> Void) {
 		dispatch_write(toFileDescriptor, data.__wrapped.__wrapped, queue.__wrapped) { (data: dispatch_data_t?, error: Int32) in
-			handler(data: data.flatMap { DispatchData(data: $0) }, error: error)
+			handler(data.flatMap { DispatchData(data: $0) }, error)
 		}
 	}
 
 	public convenience init(
 		type: StreamType,
 		fileDescriptor: Int32,
 		queue: DispatchQueue,
-		cleanupHandler: (error: Int32) -> Void)
+		cleanupHandler: @escaping (_ error: Int32) -> Void)
 	{
 		self.init(__type: type.rawValue, fd: fileDescriptor, queue: queue, handler: cleanupHandler)
 	}
@@ -61,7 +61,7 @@ public extension DispatchIO {
 		oflag: Int32,
 		mode: mode_t,
 		queue: DispatchQueue,
-		cleanupHandler: (error: Int32) -> Void)
+		cleanupHandler: @escaping (_ error: Int32) -> Void)
 	{
 		self.init(__type: type.rawValue, path: path, oflag: oflag, mode: mode, queue: queue, handler: cleanupHandler)
 	}
@@ -70,20 +70,20 @@ public extension DispatchIO {
 		type: StreamType,
 		io: DispatchIO,
 		queue: DispatchQueue,
-		cleanupHandler: (error: Int32) -> Void)
+		cleanupHandler: @escaping (_ error: Int32) -> Void)
 	{
 		self.init(__type: type.rawValue, io: io, queue: queue, handler: cleanupHandler)
 	}
 
-	public func read(offset: off_t, length: Int, queue: DispatchQueue, ioHandler: (done: Bool, data: DispatchData?, error: Int32) -> Void) {
+	public func read(offset: off_t, length: Int, queue: DispatchQueue, ioHandler: @escaping (_ done: Bool, _ data: DispatchData?, _ error: Int32) -> Void) {
 		dispatch_io_read(self.__wrapped, offset, length, queue.__wrapped) { (done: Bool, data: dispatch_data_t?, error: Int32) in
-			ioHandler(done: done, data: data.flatMap { DispatchData(data: $0) }, error: error)
+			ioHandler(done, data.flatMap { DispatchData(data: $0) }, error)
 		}
 	}
 
-	public func write(offset: off_t, data: DispatchData, queue: DispatchQueue, ioHandler: (done: Bool, data: DispatchData?, error: Int32) -> Void) {
+	public func write(offset: off_t, data: DispatchData, queue: DispatchQueue, ioHandler: @escaping (_ done: Bool, _ data: DispatchData?, _ error: Int32) -> Void) {
 		dispatch_io_write(self.__wrapped, offset, data.__wrapped.__wrapped, queue.__wrapped) { (done: Bool, data: dispatch_data_t?, error: Int32) in
-			ioHandler(done: done, data: data.flatMap { DispatchData(data: $0) }, error: error)
+			ioHandler(done, data.flatMap { DispatchData(data: $0) }, error)
 		}
 	}
 

src/swift/Queue.swift

@@ -32,7 +32,7 @@ public struct DispatchQueueAttributes : OptionSet {
 	public static let serial = DispatchQueueAttributes(rawValue: 1<<0)
 	public static let concurrent = DispatchQueueAttributes(rawValue: 1<<1)
 
-	private var _translatedValue: DispatchQueue.Attributes {
+	fileprivate var _translatedValue: DispatchQueue.Attributes {
 		if self.contains(.concurrent) { return .concurrent }
 		return []
 	}
@@ -48,7 +48,7 @@ public extension DispatchQueue {
 		@available(OSX 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *)
 		public static let initiallyInactive = Attributes(rawValue: 1<<2)
 
-		private func _attr() -> dispatch_queue_attr_t? {
+		fileprivate func _attr() -> dispatch_queue_attr_t? {
 			var attr: dispatch_queue_attr_t? = nil
 
 			if self.contains(.concurrent) {
@@ -95,7 +95,7 @@ public extension DispatchQueue {
 	public enum GlobalQueueDeprecatedPriority {
 		case qosBackground
 
-		private var _translatedValue: DispatchQoS.QoSClass {
+		fileprivate var _translatedValue: DispatchQoS.QoSClass {
 			switch self {
 			case .qosBackground: return .background
 			}
@@ -221,15 +221,15 @@ public extension DispatchQueue {
 		group: DispatchGroup? = nil, 
 		qos: DispatchQoS = .unspecified, 
 		flags: DispatchWorkItemFlags = [], 
-		execute work: @convention(block) () -> Void) 
+		execute work: @escaping @convention(block) () -> Void) 
 	{
 		if group == nil && qos == .unspecified && flags.isEmpty {
 			// Fast-path route for the most common API usage
 			CDispatch.dispatch_async(self.__wrapped, work)
 			return
 		}
 
-		var block: @convention(block) () -> Void = work
+		var block: @escaping @convention(block) () -> Void = work
 		if #available(OSX 10.10, iOS 8.0, *), (qos != .unspecified || !flags.isEmpty) {
 			let workItem = DispatchWorkItem(qos: qos, flags: flags, block: work)
 			block = workItem._block
@@ -309,7 +309,7 @@ public extension DispatchQueue {
 		deadline: DispatchTime, 
 		qos: DispatchQoS = .unspecified, 
 		flags: DispatchWorkItemFlags = [], 
-		execute work: @convention(block) () -> Void) 
+		execute work: @escaping @convention(block) () -> Void) 
 	{
 		if #available(OSX 10.10, iOS 8.0, *), qos != .unspecified || !flags.isEmpty {
 			let item = DispatchWorkItem(qos: qos, flags: flags, block: work)
@@ -323,7 +323,7 @@ public extension DispatchQueue {
 		wallDeadline: DispatchWallTime,
 		qos: DispatchQoS = .unspecified, 
 		flags: DispatchWorkItemFlags = [], 
-		execute work: @convention(block) () -> Void) 
+		execute work: @escaping @convention(block) () -> Void) 
 	{
 		if #available(OSX 10.10, iOS 8.0, *), qos != .unspecified || !flags.isEmpty {
 			let item = DispatchWorkItem(qos: qos, flags: flags, block: work)

src/swift/Time.swift

@@ -26,7 +26,7 @@ public struct DispatchTime : Comparable {
 
 	public static let distantFuture = DispatchTime(rawValue: ~0)
 
-	private init(rawValue: dispatch_time_t) { 
+	fileprivate init(rawValue: dispatch_time_t) { 
 		self.rawValue = rawValue
 	}
 
@@ -64,7 +64,7 @@ public struct DispatchWallTime : Comparable {
 
 	public static let distantFuture = DispatchWallTime(rawValue: ~0)
 
-	private init(rawValue: dispatch_time_t) {
+	fileprivate init(rawValue: dispatch_time_t) {
 		self.rawValue = rawValue
 	}
 

src/swift/Wrapper.swift

@@ -91,17 +91,17 @@ public class DispatchIO : DispatchObject {
 	}
 
 	internal init(__type: UInt, fd: Int32, queue: DispatchQueue,
-				  handler: (error: Int32) -> Void) {
+				  handler: @escaping (_ error: Int32) -> Void) {
 		__wrapped = dispatch_io_create(__type, fd, queue.__wrapped, handler)
 	}
 
 	internal init(__type: UInt, path: UnsafePointer<Int8>, oflag: Int32,
-				  mode: mode_t, queue: DispatchQueue, handler: (error: Int32) -> Void) {
+				  mode: mode_t, queue: DispatchQueue, handler: @escaping (_ error: Int32) -> Void) {
 		__wrapped = dispatch_io_create_with_path(__type, path, oflag, mode, queue.__wrapped, handler)
 	}
 
 	internal init(__type: UInt, io: DispatchIO,
-				  queue: DispatchQueue, handler: (error: Int32) -> Void) {
+				  queue: DispatchQueue, handler: @escaping (_ error: Int32) -> Void) {
 		__wrapped = dispatch_io_create_with_io(__type, io.__wrapped, queue.__wrapped, handler)
 	}
 
@@ -113,7 +113,7 @@ public class DispatchIO : DispatchObject {
 		_swift_dispatch_release(wrapped())
 	}
 
-	public func barrier(execute: () -> ()) {
+	public func barrier(execute: @escaping () -> ()) {
 		dispatch_io_barrier(self.__wrapped, execute)
 	}