Sendable wrappers for pointer types

.github/workflows/test.yml

@@ -43,8 +43,6 @@ jobs:
       - uses: actions/checkout@v4
         with:
           submodules: true
-            #      - name: Give up and run in docker
-            # run: 'docker run -v `pwd`:`pwd` -w `pwd` --name steamworks --rm swift:5.9 /bin/bash -c "apt-get update; apt-get install make; (cd sdk && make install); swift test -Xswiftc -cxx-interoperability-mode=default"'
       - name: Set up SDK
         run: cd sdk && sudo make install
       - name: Run tests

Makefile

@@ -27,7 +27,7 @@ clean:
 
 # Random flags here to get around crap Linux C++ support
 test_linux:
-	docker run -v `pwd`:`pwd` -w `pwd` --name steamworks --rm swiftlang/swift:nightly-5.9-focal /bin/bash -c "apt-get update; apt-get install make; (cd sdk && make install); swift test -Xswiftc -cxx-interoperability-mode=default"
+	docker run -v `pwd`:`pwd` -w `pwd` --name steamworks --rm swift:5.10 /bin/bash -c "apt-get update; apt-get install make; (cd sdk && make install); swift test  -Xswiftc -cxx-interoperability-mode=default"
 
 shell_linux:
-	docker run -it -v `pwd`:`pwd` -w `pwd` --name steamworks --rm  swiftlang/swift:nightly-5.9-focal /bin/bash
+	docker run -it -v `pwd`:`pwd` -w `pwd` --name steamworks --rm swift:5.10 /bin/bash

Sources/LibGenerate/Interfaces.swift

@@ -89,10 +89,14 @@ extension MetadataDB.Interface.Access {
 
         switch self {
         case .instance:
+            let sendableSwiftType = "Steam\(swiftType)"
             decl = """
-                       private let interface: \(swiftType)
+                       private let _interface: \(sendableSwiftType)
+                       private var interface: \(swiftType) {
+                           _interface.base
+                       }
                        init(_ interface: \(swiftType)) {
-                           self.interface = interface
+                           self._interface = .init(interface)
                        }
                    """
         case .user(let accessor), .gameserver(let accessor), .global(let accessor):

Sources/LibGenerate/SteamSwiftTypes.swift

@@ -78,6 +78,14 @@ extension SteamType {
         return SwiftType(name1.replacingOccurrences(of: "_", with: ""))
     }
 
+    var sendableSwiftType: SwiftType {
+        let base = swiftType
+        if base.isSendable {
+            return base
+        }
+        return SwiftType("Steam\(base.name)")
+    }
+
     /// Does this C++ type look like a pointer but is actually something else?
     /// Mostly for `const char *` -> `String`
     fileprivate var isPointerTypePassedByValue: Bool {
@@ -409,6 +417,10 @@ extension SwiftTypeUtils {
     var isOptional: Bool {
         name.hasSuffix("?")
     }
+
+    var isSendable: Bool {
+        !name.re_isMatch("^Unsafe.*Pointer$")
+    }
 }
 
 // MARK: SwiftExpr

Sources/LibGenerate/Structs.swift

@@ -97,7 +97,7 @@ extension MetadataDB.Struct.Field {
     /// Swift structure declaration field
     var declLine: [String] {[
         "/// Steamworks `\(name)`",
-        "public let \(name.swiftName): \(type.swiftType)"
+        "public let \(name.swiftName): \(type.sendableSwiftType)"
     ]}
 
     /// Swift structure initializer lines
@@ -130,7 +130,7 @@ extension MetadataDB.Struct.Field {
     /// Default value setup for memberwise initializer
     var memberwiseParameter: String {
         let initClause = type.swiftTypeInstance.flatMap { " = \($0)"} ?? ""
-        return "\(name.swiftName): \(type.swiftType)\(initClause)"
+        return "\(name.swiftName): \(type.sendableSwiftType)\(initClause)"
     }
 
     /// Initializer line for memberwise initializer

Sources/LibGenerate/Typedefs.swift

@@ -56,12 +56,28 @@ extension MetadataDB.Typedef {
         var decl = """
                    /// Steamworks `\(typedef)`
                    public struct \(swiftType): Hashable, Sendable {
-                       public let value: \(swiftNativeType)
-                       public init(_ value: \(swiftNativeType)) { self.value = value }
-                   }
 
-                   extension \(swiftType): SteamTypeAlias, SteamCreatable {}
                    """
+        if swiftNativeType.isSendable {
+            decl += """
+                        public let value: \(swiftNativeType)
+                        public init(_ value: \(swiftNativeType)) { self.value = value }
+                    }
+                    """
+        } else {
+            decl += """
+                        private let _value: Steam\(swiftNativeType)
+                        public var value: \(swiftNativeType) { _value.base }
+                        public init(_ value: \(swiftNativeType)) { self._value = .init(value) }
+                    }
+                    """
+        }
+        decl += """
+
+
+                extension \(swiftType): SteamTypeAlias, SteamCreatable {}
+                """
+
         if swiftNativeType.isInteger {
             decl += """
 

Sources/Steamworks/Generated/SteamNetworkingFakeUDPPort.swift

@@ -12,9 +12,12 @@
 ///
 /// Access via ``SteamNetworkingSockets/createFakeUDPPort(fakeServerPort:)``.
 public final class SteamNetworkingFakeUDPPort: Sendable {
-    private let interface: UnsafeMutablePointer<ISteamNetworkingFakeUDPPort>
+    private let _interface: SteamUnsafeMutablePointer<ISteamNetworkingFakeUDPPort>
+    private var interface: UnsafeMutablePointer<ISteamNetworkingFakeUDPPort> {
+        _interface.base
+    }
     init(_ interface: UnsafeMutablePointer<ISteamNetworkingFakeUDPPort>) {
-        self.interface = interface
+        self._interface = .init(interface)
     }
 
     /// Steamworks `ISteamNetworkingFakeUDPPort::DestroyFakeUDPPort()`

Sources/Steamworks/Generated/Structs.swift

@@ -1875,7 +1875,7 @@ public struct HTMLNeedsPaint: Sendable {
     /// Steamworks `unBrowserHandle`
     public let browserHandle: HHTMLBrowser
     /// Steamworks `pBGRA`
-    public let bgra: UnsafeRawPointer
+    public let bgra: SteamUnsafeRawPointer
     /// Steamworks `unWide`
     public let wide: Int
     /// Steamworks `unTall`
@@ -1898,7 +1898,7 @@ public struct HTMLNeedsPaint: Sendable {
     public let pageSerial: Int
 
     /// Create a customized `HTMLNeedsPaint`
-    public init(browserHandle: HHTMLBrowser = 0, bgra: UnsafeRawPointer, wide: Int = 0, tall: Int = 0, updateX: Int = 0, updateY: Int = 0, updateWide: Int = 0, updateTall: Int = 0, scrollX: Int = 0, scrollY: Int = 0, pageScale: Float = 0, pageSerial: Int = 0) {
+    public init(browserHandle: HHTMLBrowser = 0, bgra: SteamUnsafeRawPointer, wide: Int = 0, tall: Int = 0, updateX: Int = 0, updateY: Int = 0, updateWide: Int = 0, updateTall: Int = 0, scrollX: Int = 0, scrollY: Int = 0, pageScale: Float = 0, pageSerial: Int = 0) {
         self.browserHandle = browserHandle
         self.bgra = bgra
         self.wide = wide

Sources/Steamworks/Generated/Typedefs.swift

@@ -76,8 +76,9 @@ extension HHTMLBrowser: ExpressibleByIntegerLiteral {
 
 /// Steamworks `HServerListRequest`
 public struct HServerListRequest: Hashable, Sendable {
-    public let value: UnsafeMutableRawPointer
-    public init(_ value: UnsafeMutableRawPointer) { self.value = value }
+    private let _value: SteamUnsafeMutableRawPointer
+    public var value: UnsafeMutableRawPointer { _value.base }
+    public init(_ value: UnsafeMutableRawPointer) { self._value = .init(value) }
 }
 
 extension HServerListRequest: SteamTypeAlias, SteamCreatable {}

Sources/Steamworks/TypeUtils.swift

@@ -168,6 +168,44 @@ extension Optional where Wrapped == UnsafeMutablePointer<UnsafeMutablePointer<Ma
     }
 }
 
+// MARK: Sendable
+
+/// An unsafe `Sendable` wrapper.
+///
+/// This is used to wrap pointers that the Steam API uses in a potentially-sendable context.
+/// Typically these pointers are read-only, whether or not the Steam API has marked them `const`,
+/// so there is no real risk to them, but the Steam API client code is responsible for serializing any
+/// write action that is required.
+public struct SteamUncheckedSendable<Base>: @unchecked Sendable {
+    let base: Base
+    init(_ base: Base) {
+        self.base = base
+    }
+}
+
+extension SteamUncheckedSendable: Equatable where Base: Equatable {
+    /// :nodoc:
+    public static func == (lhs: SteamUncheckedSendable<Base>, rhs: SteamUncheckedSendable<Base>) -> Bool {
+        lhs.base == rhs.base
+    }
+}
+
+extension SteamUncheckedSendable: Hashable where Base: Hashable {
+    /// :nodoc:
+    public func hash(into hasher: inout Hasher) {
+        base.hash(into: &hasher)
+    }
+}
+
+/// A `Sendable` wrapper of `UnsafeMutableRawPointer`.
+public typealias SteamUnsafeMutableRawPointer = SteamUncheckedSendable<UnsafeMutableRawPointer>
+
+/// A `Sendable` wrapper of `UnsafeRawPointer`.
+public typealias SteamUnsafeRawPointer = SteamUncheckedSendable<UnsafeRawPointer>
+
+/// A `Sendable` wrapper of `UnsafeMutablePointer`.
+public typealias SteamUnsafeMutablePointer<T> = SteamUncheckedSendable<UnsafeMutablePointer<T>>
+
 // MARK: Typedefs
 
 /// Conversion of Swift Types to Steam types, for passing in typedefs to Steamworks