Add UnsafeMutableTupleTests

Author: Kyle-Ye

Sources/OpenGraph/Runtime/Metadata.swift

@@ -27,7 +27,7 @@ extension Metadata: Swift.Hashable, Swift.CustomStringConvertible {
     @inlinable
     @inline(__always)
     public init(_ type: Any.Type) {
-        self.init(rawValue: unsafeBitCast(type, to: UnsafePointer<OGSwiftMetadata>.self))
+        self.init(rawValue: unsafeBitCast(type, to: UnsafePointer<_Metadata>.self))
     }
 
     @inlinable

Sources/OpenGraph/Runtime/TupleType.swift

@@ -7,27 +7,24 @@
 
 public import OpenGraph_SPI
 
+// MARK: TupleType
+
 extension TupleType {
     public init(_ types: [Any.Type]) {
         self.init(count: types.count, elements: types.map(Metadata.init))
     }
 
     public init(_ type: Any.Type) {
-        self.init(rawValue: unsafeBitCast(type, to: UnsafePointer<OGSwiftMetadata>.self))
+        self.init(rawValue: unsafeBitCast(type, to: UnsafePointer<_Metadata>.self))
     }
 
+    public var isEmpty: Bool { count == 0 }
+    public var indices: Range<Int> { 0 ..< count }
+    
     public var type: Any.Type {
         unsafeBitCast(rawValue, to: Any.Type.self)
     }
 
-    public var isEmpty: Bool {
-        count == 0
-    }
-    
-    public var indices: Range<Int> {
-        0 ..< count
-    }
-    
     public func type(at index: Int) -> Any.Type {
         elementType(at: index).type
     }
@@ -47,3 +44,86 @@ extension TupleType {
 
 @_silgen_name("OGTupleWithBuffer")
 public func withUnsafeTuple(of type: TupleType, count: Int, _ body: (UnsafeMutableTuple) -> ())
+
+// MARK: - UnsafeTuple
+
+extension UnsafeTuple {
+    public var count: Int { type.count }
+    public var isEmpty: Bool { type.isEmpty }
+    public var indices: Range<Int> { type.indices }
+    
+    public func address<T>(as _: T.Type = T.self) -> UnsafePointer<T> {
+        value.assumingMemoryBound(to: T.self)
+    }
+    
+    public func address<T>(of index: Int, as _: T.Type = T.self) -> UnsafePointer<T> {
+        value.advanced(by: type.elementOffset(at: index, type: Metadata(T.self)))
+            .assumingMemoryBound(to: T.self)
+    }
+    
+    public subscript<T>() -> T {
+        unsafeAddress { address(as: T.self) }
+    }
+    
+    public subscript<T>(_ index: Int) -> T {
+        unsafeAddress { address(of: index, as: T.self) }
+    }
+}
+
+// MARK: - UnsafeMutableTuple
+
+@_silgen_name("swift_slowAlloc")
+private func slowAlloc(_ size: Int, _ alignMask: Int) -> UnsafeMutableRawPointer
+
+@_silgen_name("swift_slowDealloc")
+private func slowDealloc(_ ptr: UnsafeMutableRawPointer, _ size: Int, _ alignMask: Int)
+
+extension UnsafeMutableTuple {
+    public init(with tupleType: TupleType) {
+        self.init(type: tupleType, value: slowAlloc(tupleType.size, -1))
+    }
+    
+    public func initialize<T>(at index: Int, to element: T) {
+        withUnsafePointer(to: element) { elementPointer in
+            type.setElement(in: value, at: index, from: elementPointer, options: .initCopy)
+        }
+    }
+    
+    public func deinitialize() {
+        type.destory(value)
+    }
+    
+    public func deinitialize(at index: Int) {
+        type.destory(value, at: index)
+    }
+
+    public func deallocate(initialized: Bool) {
+        if initialized {
+            deinitialize()
+        }
+        slowDealloc(value, -1, -1)
+    }
+    
+    public var count: Int { type.count }
+    public var isEmpty: Bool { type.isEmpty }
+    public var indices: Range<Int> { type.indices }
+    
+    public func address<T>(as _: T.Type = T.self) -> UnsafeMutablePointer<T> {
+        value.assumingMemoryBound(to: T.self)
+    }
+    
+    public func address<T>(of index: Int, as _: T.Type = T.self) -> UnsafeMutablePointer<T> {
+        value.advanced(by: type.elementOffset(at: index, type: Metadata(T.self)))
+            .assumingMemoryBound(to: T.self)
+    }
+    
+    public subscript<T>() -> T {
+        unsafeAddress { UnsafePointer(address(as: T.self)) }
+        unsafeMutableAddress { address(as: T.self) }
+    }
+    
+    public subscript<T>(_ index: Int) -> T {
+        unsafeAddress { UnsafePointer(address(of: index, as: T.self)) }
+        unsafeMutableAddress { address(of: index, as: T.self) }
+    }
+}

Sources/OpenGraph_SPI/Runtime/OGTupleType.h

@@ -22,19 +22,15 @@ typedef OG_CLOSED_ENUM(uint32_t, OGTupleCopyOptions) {
     OGTupleCopyOptionsInitTake = 3
 } OG_SWIFT_NAME(TupleType.CopyOptions);
 
-struct OGUnsafeTuple {
+typedef struct OG_SWIFT_NAME(UnsafeTuple) OGUnsafeTuple {
     OGTupleType type;
     const void *value;
-} OG_SWIFT_NAME(UnsafeTuple);
+} OGUnsafeTuple;
 
-typedef struct OGUnsafeTuple OGUnsafeTuple;
-
-struct OGUnsafeMutableTuple {
+typedef struct OG_SWIFT_NAME(UnsafeMutableTuple) OGUnsafeMutableTuple {
     OGTupleType type;
     void *value;
-} OG_SWIFT_NAME(UnsafeMutableTuple);
-
-typedef struct OGUnsafeMutableTuple OGUnsafeMutableTuple;
+} OGUnsafeMutableTuple;
 
 OG_EXTERN_C_BEGIN
 

Sources/OpenGraph_SPI/Runtime/OGTypeID.h

@@ -13,8 +13,8 @@
 
 OG_ASSUME_NONNULL_BEGIN
 
-typedef struct OGSwiftMetadata {
-} OGSwiftMetadata OG_SWIFT_NAME(_Metadata);
+typedef struct OG_SWIFT_NAME(_Metadata) OGSwiftMetadata {
+} OGSwiftMetadata ;
 
 typedef const OGSwiftMetadata *OGTypeID OG_SWIFT_STRUCT OG_SWIFT_NAME(Metadata);
 

Tests/OpenGraphCompatibilityTests/Runtime/TupleTypeTests.swift

@@ -98,3 +98,46 @@ struct TupleTypeTests {
         }
     }
 }
+
+@Suite(.enabled(if: swiftToolchainSupported))
+struct UnsafeTupleTests {
+}
+
+@Suite(.enabled(if: swiftToolchainSupported))
+struct UnsafeMutableTupleTests {
+    class T1 {
+        var a = 0
+        var b: Double = 0
+    }
+    
+    struct T2 {
+        var a: Int = 0
+        var b: Double = 0
+    }
+    
+    enum T3 {
+        case a, b
+    }
+    
+    @Test
+    func initialize() {
+        let mutableTuple = UnsafeMutableTuple(with: TupleType([T1.self, T2.self]))
+        
+        #expect(mutableTuple.count == 2)
+        #expect(mutableTuple.isEmpty == false)
+        
+        let t1 = T1()
+        t1.a = 1
+        let t2 = T2(a: 2)
+        mutableTuple.initialize(at: 0, to: t1)
+        mutableTuple.initialize(at: 1, to: t2)
+
+        let retrievedT1: T1 = mutableTuple[0]
+        let retrievedT2: T2 = mutableTuple[1]
+        
+        #expect(retrievedT1.a == 1)
+        #expect(retrievedT2.a == 2)
+        
+        mutableTuple.deinitialize()
+    }
+}