[perf]: don't instantiate debugger info if not needed (#331)

refactors action propagation to no longer instantiate any
`WorkflowDebugInfo` types unless there is a `WorkflowDebugger` set on
the host. this should avoid some unnecessary string allocations and
reflection metadata lookups.

Author: jamieQ

Workflow/Sources/Debugging.swift

@@ -148,3 +148,23 @@ extension WorkflowHierarchyDebugSnapshot {
         }
     }
 }
+
+// MARK: - Compatibility
+
+/// These extensions are utilities to support conditionally emitting debug info only when a
+/// `debugger` is set.
+extension WorkflowUpdateDebugInfo? {
+    var unwrappedOrErrorDefault: WorkflowUpdateDebugInfo {
+        self ?? .unexpectedlyMissing
+    }
+}
+
+extension WorkflowUpdateDebugInfo {
+    fileprivate static let unexpectedlyMissing = {
+        assertionFailure("Creation of actual WorkflowUpdateDebugInfo failed unexpectedly")
+        return WorkflowUpdateDebugInfo(
+            workflowType: "BUG IN WORKFLOW",
+            kind: .didUpdate(source: .external)
+        )
+    }()
+}

Workflow/Sources/SubtreeManager.swift

@@ -131,10 +131,29 @@ extension WorkflowNode {
     }
 }
 
+/// Carries information about the provenance of an event handled by the runtime.
+enum EventSource: Equatable {
+    /// An event received from an external source.
+    case external
+
+    /// An event that comes from a descendent in the subtree.
+    /// Will contain associated debug info iff the `debugger` property of the `WorkflowHost`
+    /// is set.
+    case subtree(WorkflowUpdateDebugInfo?)
+
+    /// Compatibility method to convert to the public representation of this data
+    func toDebugInfoSource() -> WorkflowUpdateDebugInfo.Source {
+        switch self {
+        case .external: .external
+        case .subtree(let maybeInfo): .subtree(maybeInfo.unwrappedOrErrorDefault)
+        }
+    }
+}
+
 extension WorkflowNode.SubtreeManager {
     enum Output {
-        case update(any WorkflowAction<WorkflowType>, source: WorkflowUpdateDebugInfo.Source)
-        case childDidUpdate(WorkflowUpdateDebugInfo)
+        case update(any WorkflowAction<WorkflowType>, source: EventSource)
+        case childDidUpdate(WorkflowUpdateDebugInfo?)
     }
 }
 

Workflow/Sources/WorkflowHost.swift

@@ -95,10 +95,12 @@ public final class WorkflowHost<WorkflowType: Workflow> {
         // Treat the update as an "output" from the workflow originating from an external event to force a render pass.
         let output = WorkflowNode<WorkflowType>.Output(
             outputEvent: nil,
-            debugInfo: WorkflowUpdateDebugInfo(
-                workflowType: "\(WorkflowType.self)",
-                kind: .didUpdate(source: .external)
-            )
+            debugInfo: context.ifDebuggerEnabled {
+                WorkflowUpdateDebugInfo(
+                    workflowType: "\(WorkflowType.self)",
+                    kind: .didUpdate(source: .external)
+                )
+            }
         )
         handle(output: output)
     }
@@ -112,7 +114,7 @@ public final class WorkflowHost<WorkflowType: Workflow> {
 
         debugger?.didUpdate(
             snapshot: rootNode.makeDebugSnapshot(),
-            updateInfo: output.debugInfo
+            updateInfo: output.debugInfo.unwrappedOrErrorDefault
         )
 
         rootNode.enableEvents()
@@ -140,3 +142,11 @@ final class HostContext {
         self.debugger = debugger
     }
 }
+
+extension HostContext {
+    func ifDebuggerEnabled<T>(
+        _ perform: () -> T
+    ) -> T? {
+        debugger != nil ? perform() : nil
+    }
+}

Workflow/Sources/WorkflowNode.swift

@@ -96,19 +96,23 @@ final class WorkflowNode<WorkflowType: Workflow> {
             /// Finally, we tell the outside world that our state has changed (including an output event if it exists).
             output = Output(
                 outputEvent: outputEvent,
-                debugInfo: WorkflowUpdateDebugInfo(
-                    workflowType: "\(WorkflowType.self)",
-                    kind: .didUpdate(source: source)
-                )
+                debugInfo: hostContext.ifDebuggerEnabled {
+                    WorkflowUpdateDebugInfo(
+                        workflowType: "\(WorkflowType.self)",
+                        kind: .didUpdate(source: source.toDebugInfoSource())
+                    )
+                }
             )
 
         case .childDidUpdate(let debugInfo):
             output = Output(
                 outputEvent: nil,
-                debugInfo: WorkflowUpdateDebugInfo(
-                    workflowType: "\(WorkflowType.self)",
-                    kind: .childDidUpdate(debugInfo)
-                )
+                debugInfo: hostContext.ifDebuggerEnabled {
+                    WorkflowUpdateDebugInfo(
+                        workflowType: "\(WorkflowType.self)",
+                        kind: .childDidUpdate(debugInfo.unwrappedOrErrorDefault)
+                    )
+                }
             )
         }
 
@@ -179,7 +183,7 @@ final class WorkflowNode<WorkflowType: Workflow> {
 extension WorkflowNode {
     struct Output {
         var outputEvent: WorkflowType.Output?
-        var debugInfo: WorkflowUpdateDebugInfo
+        var debugInfo: WorkflowUpdateDebugInfo?
     }
 }
 

Workflow/Tests/HostContextTests.swift

@@ -0,0 +1,23 @@
+import XCTest
+
+@testable import Workflow
+
+final class HostContextTests: XCTestCase {
+    func test_conditional_debug_info_no_debugger() {
+        let subject = HostContext.testing(debugger: nil)
+        subject.ifDebuggerEnabled {
+            XCTFail("should not be called")
+        }
+    }
+
+    func test_conditional_debug_info_with_debugger() {
+        let subject = HostContext.testing(debugger: TestDebugger())
+        let expectation = expectation(description: "debugger block invoked")
+
+        subject.ifDebuggerEnabled {
+            expectation.fulfill()
+        }
+
+        wait(for: [expectation], timeout: 0.001)
+    }
+}

Workflow/Tests/TestUtilities.swift

@@ -57,15 +57,29 @@ struct StateTransitioningWorkflow: Workflow {
     }
 }
 
-// MARK: -
+// MARK: - HostContext
 
 extension HostContext {
     static func testing(
-        observer: WorkflowObserver? = nil
+        observer: WorkflowObserver? = nil,
+        debugger: WorkflowDebugger? = nil
     ) -> HostContext {
         HostContext(
             observer: observer,
-            debugger: nil
+            debugger: debugger
         )
     }
 }
+
+// MARK: - WorkflowDebugger
+
+struct TestDebugger: WorkflowDebugger {
+    func didEnterInitialState(
+        snapshot: WorkflowHierarchyDebugSnapshot
+    ) {}
+
+    func didUpdate(
+        snapshot: WorkflowHierarchyDebugSnapshot,
+        updateInfo: WorkflowUpdateDebugInfo
+    ) {}
+}

Workflow/Tests/WorkflowNodeTests.swift

@@ -110,12 +110,13 @@ final class WorkflowNodeTests: XCTestCase {
             b: SimpleWorkflow(string: "World")
         )
 
-        let node = WorkflowNode(workflow: workflow)
+        let context = HostContext.testing(debugger: TestDebugger())
+        let node = WorkflowNode(workflow: workflow, hostContext: context)
 
         let rendering = node.render()
         node.enableEvents()
 
-        var emittedDebugInfo: [WorkflowUpdateDebugInfo] = []
+        var emittedDebugInfo: [WorkflowUpdateDebugInfo?] = []
 
         let expectation = XCTestExpectation(description: "Output")
         node.onOutput = { value in
@@ -130,11 +131,12 @@ final class WorkflowNodeTests: XCTestCase {
         XCTAssertEqual(emittedDebugInfo.count, 1)
 
         let debugInfo = emittedDebugInfo[0]
-
-        XCTAssert(debugInfo.workflowType == "\(WorkflowType.self)")
+        XCTAssert(debugInfo?.workflowType == "\(WorkflowType.self)")
 
         /// Test the shape of the emitted debug info
-        switch debugInfo.kind {
+        switch debugInfo?.kind {
+        case .none:
+            XCTFail()
         case .childDidUpdate:
             XCTFail()
         case .didUpdate(let source):
@@ -158,6 +160,38 @@ final class WorkflowNodeTests: XCTestCase {
         }
     }
 
+    func test_noDebugUpdateInfoIfNoDebugger() {
+        typealias WorkflowType = CompositeWorkflow<EventEmittingWorkflow, SimpleWorkflow>
+
+        let workflow = CompositeWorkflow(
+            a: EventEmittingWorkflow(string: "Hello"),
+            b: SimpleWorkflow(string: "World")
+        )
+
+        let context = HostContext.testing(debugger: nil)
+        let node = WorkflowNode(workflow: workflow, hostContext: context)
+
+        let rendering = node.render()
+        node.enableEvents()
+
+        var emittedDebugInfo: [WorkflowUpdateDebugInfo?] = []
+
+        let expectation = XCTestExpectation(description: "Output")
+        node.onOutput = { value in
+            emittedDebugInfo.append(value.debugInfo)
+            expectation.fulfill()
+        }
+
+        rendering.aRendering.someoneTappedTheButton()
+
+        wait(for: [expectation], timeout: 1.0)
+
+        XCTAssertEqual(emittedDebugInfo.count, 1)
+
+        let debugInfo = emittedDebugInfo[0]
+        XCTAssertNil(debugInfo)
+    }
+
     func test_debugTreeSnapshots() {
         typealias WorkflowType = CompositeWorkflow<EventEmittingWorkflow, SimpleWorkflow>