add withUnsafeTuple implementation

Author: Kyle-Ye

Sources/OpenGraph/Runtime/TupleType.swift

@@ -53,7 +53,10 @@ extension UnsafeTuple {
     public var indices: Range<Int> { type.indices }
 
     public func address<T>(as _: T.Type = T.self) -> UnsafePointer<T> {
-        value.assumingMemoryBound(to: T.self)
+        guard type.type == T.self else {
+            preconditionFailure()
+        }
+        return value.assumingMemoryBound(to: T.self)
     }
 
     public func address<T>(of index: Int, as _: T.Type = T.self) -> UnsafePointer<T> {
@@ -109,7 +112,10 @@ extension UnsafeMutableTuple {
     public var indices: Range<Int> { type.indices }
 
     public func address<T>(as _: T.Type = T.self) -> UnsafeMutablePointer<T> {
-        value.assumingMemoryBound(to: T.self)
+        guard type.type == T.self else {
+            preconditionFailure()
+        }
+        return value.assumingMemoryBound(to: T.self)
     }
 
     public func address<T>(of index: Int, as _: T.Type = T.self) -> UnsafeMutablePointer<T> {
@@ -119,11 +125,11 @@ extension UnsafeMutableTuple {
 
     public subscript<T>() -> T {
         unsafeAddress { UnsafePointer(address(as: T.self)) }
-        unsafeMutableAddress { address(as: T.self) }
+        nonmutating 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) }
+        nonmutating unsafeMutableAddress { address(of: index, as: T.self) }
     }
 }

Sources/OpenGraph_SPI/Runtime/OGTupleType.cpp

@@ -231,3 +231,27 @@ void OGTupleDestoryElement(OGTupleType tuple_type, void *value, size_t index) {
     element_type->vw_destroy(reinterpret_cast<swift::OpaqueValue *>((intptr_t)value + index));
     #endif
 }
+
+void OGTupleWithBuffer(OGTupleType tuple_type, size_t count, const void (* function)(const OGUnsafeMutableTuple mutableTuple, const void * context OG_SWIFT_CONTEXT) OG_SWIFT_CC(swift), const void *context) {
+    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+    auto metadata = reinterpret_cast<OG::swift::metadata const*>(tuple_type);
+    auto buffer_size = metadata->vw_stride() * count;
+    OGUnsafeMutableTuple tuple;
+    tuple.type = tuple_type;
+    if (buffer_size <= 0x1000) {
+        char buffer[buffer_size];
+        bzero(buffer, buffer_size);
+        // NOTE: If you use buffer out of the scope, the stack may be malformed.
+        // So we need to call function in this scope.
+        function(tuple, context);
+    } else {
+        void *buffer = malloc_type_malloc(buffer_size, 0x100004077774924);
+        if (buffer == nullptr) {
+            OG::precondition_failure("memory allocation failure");
+        }
+        tuple.value = buffer;
+        function(tuple, context);
+        free(buffer);
+    }
+    #endif
+}

Sources/OpenGraph_SPI/Runtime/OGTupleType.h

@@ -80,7 +80,7 @@ void OGTupleDestoryElement(OGTupleType tuple_type, void *buffer, size_t index) O
 
 OG_EXPORT
 OG_REFINED_FOR_SWIFT
-void OGTupleWithBuffer(OGTupleType tuple_type, size_t count, const void (*_Nullable function)(const void * _Nullable context OG_SWIFT_CONTEXT) OG_SWIFT_CC(swift), const void * _Nullable context);
+void OGTupleWithBuffer(OGTupleType tuple_type, size_t count, const void (* function)(const OGUnsafeMutableTuple mutableTuple, const void * context OG_SWIFT_CONTEXT) OG_SWIFT_CC(swift), const void *context);
 
 OG_EXTERN_C_END
 

Sources/OpenGraph_SPI/Runtime/OGTypeID.h

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

Tests/OpenGraphCompatibilityTests/Runtime/TupleTypeTests.swift

@@ -99,24 +99,32 @@ 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
+        var a = 0
     }
 
-    enum T3 {
-        case a, b
+    @Test
+    func buffer() {
+        withUnsafeTuple(of: TupleType([T1.self, T2.self]), count: 1) { mutableTuple in
+            let ref = T1()
+            ref.a = 1
+            mutableTuple.initialize(at: 0, to: ref)
+            mutableTuple.initialize(at: 1, to: T2(a: 2))
+            
+            let tuple = UnsafeTuple(type: mutableTuple.type, value: mutableTuple.value)
+            let t1 = tuple[0] as T1
+            let t2 = tuple[1] as T2
+            
+            #expect(t1 === ref)
+            #expect(t1.a == 1)
+            #expect(t2.a == 2)
+        }
     }
 
     @Test
@@ -131,12 +139,9 @@ struct UnsafeMutableTupleTests {
         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)
+        #expect((mutableTuple[0] as T1).a == 1)
+        #expect((mutableTuple[1] as T2).a == 2)
 
         mutableTuple.deinitialize()
     }