Reduce key path COW copies in Graph forEach and compactMapValues (#1725)

This avoids an accidentally-superlinear COW copy of the key path during
`Graph.forEach` and `Graph.compactMapValues` traversal.

  ### Motivation:

While reading [@harlanhaskins](https://github.com/harlanhaskins)'
[#1626](#1626) (which
fixes a quadratic COW issue on `Graph.insertValue`), I noticed that
`_forEach` and
`_compactMapValues` carry a related — though less dramatic — version of
the same pattern. Each recursive call builds the descendant's key path
with `var childKeyPath = keyPath; childKeyPath.append(key)`, and because
`childKeyPath` is COW-shared with `keyPath`, the `append` always
triggers a copy of the whole key-path array. For a graph with `N` nodes
at average depth `d`, this turns traversal into _O(N · d)_ instead of
the _O(N)_ it should
  be.

In isolated benchmarks of the key-path copy pattern at depths 3–6 with
branching factor 3–5, the new inout-based version is consistently **3–5×
faster**, with the speedup growing with depth — exactly as expected from
the _O(N ·
  d) → O(N)_ change:

  | Config | Nodes | Old | New | Speedup |
  | --- | --- | --- | --- | --- |
  | depth 3, branch 3 | 40 | 0.006 ms | 0.002 ms | 3.51× |
  | depth 4, branch 4 | 341 | 0.059 ms | 0.012 ms | 4.84× |
  | depth 4, branch 5 | 781 | 0.138 ms | 0.029 ms | 4.84× |
  | depth 5, branch 4 | 1,365 | 0.242 ms | 0.046 ms | 5.21× |
  | depth 6, branch 4 | 5,461 | 0.830 ms | 0.159 ms | 5.23× |

  ### Modifications:

The four `_forEach` / `_compactMapValues` overloads (sync + async for
each) now thread a single `inout [K]` through the recursion. After
invoking the body, the child's key is appended once, recursion descends,
and the key is
popped on the way back up — mutating the key path in place rather than
copying it on every descent. The public `forEach(_:)` and
`compactMapValues(_:)` wrappers create the initial `var keyPath: [K] =
[]` and pass it through; the
  public API surface is unchanged.

All six current `forEach` callsites (two in `Runner.Plan`, four in
`AdvancedConsoleOutputRecorder`) consume the key path inline — none of
them escape it — so the existing semantics are preserved. The existing
`GraphTests` for
  `forEach`, `forEach (async)`, and `compactMapValues` pass unchanged.


  ### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: inju2403

Sources/Testing/Support/Graph.swift

@@ -389,36 +389,34 @@ extension Graph {
   /// The recursive implementation of `forEach(_:)`.
   ///
   /// - Parameters:
-  ///   - keyPath: The key path to use for the root node when passing it to
-  ///     `body`.
+  ///   - keyPath: The key path of the current node, passed to `body`.
   ///   - body: A closure that is invoked once per element in the graph. The key
   ///     path and leaf value of each node are passed to the closure.
   ///
   /// - Throws: Whatever is thrown by `body`.
-  private func _forEach<E>(keyPath: [K], _ body: (Element) throws(E) -> Void) throws(E) {
+  private func _forEach<E>(keyPath: inout [K], _ body: (Element) throws(E) -> Void) throws(E) {
     try body((keyPath, value))
     for (key, child) in children {
-      var childKeyPath = keyPath
-      childKeyPath.append(key)
-      try child._forEach(keyPath: childKeyPath, body)
+      keyPath.append(key)
+      try child._forEach(keyPath: &keyPath, body)
+      keyPath.removeLast()
     }
   }
 
   /// The recursive implementation of `forEach(_:)`.
   ///
   /// - Parameters:
-  ///   - keyPath: The key path to use for the root node when passing it to
-  ///     `body`.
+  ///   - keyPath: The key path of the current node, passed to `body`.
   ///   - body: A closure that is invoked once per element in the graph. The
   ///     key path and leaf value of each node are passed to the closure.
   ///
   /// - Throws: Whatever is thrown by `body`.
-  private func _forEach<E>(keyPath: [K], _ body: (Element) async throws(E) -> Void) async throws(E) {
+  private func _forEach<E>(keyPath: inout [K], _ body: (Element) async throws(E) -> Void) async throws(E) {
     try await body((keyPath, value))
     for (key, child) in children {
-      var childKeyPath = keyPath
-      childKeyPath.append(key)
-      try await child._forEach(keyPath: childKeyPath, body)
+      keyPath.append(key)
+      try await child._forEach(keyPath: &keyPath, body)
+      keyPath.removeLast()
     }
   }
 
@@ -432,7 +430,8 @@ extension Graph {
   ///
   /// This function iterates depth-first.
   func forEach<E>(_ body: (Element) throws(E) -> Void) throws(E) {
-    try _forEach(keyPath: []) { (element) throws(E) in
+    var keyPath: [K] = []
+    try _forEach(keyPath: &keyPath) { (element) throws(E) in
       try body(element)
     }
   }
@@ -447,7 +446,8 @@ extension Graph {
   ///
   /// This function iterates depth-first.
   func forEach<E>(_ body: (Element) async throws(E) -> Void) async throws(E) {
-    try await _forEach(keyPath: []) { (element) async throws(E) in
+    var keyPath: [K] = []
+    try await _forEach(keyPath: &keyPath) { (element) async throws(E) in
       try await body(element)
     }
   }
@@ -546,16 +546,16 @@ extension Graph {
   ///
   /// This function iterates depth-first.
   func compactMapValues<U, E>(_ transform: (Element) throws(E) -> (U, recursivelyApply: Bool)?) throws(E) -> Graph<K, U>? {
-    try _compactMapValues(keyPath: []) { (element) throws(E) in
+    var keyPath: [K] = []
+    return try _compactMapValues(keyPath: &keyPath) { (element) throws(E) in
       try transform(element)
     }
   }
 
   /// The recursive implementation of `compactMapValues(_:)`.
   ///
   /// - Parameters:
-  ///   - keyPath: The key path to use for the root node when passing it to
-  ///     `transform`.
+  ///   - keyPath: The key path of the current node, passed to `transform`.
   ///   - transform: A closure that is invoked once per element in the graph.
   ///     The key path and leaf value of each node are passed to this closure.
   ///     The result of the closure is a tuple containing the new value and
@@ -565,21 +565,21 @@ extension Graph {
   ///     child nodes are omitted from the new graph.
   ///
   /// - Throws: Whatever is thrown by `transform`.
-  private func _compactMapValues<U, E>(keyPath: [K], _ transform: (Element) throws(E) -> (U, recursivelyApply: Bool)?) throws(E) -> Graph<K, U>? {
+  private func _compactMapValues<U, E>(keyPath: inout [K], _ transform: (Element) throws(E) -> (U, recursivelyApply: Bool)?) throws(E) -> Graph<K, U>? {
     guard let (newValue, recursivelyApply) = try transform((keyPath, value)) else {
       return nil
     }
 
     var newChildren = [K: Graph<K,U>]()
     newChildren.reserveCapacity(children.count)
     for (key, child) in children {
-      var childKeyPath = keyPath
-      childKeyPath.append(key)
+      keyPath.append(key)
+      defer { keyPath.removeLast() }
 
       if recursivelyApply {
-        newChildren[key] = child._compactMapValues(keyPath: childKeyPath) { _ in (newValue, true) }
+        newChildren[key] = child._compactMapValues(keyPath: &keyPath) { _ in (newValue, true) }
       } else {
-        newChildren[key] = try child._compactMapValues(keyPath: childKeyPath, transform)
+        newChildren[key] = try child._compactMapValues(keyPath: &keyPath, transform)
       }
     }
 
@@ -606,16 +606,16 @@ extension Graph {
   ///
   /// This function iterates depth-first.
   func compactMapValues<U, E>(_ transform: (Element) async throws(E) -> (U, recursivelyApply: Bool)?) async throws(E) -> Graph<K, U>? {
-    try await _compactMapValues(keyPath: []) { (element) async throws(E) in
+    var keyPath: [K] = []
+    return try await _compactMapValues(keyPath: &keyPath) { (element) async throws(E) in
       try await transform(element)
     }
   }
 
   /// The recursive implementation of `compactMapValues(_:)`.
   ///
   /// - Parameters:
-  ///   - keyPath: The key path to use for the root node when passing it to
-  ///     `transform`.
+  ///   - keyPath: The key path of the current node, passed to `transform`.
   ///   - transform: A closure that is invoked once per element in the graph.
   ///     The key path and leaf value of each node are passed to this closure.
   ///     The result of the closure is a tuple containing the new value and
@@ -625,21 +625,21 @@ extension Graph {
   ///     child nodes are omitted from the new graph.
   ///
   /// - Throws: Whatever is thrown by `transform`.
-  private func _compactMapValues<U, E>(keyPath: [K], _ transform: (Element) async throws(E) -> (U, recursivelyApply: Bool)?) async throws(E) -> Graph<K, U>? {
+  private func _compactMapValues<U, E>(keyPath: inout [K], _ transform: (Element) async throws(E) -> (U, recursivelyApply: Bool)?) async throws(E) -> Graph<K, U>? {
     guard let (newValue, recursivelyApply) = try await transform((keyPath, value)) else {
       return nil
     }
 
     var newChildren = [K: Graph<K,U>]()
     newChildren.reserveCapacity(children.count)
     for (key, child) in children {
-      var childKeyPath = keyPath
-      childKeyPath.append(key)
+      keyPath.append(key)
+      defer { keyPath.removeLast() }
 
       if recursivelyApply {
-        newChildren[key] = child._compactMapValues(keyPath: childKeyPath) { _ in (newValue, true) }
+        newChildren[key] = child._compactMapValues(keyPath: &keyPath) { _ in (newValue, true) }
       } else {
-        newChildren[key] = try await child._compactMapValues(keyPath: childKeyPath, transform)
+        newChildren[key] = try await child._compactMapValues(keyPath: &keyPath, transform)
       }
     }