Short-circuit the store cache from uncached stores

Sources/ComposableArchitecture/Store.swift

@@ -133,6 +133,7 @@ import SwiftUI
 /// of the store are also checked to make sure that work is performed on the main thread.
 public final class Store<State, Action> {
   private var bufferedActions: [Action] = []
+  fileprivate var canCacheChildren = true
   fileprivate var children: [AnyHashable: AnyObject] = [:]
   @_spi(Internals) public var effectCancellables: [UUID: AnyCancellable] = [:]
   var _isInvalidated = { false }
@@ -1033,14 +1034,16 @@ extension ScopedStoreReducer: AnyScopedStoreReducer {
     removeDuplicates isDuplicate: ((ChildState, ChildState) -> Bool)?
   ) -> Store<ChildState, ChildAction> {
     let id = id?(store.stateSubject.value)
-    if let id = id,
+    if
+      store.canCacheChildren,
+      let id = id,
       let childStore = store.children[id] as? Store<ChildState, ChildAction>
     {
       return childStore
     }
     let fromAction = self.fromAction as! (A) -> RootAction?
     let isInvalid =
-      id == nil
+      id == nil || !store.canCacheChildren
       ? {
         store._isInvalidated() || isInvalid?(store.stateSubject.value) == true
       }
@@ -1067,6 +1070,7 @@ extension ScopedStoreReducer: AnyScopedStoreReducer {
       reducer
     }
     childStore._isInvalidated = isInvalid
+    childStore.canCacheChildren = store.canCacheChildren && id != nil
     childStore.parentCancellable = store.stateSubject
       .dropFirst()
       .sink { [weak store, weak childStore] state in
@@ -1092,7 +1096,11 @@ extension ScopedStoreReducer: AnyScopedStoreReducer {
         Logger.shared.log("\(storeTypeName(of: store)).scope")
       }
     if let id = id {
-      store.children[id] = childStore
+      if store.canCacheChildren {
+        store.children[id] = childStore
+      } else {
+        // runtimeWarn("Can't cache child store at '\(id)' in an uncached store")
+      }
     }
     return childStore
   }

Tests/ComposableArchitectureTests/StoreLifetimeTests.swift

@@ -0,0 +1,106 @@
+import XCTest
+import ComposableArchitecture
+
+@MainActor
+final class StoreLifetimeTests: BaseTCATestCase {
+  func testStoreCaching() {
+    let grandparentStore = Store(initialState: Grandparent.State()) {
+      Grandparent()
+    }
+    let parentStore = grandparentStore.scope(state: \.child, action: \.child)
+    XCTAssertTrue(parentStore === grandparentStore.scope(state: \.child, action: \.child))
+    XCTAssertFalse(
+      parentStore === grandparentStore.scope(state: { $0.child }, action: { .child($0) })
+    )
+    let childStore = parentStore.scope(state: \.child, action: \.child)
+    XCTAssertTrue(childStore === parentStore.scope(state: \.child, action: \.child))
+    XCTAssertFalse(
+      childStore === parentStore.scope(state: { $0.child }, action: { .child($0) })
+    )
+  }
+
+  func testStoreInvalidation() {
+    let grandparentStore = Store(initialState: Grandparent.State()) {
+      Grandparent()
+    }
+    var parentStore: Store! = grandparentStore.scope(state: { $0.child }, action: { .child($0) })
+    let childStore = parentStore.scope(state: \.child, action: \.child)
+
+    childStore.send(.tap)
+    XCTAssertEqual(1, grandparentStore.withState(\.child.child.count))
+    XCTAssertEqual(1, parentStore.withState(\.child.count))
+    XCTAssertEqual(1, childStore.withState(\.count))
+    grandparentStore.send(.incrementGrandchild)
+    XCTAssertEqual(2, grandparentStore.withState(\.child.child.count))
+    XCTAssertEqual(2, parentStore.withState(\.child.count))
+    XCTAssertEqual(2, childStore.withState(\.count))
+
+    parentStore = nil
+
+    childStore.send(.tap)
+    XCTAssertEqual(3, grandparentStore.withState(\.child.child.count))
+    XCTAssertEqual(3, childStore.withState(\.count))
+    grandparentStore.send(.incrementGrandchild)
+    XCTAssertEqual(4, grandparentStore.withState(\.child.child.count))
+    XCTAssertEqual(4, childStore.withState(\.count))
+  }
+}
+
+@Reducer
+fileprivate struct Child {
+  struct State: Equatable {
+    var count = 0
+  }
+  enum Action {
+    case tap
+  }
+  var body: some ReducerOf<Self> {
+    Reduce { state, action in
+      switch action {
+      case .tap:
+        state.count += 1
+        return .none
+      }
+    }
+  }
+}
+
+@Reducer
+fileprivate struct Parent {
+  struct State: Equatable {
+    var child = Child.State()
+  }
+  enum Action {
+    case child(Child.Action)
+  }
+  var body: some ReducerOf<Self> {
+    Scope(state: \.child, action: \.child) {
+      Child()
+    }
+  }
+}
+
+@Reducer
+fileprivate struct Grandparent {
+  struct State: Equatable {
+    var child = Parent.State()
+  }
+  enum Action {
+    case child(Parent.Action)
+    case incrementGrandchild
+  }
+  var body: some ReducerOf<Self> {
+    Scope(state: \.child, action: \.child) {
+      Parent()
+    }
+    Reduce { state, action in
+      switch action {
+      case .child:
+        return .none
+      case .incrementGrandchild:
+        state.child.child.count += 1
+        return .none
+      }
+    }
+  }
+}