Circular reference ReducerProtocol

[ghost]

Hello everyone, compiler yells at me saying that there is a circular reference
Here's the code, especially it says that there is a circular reference because of the Action enum in the ElementReducer

struct ApplicationReducer: ReducerProtocol {
    struct State {
        var sidebar: SidebarReducer.State
    }
    
    enum Action {
        case sidebar(SidebarReducer.Action)
    }
    
    var body: some ReducerProtocol<State, Action> {
        Scope(state: \.sidebar, action: /Action.sidebar) {
            SidebarReducer()
        }
    }
}

struct SidebarReducer: ReducerProtocol {
    struct State: Equatable {
        var folders: IdentifiedArrayOf<ElementReducer.State> = []
    }
    
    enum Action {
        case element(id: ElementReducer.State.ID, action: ElementReducer.Action)
    }
    
    @Dependency(\.uuid) var uuid
    
    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
            case .element:
                return .none
            }
             
        }
        .forEach(\.folders, action: /Action.element(id:action:)) {
            ElementReducer()
        }
    }
}

struct ElementReducer: ReducerProtocol {
    struct State: Identifiable, Equatable {
        let id: UUID
        var title: String
        var isCollapsed: Bool
        var isHighlighted: Bool
        var nestedElements: IdentifiedArrayOf<State>
    }
     
    enum Action: Equatable {
        case cursorIsPointing(Bool)
        case itemTapped
        case changedTitle(String)
        indirect case nestedElement(id: State.ID, action: Action)
    }
    
    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
            case .changedTitle(let title):
                state.title = title
                return .none
            case .cursorIsPointing(let pointing):
                state.isHighlighted = pointing
                return .none
            case .itemTapped:
                state.isCollapsed.toggle()
                return .none
            case .nestedElement:
                return .none
            }
        }
        .forEach(\.nestedElements, action: /Action.nestedElement(id:action:)) {
            Self()
        }
    }
}

[tgrapperon]

Hey @infinitySqrdd
Apparently, this is the State.ID that is triggering the apparent circular reference. It seems to build if you specify the type explicitly instead:

indirect case nestedElement(id: UUID, action: Action)

I'm not sure what's going on exactly here right now, but at least this can let you get through in the meantime.

[tgrapperon]

I think the "issue" is created a step above, when you declare:

case element(id: ElementReducer.State.ID, action: ElementReducer.Action)

It also builds if you specify UUID only here.
It seems to be a Swift bug, as I don't see why it would be circular given that State.ID is unambiguously locked to an UUID. I'll try to extract a simplified repro.

[mbrandonw]

I was able to boil it down to this:

enum A {
  case a(id: Int, b: B)
}
indirect enum B {
  case b(id: Int, b: B)
  case z
}

That fails to compile, but removing the "id" argument from either case fixes. Very bizarre Swift bug.

[mbrandonw]

I submitted a bug report: swiftlang/swift#62060

[ghost]

That feeling when you broke Swift Compiler
I thought that it could be an issue with the compiler, but decided to go to the discussions since I could miss something
I am very thankful for your help and replies!

[iampatbrown]

@infinitySqrdd Marking your action as Sendable is a possible workaround in the short term.

enum Action: Equatable, Sendable {

It works for me with yours and @mbrandonw's example.