Add basic UIHostingView support

Package.resolved

@@ -6,7 +6,7 @@
       "location" : "https://github.com/OpenSwiftUIProject/OpenGraph",
       "state" : {
         "branch" : "main",
-        "revision" : "ed01e7196afe56bf953f2f14b0b463208dda9c8d"
+        "revision" : "ccb771c9fd939f1e1eefb46f69139e94ebb0dc82"
       }
     },
     {

Scripts/openswiftui_swiftinterface.sh

@@ -11,4 +11,4 @@ cd $OPENSWIFTUI_ROOT
 
 export OPENSWIFTUI_SWIFT_TESTING=0
 export OPENGRAPH_SWIFT_TESTING=0
-swift build -c release -Xswiftc -emit-module-interface -Xswiftc -enable-library-evolution
+swift build -Xswiftc -emit-module-interface -Xswiftc -enable-library-evolution

Sources/OpenSwiftUI/App/ScenePhase.swift

@@ -0,0 +1,24 @@
+//
+//  ScenePhase.swift
+//  OpenSwiftUI
+//
+//  Audited for RELEASE_2021
+//  Status: WIP
+//  ID: 130BB08D98602D712FD59CAC6992C14A
+
+public enum ScenePhase: Comparable, Hashable {
+    case background
+    case inactive
+    case active
+}
+
+private struct ScenePhaseKey: EnvironmentKey {
+    static let defaultValue: ScenePhase = .background
+}
+
+extension EnvironmentValues {
+    public var scenePhase: ScenePhase {
+        get { self[ScenePhaseKey.self] }
+        set { self[ScenePhaseKey.self] = newValue }
+    }
+}

Sources/OpenSwiftUI/Core/Graph/GraphHost.swift

@@ -20,8 +20,8 @@ class GraphHost {
     private(set) var hostPreferenceValues: OptionalAttribute<PreferenceList>
     private(set) var lastHostPreferencesSeed: VersionSeed = .invalid
     private var pendingTransactions: [AsyncTransaction] = []
-    private(set) var inTransaction = false
-    private(set) var continuations: [() -> Void] = []
+    /*private(set)*/ var inTransaction = false
+    /*private(set)*/ var continuations: [() -> Void] = []
     private(set) var mayDeferUpdate = true
     private(set) var removedState: RemovedState = []
 
@@ -156,7 +156,8 @@ class GraphHost {
     }
 
     final func updatePreferences() -> Bool {
-        fatalError("TODO")
+        // fatalError("TODO")
+        return false
     }
 
     final func updateRemovedState() {

Sources/OpenSwiftUI/Core/Log/Signpost.swift

@@ -24,6 +24,8 @@ struct Signpost {
         }
     }
 
+    static let render = Signpost(style: .kdebug(0), stability: .published)
+    static let renderUpdate = Signpost(style: .kdebug(0), stability: .published)
     static let viewHost = Signpost(style: .kdebug(0), stability: .published)
 }
 

Sources/OpenSwiftUI/Core/Render/DisplayLink.swift

@@ -0,0 +1,68 @@
+//
+//  DisplayLink.swift
+//  OpenSwiftUI
+//
+//  Audited for RELEASE_2021
+//  Status: WIP
+//  ID: D912470A6161D66810B373079EE9F26A
+
+#if canImport(Darwin) && os(iOS) // Disable macOS temporary due to CADisplayLink issue
+import QuartzCore
+#if os(iOS)
+import UIKit
+#elseif os(macOS)
+import AppKit
+#endif
+
+final class DisplayLink: NSObject {
+    private weak var host: AnyUIHostingView?
+    private var link: CADisplayLink?
+    private var nextUpdate: Time
+    private var currentUpdate: Time?
+    private var interval: Double
+    private var reasons: Set<UInt32>
+    private var currentThread: ThreadName
+    private var nextThread: ThreadName
+
+    #if os(iOS)
+    init(host: AnyUIHostingView, window: UIWindow) {
+        fatalError("TODO")
+    }
+    #elseif os(macOS)
+    init(host: AnyUIHostingView, window: NSWindow) {
+        fatalError("TODO")
+    }
+    #endif
+
+    var willRender: Bool {
+        nextUpdate < .infinity
+    }
+
+    func setNextUpdate(delay: Double, interval: Double, reasons: Set<UInt32>) {
+        // TODO
+    }
+
+    func invalidate() {
+        Update.lock.withLock {
+            // TODO
+        }
+    }
+
+    @inline(__always)
+    func startAsyncRendering() {
+        nextThread = .async
+    }
+
+    @inline(__always)
+    func cancelAsyncRendering() {
+        nextThread = .main
+    }
+}
+
+extension DisplayLink {
+    enum ThreadName: Hashable {
+        case main
+        case async
+    }
+}
+#endif

Sources/OpenSwiftUI/Core/Update/Update.swift

@@ -19,7 +19,7 @@ extension MovableLock {
 
 enum Update {
     static let trackHost: AnyObject = TraceHost()
-    private static let lock = MovableLock.create()
+    static let lock = MovableLock.create()
     private static var depth = 0
     private static var actions: [() -> Void] = []
 
@@ -63,15 +63,15 @@ enum Update {
         }
     }
 
-    @inlinable
+    @inline(__always)
     static func dispatchActions() {
         // FIXME
         for action in actions {
             action()
         }
     }
 
-    @inlinable
+    @inline(__always)
     static func syncMain(_ body: () -> Void) {
         // TODO
         fatalError("TODO")

Sources/OpenSwiftUI/Core/Util/Time.swift

@@ -5,6 +5,10 @@
 //  Audited for RELEASE_2021
 //  Status: Complete
 
+#if canImport(QuartzCore)
+import QuartzCore
+#endif
+
 struct Time: Comparable, Hashable {
     var seconds : Double
 
@@ -14,4 +18,76 @@ struct Time: Comparable, Hashable {
 
     static let zero = Time(seconds: .zero)
     static let infinity = Time(seconds: .infinity)
+
+    #if canImport(QuartzCore)
+    @inline(__always)
+    static var now: Time {
+        Time(seconds: CACurrentMediaTime())
+    }
+    #endif
+
+    @inline(__always)
+    private init(seconds: Double) {
+        self.seconds = seconds
+    }
+
+    @inline(__always)
+    static func seconds(_ value: Double) -> Time {
+        Time(seconds: value)
+    }
+
+    @inline(__always)
+    static func seconds(_ value: Int) -> Time {
+        Time(seconds: Double(value))
+    }
+
+    @inline(__always)
+    static func microseconds(_ value: Double) -> Time {
+        Time(seconds: value * 1e-3)
+    }
+
+    @inline(__always)
+    static func milliseconds(_ value: Double) -> Time {
+        Time(seconds: value * 1e-6)
+    }
+
+    @inline(__always)
+    static func nanoseconds(_ value: Double) -> Time {
+        Time(seconds: value * 1e-9)
+    }
+
+    @inline(__always)
+    static func += (lhs: inout Time, rhs: Time) {
+        lhs.seconds = lhs.seconds + rhs.seconds
+    }
+
+    @inline(__always)
+    static func + (lhs: Time, rhs: Time) -> Time {
+        Time(seconds: lhs.seconds + rhs.seconds)
+    }
+
+    @inline(__always)
+    static func -= (lhs: inout Time, rhs: Time) {
+        lhs.seconds = lhs.seconds - rhs.seconds
+    }
+
+    @inline(__always)
+    static func - (lhs: Time, rhs: Time) -> Time {
+        Time(seconds: lhs.seconds - rhs.seconds)
+    }
+
+    @inline(__always)
+    mutating func advancing(by seconds: Double) {
+        self.seconds += seconds
+    }
+
+    @inline(__always)
+    func advanced(by seconds: Double) -> Time {
+        Time(seconds: self.seconds + seconds)
+    }
+
+    @inline(__always)
+    func distance(to other: Time) -> Double {
+        seconds.distance(to: other.seconds)
+    }
 }