Merge pull request #121 from loffgren/machport_fixes

Mach.Port: Tidiness

Author: loffgren

Sources/System/MachPort.swift

@@ -13,7 +13,7 @@ import Darwin.Mach
 
 public protocol MachPortRight {}
 
-private func machPrecondition(
+private func _machPrecondition(
   file: StaticString = #file,
   line: UInt = #line,
   _ body: @autoclosure () -> kern_return_t
@@ -23,11 +23,13 @@ private func machPrecondition(
   precondition(kr == expected, file: file, line: line)
 }
 
+/*System 1.3.0, @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)*/
+@frozen
 public enum Mach {
   @_moveOnly
   public struct Port<RightType: MachPortRight> {
-    internal var name: mach_port_name_t
-    internal var context: mach_port_context_t
+    internal var _name: mach_port_name_t
+    internal var _context: mach_port_context_t
 
     /// Transfer ownership of an existing unmanaged Mach port right into a
     /// `Mach.Port` by name.
@@ -44,17 +46,17 @@ public enum Mach {
     /// This initializer makes a syscall to guard the right.
     public init(name: mach_port_name_t) {
       precondition(name != mach_port_name_t(MACH_PORT_NULL), "Mach.Port cannot be initialized with MACH_PORT_NULL")
-      self.name = name
+      self._name = name
 
       if RightType.self == ReceiveRight.self {
         precondition(name != 0xFFFFFFFF /* MACH_PORT_DEAD */, "Receive rights cannot be dead names")
 
         let secret = mach_port_context_t(arc4random())
-        machPrecondition(mach_port_guard(mach_task_self_, name, secret, 0))
-        self.context = secret
+        _machPrecondition(mach_port_guard(mach_task_self_, name, secret, 0))
+        self._context = secret
       }
       else {
-        self.context = 0
+        self._context = 0
       }
     }
 
@@ -68,21 +70,23 @@ public enum Mach {
     ///
     /// The body block may optionally return something, which will then be
     /// returned to the caller of withBorrowedName.
-    public func withBorrowedName<ReturnType>(body: (mach_port_name_t) -> ReturnType) -> ReturnType {
-      return body(name)
+    public func withBorrowedName<ReturnType>(
+      body: (mach_port_name_t) -> ReturnType
+    ) -> ReturnType {
+      return body(_name)
     }
 
     deinit {
-      if name == 0xFFFFFFFF /* MACH_PORT_DEAD */ {
+      if _name == 0xFFFFFFFF /* MACH_PORT_DEAD */ {
         precondition(RightType.self != ReceiveRight.self, "Receive rights cannot be dead names")
-        machPrecondition(mach_port_mod_refs(mach_task_self_, name, MACH_PORT_RIGHT_DEAD_NAME, -1))
+        _machPrecondition(mach_port_mod_refs(mach_task_self_, _name, MACH_PORT_RIGHT_DEAD_NAME, -1))
       } else {
         if RightType.self == ReceiveRight.self {
-          machPrecondition(mach_port_destruct(mach_task_self_, name, -1, context))
+          _machPrecondition(mach_port_destruct(mach_task_self_, _name, -1, _context))
         } else if RightType.self == SendRight.self {
-          machPrecondition(mach_port_mod_refs(mach_task_self_, name, MACH_PORT_RIGHT_SEND, -1))
+          _machPrecondition(mach_port_mod_refs(mach_task_self_, _name, MACH_PORT_RIGHT_SEND, -1))
         } else if RightType.self == SendOnceRight.self {
-          machPrecondition(mach_port_mod_refs(mach_task_self_, name, MACH_PORT_RIGHT_SEND_ONCE, -1))
+          _machPrecondition(mach_port_mod_refs(mach_task_self_, _name, MACH_PORT_RIGHT_SEND_ONCE, -1))
         }
       }
     }
@@ -115,21 +119,22 @@ public enum Mach {
   ///
   /// This function will abort if the rights could not be created.
   /// Callers may assert that valid rights are always returned.
-  public static func allocatePortRightPair() -> (receive: Mach.Port<Mach.ReceiveRight>, send: Mach.Port<Mach.SendRight>) {
+  public static func allocatePortRightPair() ->
+    (receive: Mach.Port<Mach.ReceiveRight>, send: Mach.Port<Mach.SendRight>) {
     var name = mach_port_name_t(MACH_PORT_NULL)
     let secret = mach_port_context_t(arc4random())
     withUnsafeMutablePointer(to: &name) { name in
       var options = mach_port_options_t()
       options.flags = UInt32(MPO_INSERT_SEND_RIGHT);
       withUnsafeMutablePointer(to: &options) { options in
-        machPrecondition(mach_port_construct(mach_task_self_, options, secret, name))
+        _machPrecondition(mach_port_construct(mach_task_self_, options, secret, name))
       }
     }
     return (Mach.Port(name: name, context: secret), Mach.Port(name: name))
   }
 }
 
-public extension Mach.Port where RightType == Mach.ReceiveRight {
+extension Mach.Port where RightType == Mach.ReceiveRight {
   /// Transfer ownership of an existing, unmanaged, but already guarded,
   /// Mach port right into a Mach.Port by name.
   ///
@@ -140,20 +145,20 @@ public extension Mach.Port where RightType == Mach.ReceiveRight {
   ///
   /// The underlying port right will be automatically deallocated when
   /// the Mach.Port object is destroyed.
-  init(name: mach_port_name_t, context: mach_port_context_t) {
-    self.name = name
-    self.context = context
+  public init(name: mach_port_name_t, context: mach_port_context_t) {
+    self._name = name
+    self._context = context
   }
 
   /// Allocate a new Mach port with a receive right, creating a
   /// Mach.Port<Mach.ReceiveRight> to manage it.
   ///
   /// This initializer will abort if the right could not be created.
   /// Callers may assert that a valid right is always returned.
-  init() {
+  public init() {
     var storage: mach_port_name_t = mach_port_name_t(MACH_PORT_NULL)
     withUnsafeMutablePointer(to: &storage) { storage in
-      machPrecondition(mach_port_allocate(mach_task_self_, MACH_PORT_RIGHT_RECEIVE, storage))
+      _machPrecondition(mach_port_allocate(mach_task_self_, MACH_PORT_RIGHT_RECEIVE, storage))
     }
 
     // name-only init will guard ReceiveRights
@@ -171,8 +176,9 @@ public extension Mach.Port where RightType == Mach.ReceiveRight {
   ///
   /// After this function completes, the Mach.Port is destroyed and no longer
   /// usable.
-  __consuming func relinquish() -> (name: mach_port_name_t, context: mach_port_context_t) {
-    return (name: name, context: context)
+  public __consuming func relinquish() ->
+    (name: mach_port_name_t, context: mach_port_context_t) {
+    return (name: _name, context: _context)
   }
 
   /// Remove guard and transfer ownership of the underlying port right to
@@ -189,9 +195,9 @@ public extension Mach.Port where RightType == Mach.ReceiveRight {
   /// This function makes a syscall to remove the guard from
   /// Mach.ReceiveRights. Use relinquish() to avoid the syscall and extract
   /// the context value along with the port name.
-  __consuming func unguardAndRelinquish() -> mach_port_name_t {
-    machPrecondition(mach_port_unguard(mach_task_self_, name, context))
-    return name
+  public __consuming func unguardAndRelinquish() -> mach_port_name_t {
+    _machPrecondition(mach_port_unguard(mach_task_self_, _name, _context))
+    return _name
   }
 
   /// Borrow access to the port name in a block that can perform
@@ -203,8 +209,10 @@ public extension Mach.Port where RightType == Mach.ReceiveRight {
   ///
   /// The body block may optionally return something, which will then be
   /// returned to the caller of withBorrowedName.
-  func withBorrowedName<ReturnType>(body: (mach_port_name_t, mach_port_context_t) -> ReturnType) -> ReturnType {
-    body(name, context)
+  public func withBorrowedName<ReturnType>(
+    body: (mach_port_name_t, mach_port_context_t) -> ReturnType
+  ) -> ReturnType {
+    body(_name, _context)
   }
 
   /// Create a send-once right for a given receive right.
@@ -213,16 +221,16 @@ public extension Mach.Port where RightType == Mach.ReceiveRight {
   ///
   /// This function will abort if the right could not be created.
   /// Callers may assert that a valid right is always returned.
-  func makeSendOnceRight() -> Mach.Port<Mach.SendOnceRight> {
+  public func makeSendOnceRight() -> Mach.Port<Mach.SendOnceRight> {
     // send once rights do not coalesce
     var newRight: mach_port_name_t = mach_port_name_t(MACH_PORT_NULL)
     var newRightType: mach_port_type_t = MACH_PORT_TYPE_NONE
 
     withUnsafeMutablePointer(to: &newRight) { newRight in
       withUnsafeMutablePointer(to: &newRightType) { newRightType in
-        machPrecondition(
+        _machPrecondition(
           mach_port_extract_right(mach_task_self_,
-                                  name,
+                                  _name,
                                   mach_msg_type_name_t(MACH_MSG_TYPE_MAKE_SEND_ONCE),
                                   newRight,
                                   newRightType)
@@ -242,38 +250,38 @@ public extension Mach.Port where RightType == Mach.ReceiveRight {
   ///
   /// This function will abort if the right could not be created.
   /// Callers may assert that a valid right is always returned.
-  func makeSendRight() -> Mach.Port<Mach.SendRight> {
+  public func makeSendRight() -> Mach.Port<Mach.SendRight> {
     let how = MACH_MSG_TYPE_MAKE_SEND
 
     // name is the same because send and recv rights are coalesced
-    machPrecondition(mach_port_insert_right(mach_task_self_, name, name, mach_msg_type_name_t(how)))
+    _machPrecondition(mach_port_insert_right(mach_task_self_, _name, _name, mach_msg_type_name_t(how)))
 
-    return Mach.Port(name: name)
+    return Mach.Port(name: _name)
   }
 
   /// Access the make-send count.
   ///
   /// Each get/set of this property makes a syscall.
-  var makeSendCount : mach_port_mscount_t {
+  public var makeSendCount : mach_port_mscount_t {
     get {
       var status: mach_port_status = mach_port_status()
       var size: mach_msg_type_number_t = mach_msg_type_number_t(MemoryLayout<mach_port_status>.size / MemoryLayout<natural_t>.size)
       withUnsafeMutablePointer(to: &size) { size in
         withUnsafeMutablePointer(to: &status) { status in
           let info = UnsafeMutableRawPointer(status).bindMemory(to: integer_t.self, capacity: 1)
-          machPrecondition(mach_port_get_attributes(mach_task_self_, name, MACH_PORT_RECEIVE_STATUS, info, size))
+          _machPrecondition(mach_port_get_attributes(mach_task_self_, _name, MACH_PORT_RECEIVE_STATUS, info, size))
         }
       }
       return status.mps_mscount
     }
 
     set {
-      machPrecondition(mach_port_set_mscount(mach_task_self_, name, newValue))
+      _machPrecondition(mach_port_set_mscount(mach_task_self_, _name, newValue))
     }
   }
 }
 
-public extension Mach.Port where RightType == Mach.SendRight {
+extension Mach.Port where RightType == Mach.SendRight {
   /// Transfer ownership of the underlying port right to the caller.
   ///
   /// Returns the Mach port name representing the right.
@@ -283,8 +291,8 @@ public extension Mach.Port where RightType == Mach.SendRight {
   ///
   /// After this function completes, the Mach.Port is destroyed and no longer
   /// usable.
-  __consuming func relinquish() -> mach_port_name_t {
-    return name
+  public __consuming func relinquish() -> mach_port_name_t {
+    return _name
   }
 
   /// Create another send right from a given send right.
@@ -294,22 +302,22 @@ public extension Mach.Port where RightType == Mach.SendRight {
   /// If the send right being copied has become a dead name, meaning the
   /// receiving side has been deallocated, then copySendRight() will throw
   /// a Mach.PortRightError.deadName error.
-  func copySendRight() throws -> Mach.Port<Mach.SendRight> {
+  public func copySendRight() throws -> Mach.Port<Mach.SendRight> {
     let how = MACH_MSG_TYPE_COPY_SEND
 
     // name is the same because send rights are coalesced
-    let kr = mach_port_insert_right(mach_task_self_, name, name, mach_msg_type_name_t(how))
+    let kr = mach_port_insert_right(mach_task_self_, _name, _name, mach_msg_type_name_t(how))
     if kr == KERN_INVALID_CAPABILITY {
       throw Mach.PortRightError.deadName
     }
-    machPrecondition(kr)
+    _machPrecondition(kr)
 
-    return Mach.Port(name: name)
+    return Mach.Port(name: _name)
   }
 }
 
 
-public extension Mach.Port where RightType == Mach.SendOnceRight {
+extension Mach.Port where RightType == Mach.SendOnceRight {
   /// Transfer ownership of the underlying port right to the caller.
   ///
   /// Returns the Mach port name representing the right.
@@ -319,8 +327,8 @@ public extension Mach.Port where RightType == Mach.SendOnceRight {
   ///
   /// After this function completes, the Mach.Port is destroyed and no longer
   /// usable.
-  __consuming func relinquish() -> mach_port_name_t {
-    return name
+  public __consuming func relinquish() -> mach_port_name_t {
+    return _name
   }
 }
 

Utilities/expand-availability.py

@@ -48,6 +48,7 @@
     "System 0.0.2": "macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0",
     "System 1.1.0": "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999",
     "System 1.2.0": "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999",
+    "System 1.3.0": "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999",
 }
 
 parser = argparse.ArgumentParser(description="Expand availability macros.")