Skipped observability notifications since introduction of `shouldNotifyObservers`

[jpsim]

Description

I don't yet have a repro case, but for our iOS app, we've noticed that as of #3751 we have parts of our app that aren't notified when state changes. Reverting af60ed2 fixes the issue for us.

I will try to get more information to make this bug report more actionable, but in the meantime I wanted to at least flag this regression and give an opportunity for other users of TCA to weigh in if they've seen the same thing in their projects.

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

No response

Actual behavior

No response

Reproducing project

No response

The Composable Architecture version information

1.22.2

Destination operating system

iOS 18.5

Xcode version information

Version 16.4 (16F6)

Swift Compiler version information

swift-driver version: 1.120.5 Apple Swift version 6.1.2 (swiftlang-6.1.2.1.2 clang-1700.0.13.5)
Target: arm64-apple-macosx15.0

[stephencelis]

@jpsim The shouldNotifyObservers affects Equatable types and classes. Do you think you might have a custom equatable conformance interfering with observation?

[mbrandonw]

Even though #3774 was closed, I am curious to hear from @jpsim when you have a moment. Is there a chance the problem you are seeing is related to reference types with custom Equatable conformances?

[jpsim]

Do you think you might have a custom equatable conformance interfering with observation?
Is there a chance the problem you are seeing is related to reference types with custom Equatable conformances?

It's quite possible! The property with skipped observation updates was an IdentifiedArray from the swift-identified-collections project, which does indeed have a custom Equatable conformance: https://github.com/pointfreeco/swift-identified-collections/blob/main/Sources/IdentifiedCollections/IdentifiedArray/IdentifiedArray%2BEquatable.swift

[jpsim]

Here's a complete repro case:

import ComposableArchitecture
import SwiftUI

// MARK: - TCA Bug Reproduction View

struct TCA3771View: View {
  let store: StoreOf<TCA3771>

  var body: some View {
    NavigationView {
      VStack(spacing: 0) {
        // Header with issue description
        VStack(spacing: 16) {
          Text("TCA Issue #3771 Bug Reproduction")
            .font(.title2)
            .fontWeight(.semibold)

          Text("This demonstrates a bug where UI doesn't update when IdentifiedArray elements change due to shouldNotifyObservers interfering with custom Equatable conformance.")
            .font(.body)
            .multilineTextAlignment(.center)
            .foregroundColor(.secondary)

          VStack(spacing: 8) {
            Text("🐛 BUG TEST")
              .font(.headline)
              .foregroundColor(.red)

            Text("When you tap 'Deactivate', does the item change from ACTIVE to INACTIVE?")
              .font(.subheadline)
              .multilineTextAlignment(.center)

            Text("Expected: Item should update immediately in both versions")
              .font(.caption)
              .foregroundColor(.orange)
              .multilineTextAlignment(.center)
          }
          .padding()
          .background(Color.yellow.opacity(0.1))
          .cornerRadius(8)
        }
        .padding()
        .background(Color(.systemGroupedBackground))

        // Comparison views
        HStack(spacing: 1) {
          // Broken version (Direct Store)
          VStack(spacing: 16) {
            VStack(spacing: 8) {
              Text("❌ BROKEN")
                .font(.headline)
                .foregroundColor(.red)
                .fontWeight(.bold)

              Text("Direct Store Access")
                .font(.caption)
                .foregroundColor(.secondary)
            }
            .padding(.top)

            Text("Active Items: \(store.activeItemsCount)")
              .font(.title3)
              .fontWeight(.semibold)
              .foregroundColor(store.activeItemsCount > 0 ? .primary : .green)

            Button("Add Item") {
              store.send(.addItem)
            }
            .buttonStyle(.borderedProminent)

            List {
              ForEach(store.items) { itemState in
                ItemRowView(
                  item: itemState,
                  onDeactivate: { store.send(.deactivateItem(itemState.id)) }
                )
              }
            }
            .listStyle(.plain)
          }
          .frame(maxWidth: .infinity)
          .background(Color.red.opacity(0.05))

          // Working version (WithViewStore)
          WithViewStore(store, observe: { $0 }) { viewStore in
            VStack(spacing: 16) {
              VStack(spacing: 8) {
                Text("✅ WORKING")
                  .font(.headline)
                  .foregroundColor(.green)
                  .fontWeight(.bold)

                Text("WithViewStore")
                  .font(.caption)
                  .foregroundColor(.secondary)
              }
              .padding(.top)

              Text("Active Items: \(viewStore.activeItemsCount)")
                .font(.title3)
                .fontWeight(.semibold)
                .foregroundColor(viewStore.activeItemsCount > 0 ? .primary : .green)

              Button("Add Item") {
                viewStore.send(.addItem)
              }
              .buttonStyle(.borderedProminent)

              List {
                ForEach(viewStore.items) { itemState in
                  ItemRowView(
                    item: itemState,
                    onDeactivate: { viewStore.send(.deactivateItem(itemState.id)) }
                  )
                }
              }
              .listStyle(.plain)
            }
            .frame(maxWidth: .infinity)
            .background(Color.green.opacity(0.05))
          }
        }
      }
    }
    .navigationTitle("TCA Bug #3771")
    .navigationBarTitleDisplayMode(.inline)
  }
}

// MARK: - Item Row Component

struct ItemRowView: View {
  let item: ItemState
  let onDeactivate: () -> Void

  var body: some View {
    VStack(alignment: .leading, spacing: 6) {
      HStack {
        VStack(alignment: .leading, spacing: 4) {
          Text(item.name)
            .font(.body)
            .fontWeight(.medium)

          Text(item.isActive ? "🟢 ACTIVE" : "🔴 INACTIVE")
            .font(.caption)
            .fontWeight(.semibold)
            .foregroundColor(item.isActive ? .green : .red)
        }

        Spacer()

        if item.isActive {
          Button("Deactivate") {
            onDeactivate()
          }
          .buttonStyle(.borderedProminent)
          .controlSize(.small)
        }
      }

      Text("ID: \(item.id)")
        .font(.caption2)
        .foregroundColor(.secondary)
    }
    .padding(.vertical, 4)
    .opacity(item.isActive ? 1.0 : 0.6)
  }
}

// MARK: - Bug Reproduction Models

@ObservableState
struct ItemState: Identifiable, Equatable, Sendable {
  let id: String
  let name: String
  let isActive: Bool

  init(
    id: String = UUID().uuidString,
    name: String,
    isActive: Bool = true
  ) {
    self.id = id
    self.name = name
    self.isActive = isActive
  }
}

@Reducer
struct TCA3771 {
  @ObservableState
  struct State: Equatable {
    var items: IdentifiedArrayOf<ItemState> = []
    var itemCounter: Int = 0

    var activeItemsCount: Int {
      items.filter(\.isActive).count
    }

    init() {}
  }

  enum Action {
    case addItem
    case deactivateItem(String)
  }

  init() {}

  var body: some Reducer<State, Action> {
    Reduce { state, action in
      switch action {
      case .addItem:
        state.itemCounter += 1
        let newItem = ItemState(
          name: "Item \(state.itemCounter)",
          isActive: true
        )
        state.items.append(newItem)
        return .none

      case .deactivateItem(let itemID):
        guard let itemIndex = state.items.index(id: itemID) else { return .none }

        let currentItem = state.items[itemIndex]
        let updatedItem = ItemState(
          id: currentItem.id,
          name: currentItem.name,
          isActive: false
        )

        state.items[itemIndex] = updatedItem

        return .none
      }
    }
  }
}

Screen Recording:

tca-3771-repro.mp4

[stephencelis]

@jpsim Unfortunately that repro will also fail before shouldNotifyObservers was added. It's a known gotcha with replacing IdentifiedArray elements in place. Are you sure this is a new problem? If you verify that your code broke when the shouldNotifyObservers was added can you share a repro that fails on main but worked fine before?

[jpsim]

You're right, that's not the same bug, I must have poorly translated my original code when producing a reduced repro case. I'll try again.

[ecito]

We're also experiencing some non-notification/non-updates since that commit, so +1 on that something is going on.

Still trying to pin-point/reproduce cleanly... but one thing I've noticed is it happens more frequently on release builds. Perhaps something is getting optimized away?

[jpsim]

Ok here's an actual repro case of the bug we're seeing, confirmed broken after af60ed2 and fixed by reverting that commit:

Buggy demo

tca-repro-3771-buggy.mp4

Working demo

tca-repro-3771-working.mp4

Code

import ComposableArchitecture
import SwiftUI

// MARK: - TCA Bug Reproduction View

struct TCA3771View: View {
  let store: StoreOf<TCA3771>

  var body: some View {
    NavigationView {
      VStack(spacing: 0) {
        HStack {
          Text("Items: \(store.items.count)")
            .font(.caption)
          Spacer()
          Text("Active: \(store.activeItems.count)")
            .font(.caption)
        }
        .padding(.horizontal)
        .padding(.vertical, 4)
        .background(Color.gray.opacity(0.1))

        if store.showEmptyView {
          VStack {
            Text("✅ All items deactivated!")
              .font(.title2)
              .padding()
            Spacer()
          }
        } else if store.items.isEmpty {
          VStack {
            Text("Loading...")
              .font(.title2)
              .padding()
            Spacer()
          }
        } else {
          ScrollView {
            LazyVStack(spacing: 8) {
              ForEach(
                store.scope(state: \.activeItems, action: \.item)
              ) { itemStore in
                TCA3771ItemView(store: itemStore)
              }
            }
            .padding()
          }
        }
      }
      .task {
        await store.send(.onAppear).finish()
      }
    }
  }
}

// MARK: - Item View

private struct TCA3771ItemView: View {
  let store: StoreOf<TCA3771ItemReducer>

  var body: some View {
    HStack {
      VStack(alignment: .leading, spacing: 4) {
        Text(store.data.item.title)
          .font(.headline)

        if store.data.isActive {
          Text("🟢 Active")
            .font(.caption)
            .foregroundColor(.green)
        } else {
          Text("⚪ Inactive")
            .font(.caption)
            .foregroundColor(.orange)
        }
      }

      Spacer()

      if store.data.isActive {
        Button("Deactivate") {
          store.send(.tappedDeactivate)
        }
        .buttonStyle(.borderedProminent)
        .controlSize(.small)
      }
    }
    .padding()
    .background(Color(.systemGray6))
    .cornerRadius(8)
  }
}

// MARK: - Simple Data Models

struct TCA3771Item: Equatable, Sendable {
  let id: String
  let title: String
}

struct TCA3771ItemData: Equatable, Sendable {
  let id: String
  let item: TCA3771Item
  var isActive: Bool
}

// MARK: - Mock Data Source

private actor TCA3771MockDataSource {
  static let shared = TCA3771MockDataSource()

  private var items: [TCA3771ItemData] = []
  private var continuations: [AsyncStream<[TCA3771ItemData]>.Continuation] = []

  private init() {
    items = (1...5).map { index in
      TCA3771ItemData(
        id: "item-\(index)",
        item: TCA3771Item(id: "item-\(index)", title: "Task #\(index)"),
        isActive: true
      )
    }
  }

  func getStream() -> AsyncStream<[TCA3771ItemData]> {
    AsyncStream { continuation in
      continuations.append(continuation)
      continuation.yield(items)
    }
  }

  func setItemActive(_ id: String, isActive: Bool) {
    if let index = items.firstIndex(where: { $0.id == id }) {
      items[index].isActive = isActive
      for continuation in continuations {
        continuation.yield(items)
      }
    }
  }
}

// MARK: - Item Reducer

@Reducer
struct TCA3771ItemReducer {
  @ObservableState
  struct State: Identifiable, Equatable, Sendable {
    let data: TCA3771ItemData
    var id: String { data.id }
  }

  enum Action: Equatable, Sendable {
    case tappedDeactivate
  }
}

// MARK: - Main Reducer

@Reducer
struct TCA3771 {
  @ObservableState
  struct State: Equatable, Sendable {
    var items: IdentifiedArrayOf<TCA3771ItemReducer.State> = []
    var hasSetItems = false

    var activeItems: IdentifiedArrayOf<TCA3771ItemReducer.State> {
      items.filter { $0.data.isActive }
    }

    var showEmptyView: Bool {
      hasSetItems && activeItems.isEmpty
    }
  }

  enum Action: Equatable, Sendable {
    case onAppear
    case item(IdentifiedActionOf<TCA3771ItemReducer>)
    case observedItems([TCA3771ItemData])
    case setOptimisticallyDeactivated(TCA3771ItemData, Bool)
  }

  var body: some Reducer<State, Action> {
    Reduce { state, action in
      switch action {
      case .onAppear:
        return .run { send in
          let stream = await TCA3771MockDataSource.shared.getStream()
          for await items in stream {
            await send(.observedItems(items))
          }
        }
      case .item(.element(id: let id, action: .tappedDeactivate)):
        guard let item = state.items[id: id]?.data else { return .none }
        return .send(.setOptimisticallyDeactivated(item, false), animation: .default)

      case .setOptimisticallyDeactivated(let item, let isActive):
        return .run { _ in
          await TCA3771MockDataSource.shared.setItemActive(item.id, isActive: isActive)
        }

      case .observedItems(let items):
        let newItems = IdentifiedArray(uniqueElements: items.map { TCA3771ItemReducer.State(data: $0) })
        let diff = newItems.difference(
          from: state.items,
          by: { $0.data == $1.data }
        )
        state.items = state.items.applying(diff) ?? newItems
        state.hasSetItems = true
        return .none

      case .item:
        return .none
      }
    }
    .forEach(\.items, action: \.item) {
      TCA3771ItemReducer()
    }
  }
}