Add AtomicBox and ObjectCache implementation (#114)

* Add AtomicBox implementation

* Fix OpenSwiftUICore link issue

* Add ObjectCache

* Add unit test for AtomicBox and ObjectCache

Author: Kyle-Ye

Package.swift

@@ -84,7 +84,7 @@ if warningsAsErrorsCondition {
 let openSwiftUICoreTarget = Target.target(
     name: "OpenSwiftUICore",
     dependencies: [
-        "COpenSwiftUI",
+        "COpenSwiftUICore",
         .product(name: "OpenGraphShims", package: "OpenGraph"),
     ],
     swiftSettings: sharedSwiftSettings
@@ -106,6 +106,14 @@ let openSwiftUIExtensionTarget = Target.target(
     ],
     swiftSettings: sharedSwiftSettings
 )
+let openSwiftUICoreTestTarget = Target.testTarget(
+    name: "OpenSwiftUICoreTests",
+    dependencies: [
+        "OpenSwiftUICore",
+    ],
+    exclude: ["README.md"],
+    swiftSettings: sharedSwiftSettings
+)
 let openSwiftUITestTarget = Target.testTarget(
     name: "OpenSwiftUITests",
     dependencies: [
@@ -153,6 +161,16 @@ let package = Package(
         ),
         .target(
             name: "COpenSwiftUI",
+            dependencies: [
+                "COpenSwiftUICore",
+            ],
+            cSettings: [
+                .unsafeFlags(["-I", includePath], .when(platforms: .nonDarwinPlatforms)),
+                .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
+            ]
+        ),
+        .target(
+            name: "COpenSwiftUICore",
             cSettings: [
                 .unsafeFlags(["-I", includePath], .when(platforms: .nonDarwinPlatforms)),
                 .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
@@ -206,6 +224,7 @@ extension Target {
 if attributeGraphCondition {
     openSwiftUICoreTarget.addAGSettings()
     openSwiftUITarget.addAGSettings()
+    openSwiftUICoreTestTarget.addAGSettings()
     openSwiftUITestTarget.addAGSettings()
     openSwiftUITempTestTarget.addAGSettings()
     openSwiftUICompatibilityTestTarget.addAGSettings()
@@ -244,10 +263,12 @@ if swiftTestingCondition {
         // Fix it to be 0.3.0 before we bump to Swift 5.10
         .package(url: "https://github.com/apple/swift-testing", exact: "0.6.0")
     )
+    openSwiftUICoreTestTarget.addSwiftTestingSettings()
     openSwiftUITestTarget.addSwiftTestingSettings()
     openSwiftUITempTestTarget.addSwiftTestingSettings()
     openSwiftUICompatibilityTestTarget.addSwiftTestingSettings()
 
+    package.targets.append(openSwiftUICoreTestTarget)
     package.targets.append(openSwiftUITestTarget)
     package.targets.append(openSwiftUITempTestTarget)
     package.targets.append(openSwiftUICompatibilityTestTarget)

Sources/COpenSwiftUI/Shims/CoreFoundation_Private.c renamed to Sources/COpenSwiftUICore/Shims/CoreFoundation_Private.c

@@ -0,0 +1,59 @@
+//
+//  AtomicBox.swift
+//  OpenSwiftUICore
+//
+//  Audited for RELEASE_2024
+//  Status: Complete
+//  ID: 82B2D47816BC992595021D60C278AFF0
+
+import Foundation
+
+private final class AtomicBuffer<Value>: ManagedBuffer<os_unfair_lock_s, Value> {
+    static func allocate(value: Value) -> AtomicBuffer<Value> {
+        let buffer = AtomicBuffer.create(minimumCapacity: 1) { buffer in
+            os_unfair_lock_s()
+        }
+        buffer.withUnsafeMutablePointerToElements { pointer in
+            pointer.initialize(to: value)
+        }
+        return unsafeDowncast(buffer, to: AtomicBuffer<Value>.self)
+    }
+}
+
+@propertyWrapper
+package struct AtomicBox<Value> {
+    private let buffer: AtomicBuffer<Value>
+    
+    package init(wrappedValue: Value) {
+        buffer = AtomicBuffer.allocate(value: wrappedValue)
+    }
+    
+    @inline(__always)
+    package var wrappedValue: Value {
+        get {
+            os_unfair_lock_lock(&buffer.header)
+            defer { os_unfair_lock_unlock(&buffer.header) }
+            return buffer.withUnsafeMutablePointerToElements { $0.pointee }
+        }
+        nonmutating _modify {
+            os_unfair_lock_lock(&buffer.header)
+            defer { os_unfair_lock_unlock(&buffer.header) }
+            yield &buffer.withUnsafeMutablePointerToElements { $0 }.pointee
+        }
+    }
+
+    @inline(__always)
+    package func access<T>(_ body: (inout Value) throws -> T) rethrows -> T {
+        try body(&wrappedValue)
+    }
+    
+    package var projectedValue: AtomicBox<Value> { self }
+}
+
+extension AtomicBox: @unchecked Sendable where Value: Sendable {}
+
+extension AtomicBox where Value: ExpressibleByNilLiteral {
+    package init() {
+        self.init(wrappedValue: nil)
+    }
+}

Sources/COpenSwiftUI/Shims/dyld_Private.c renamed to Sources/COpenSwiftUICore/Shims/dyld_Private.c

@@ -0,0 +1,80 @@
+//
+//  ObjectCache.swift
+//  OpenSwiftUICore
+//
+//  Audited for RELEASE_2024
+//  Status: Complete
+//  ID: FCB2944DC319042A861E82C8B244E212
+
+final package class ObjectCache<Key, Value> where Key: Hashable {
+    let constructor: (Key) -> Value
+    
+    @AtomicBox
+    private var data: Data
+    
+    @inlinable
+    package init(constructor: @escaping (Key) -> Value) {
+        self.constructor = constructor
+        self.data = Data()
+    }
+    
+    final package subscript(key: Key) -> Value {
+        let hash = key.hashValue
+        let bucket = (hash & ((1 << 3) - 1)) << 2
+        var targetOffset: Int = 0
+        var diff: Int32 = Int32.min
+        let value = $data.access { data -> Value? in
+            for offset in 0 ..< 3 {
+                let index = bucket + offset
+                if let itemData = data.table[index].data {
+                    if itemData.hash == hash, itemData.key == key {
+                        data.clock += 1
+                        data.table[index].used = data.clock
+                        return itemData.value
+                    } else {
+                        if diff < Int32(bitPattern: data.clock &- data.table[index].used) {
+                            targetOffset = offset
+                            diff = Int32.max
+                        }
+                    }
+                } else {
+                    if diff != Int32.max {
+                        targetOffset = offset
+                        diff = Int32.max
+                    }
+                }
+            }
+            return nil
+        }
+        if let value {
+            return value
+        } else {
+            let value = constructor(key)
+            $data.access { data in
+                data.clock += 1
+                data.table[bucket + targetOffset] = Item(data: (key, hash, value), used: data.clock)
+            }
+            return value
+        }
+    }
+    
+    private struct Item {
+        var data: (key: Key, hash: Int, value: Value)?
+        var used: UInt32
+        
+        init(data: (key: Key, hash: Int, value: Value)?, used: UInt32) {
+            self.data = data
+            self.used = used
+        }
+    }
+    
+    private struct Data {
+        var table: [Item]
+        var clock: UInt32
+        
+        init() {
+            self.table = Array(repeating: Item(data: nil, used: 0), count: 32)
+            self.clock = 0
+        }
+    }
+}

Sources/COpenSwiftUI/include/CoreFoundation_Private.h renamed to Sources/COpenSwiftUICore/include/CoreFoundation_Private.h

@@ -5,7 +5,7 @@
 //  Audited for RELEASE_2024
 //  Status: WIP
 
-internal import COpenSwiftUI
+internal import COpenSwiftUICore
 
 @inlinable
 @inline(__always)

Sources/COpenSwiftUI/include/OpenSwiftUIBase.h renamed to Sources/COpenSwiftUICore/include/OpenSwiftUIBase.h

@@ -0,0 +1,22 @@
+//
+//  AtomicBoxTests.swift
+//  OpenSwiftUICoreTests
+
+@testable import OpenSwiftUICore
+import Testing
+
+struct AtomicBoxTests {
+    @Test
+    func expressibleByNilLiteral() {
+        let box: AtomicBox<Int?> = AtomicBox()
+        #expect(box.wrappedValue == nil)
+        box.wrappedValue = 3
+        #expect(box.wrappedValue == 3)
+    }
+    
+    @Test
+    func access() {
+        @AtomicBox var box: Int = 3
+        #expect($box.access { $0.description } == "3")
+    }
+}

Sources/COpenSwiftUI/include/OpenSwiftUITargetConditionals.h renamed to Sources/COpenSwiftUICore/include/OpenSwiftUITargetConditionals.h

@@ -0,0 +1,16 @@
+//
+//  ObjectCacheTests.swift
+//  OpenSwiftUICoreTests
+
+@testable import OpenSwiftUICore
+import Testing
+
+struct ObjectCacheTests {
+    @Test
+    func example() {
+        let cache: ObjectCache<Int, String> = ObjectCache { key in "\(key)" }
+        #expect(cache[0] == "0")
+        #expect(cache[1] == "1")
+        #expect(cache[0] == "0")
+    }
+}

Sources/COpenSwiftUI/include/dyld_Private.h renamed to Sources/COpenSwiftUICore/include/dyld_Private.h

@@ -0,0 +1,7 @@
+## OpenSwiftUICoreTests
+
+Test API of OpenSwiftUICore
+
+```swift
+@testable import OpenSwiftUICore
+```

Sources/OpenSwiftUICore/Data/Other/AtomicBox.swift

@@ -0,0 +1,15 @@
+//
+//  Scaffolding.swift
+//
+//
+//  Created by Kyle on 2023/11/8.
+//
+
+import Testing
+import XCTest
+
+final class AllTests: XCTestCase {
+    func testAll() async {
+        await XCTestScaffold.runAllTests(hostedBy: self)
+    }
+}