Getter for 'subscript(dynamicMember:)' is unavailable Xcode16

[yliu342]

Hi,

TLDR; When trying to build our app on the Xcode 16 beta we saw a compiler error saying Getter for 'subscript(dynamicMember:)' is unavailable . But the same code works on Xcode 15. We still have swift version as 5 so just wondering if this is something we did that's not supported anymore or a Xcode issue.

We've been using a struct to represent our State, the state contains an enum property which we've been marking as @CasePathable and @dynamicMemberLookup so we can use scope based on cases. An example of our reducer is shown in below

public struct App: Reducer {
    @ObservableState
    public struct State: Equatable {
        var contentState: ContentState
        @Presents var alert: AlertState<Action.Alert>?
        public init() {
            contentState = .login(.init(name: ""))
        }
    }

    @CasePathable
    @dynamicMemberLookup
    public enum ContentState: Equatable {
        case login(Login.State)
        case main(Tabs.State)
    }

    public enum Action {
        case didFinishLaunching
        case main(Tabs.Action)
        case login(Login.Action)
        case alert(PresentationAction<Alert>)

        @CasePathable
        public enum Alert {
            case dismiss
        }
    }

    public init() {}


    public var body: some Reducer<State, Action> {
        Scope(state: \.contentState.login, action: \.login) {
            Login()
        }

        Scope(state: \.contentState.main, action: \.main) {
            Tabs()
        }

        Reduce { state, action in
            switch action {
            case .didFinishLaunching:
                print("didFinishLaunching")

                return .none
            case .login(.view(.done)):
                state.contentState = .main(.init(name: ""))
                return .none
            case .main(.view(.logout)):
                state.contentState = .login(.init(name: ""))
                return .none
            case .alert:
                return .none
            case .main, .login:
                return .none
            }
        }
        .ifLet(\.$alert, action: \.alert)
    }
}

This all works well in Xcode 15, but once we start using Xcode 16 we get a compiler warning saying

It seems the error is coming from @available(*, unavailable). So I'm just wondering if it was never suppose to be working or some issue with Xcode 16 beta.

  /// Embeds the associated value of a case via dynamic member lookup.
  @_disfavoredOverload
  public subscript<Value>(
    dynamicMember keyPath: KeyPath<Self.AllCasePaths, AnyCasePath<Self, Value>>
  ) -> Value {
    @available(*, unavailable)
    get { Self.allCasePaths[keyPath: keyPath].extract(from: self)! }
    set {
      let casePath = Self.allCasePaths[keyPath: keyPath]
      guard casePath.extract(from: self) != nil else {
        return
      }
      self = casePath.embed(newValue)
    }
  }

FYI, I've got a sample code that I can share as well, let me know if that will be helpful.

Thank you in advance

[mbrandonw]

FYI, I've got a sample code that I can share as well, let me know if that will be helpful.

Hi @yliu342, yes that would be very helpful. I'm having a hard time reproducing this myself.

[yliu342]

CasePath.zip

Here you go. Let me know if there is anything else you need

[Narsail]

I'm seeing the same issue in my tests where I use case paths to test structs of destinations of my reducer state.

[stephencelis]

@yliu342 Swift 6 has gotten a bit more strict with availability checks, which is a good thing. In your code sample Swift 5 was actually compiling some invalid code that may have only incidentally functioned. You can update your reducer with nested scoping to fix:

Scope(state: \.contentState, action: \.self) {
  Scope(state: \.login, action: \.login) {
    Login()
  }
  
  Scope(state: \.main, action: \.main) {
    Tabs()
  }
}

You may want to choose to refactor the contentState enum to its own reducer, though.

[yliu342]

All good, when I saw the error I was wondering how it was working on Swift 5. We'll try update it to make it a seperate reducer. Thank you.

[jaganrajj19]

I'm not sure what I'm missing here but I'm getting the same error even though I don't have any nested state.

Posting my Path reducer and the view code here for reference. Any help would be appreciated!

The same code working in Xcode 15.* and I'm using Swift Composable Architecture 1.17.0

extension AppReducer {
    @Reducer
    struct Path: Reducer {
        @ObservableState
        enum State: Equatable {
            case eventDetail(EventDetailReducer.State)
            case participants(AllParticipantsReducer.State)
            case participant(ParticipantReducer.State)
            case signInView(SignInReducer.State)
            case signUpView(SignUpReducer.State)
        }
        
        enum Action {
            case eventDetail(EventDetailReducer.Action)
            case participants(AllParticipantsReducer.Action)
            case participant(ParticipantReducer.Action)
            case signInView(SignInReducer.Action)
            case signUpView(SignUpReducer.Action)
        }
        
        var body: some ReducerOf<Self> {
            Scope(state: \.eventDetail, action: \.eventDetail, child: EventDetailReducer.init)
            Scope(state: \.participants, action: \.participants, child: AllParticipantsReducer.init)
            Scope(state: \.participant, action: \.participant, child: ParticipantReducer.init)
            Scope(state: \.signInView, action: \.signInView, child: SignInReducer.init)
            Scope(state: \.signUpView, action: \.signUpView, child: SignUpReducer.init)
        }
    }
}

[mbrandonw]

Hi @jaganrajj19, while you do not have nested state you are still running into the same underlying problem. You are using \.eventDetail as if it were a KeyPath<State, EventDetailReducer.State>, but that is specifically forbidden. It is technically safe in your use case, but generally it is not safe and newer versions of Swift have become more strict.

You technically need to first if let unwrap the store:

if let store = store.scope(state: \.eventDeteail, …) {
  EventDetailView(store: store)
}

But also there is a better way to do this. If you refactor your Path reducer to be an enum (see these docs), then you can write the destination closure simply as:

} destination: { store in 
  switch store.case {
  case let .eventDetail(store):
    EventDetailView(store: store)
  …
}

The derivation of the store for each case of the enum is handled for you automatically.

[mbrandonw]

@yliu342 Thanks for that! We will look into it soon.

@Narsail Can you provide a small repro too for us to look at?

[Alex293]

Is there a reason to make it unavailable other than avoiding the situation in the availability message ?

[stephencelis]

The setter is unavailable because it's nonsensical to set nil. Our use of availability was intended to work around the fact that Swift doesn't let you create your own custom properties that behave like optional chaining (optional get with non-optional set).

It appears that this isn't really allowed, though, and so we'll sadly have to remove the functionality in Swift 6. We'll try to cut a Swift 5 release with a hard deprecation if the language allows. In the meantime, the manual fix is:

-destination?.add?.syncUp.title = "Morning sync"
+destination?.modify(\.add) { $0.syncUp.title = "Morning sync" }

[Alex293]

Makes sense thanks. I’ll try the approach you provided

[Narsail]

Argh, that means cleanup time of my tests. Thanks @stephencelis for the correct syntax.

[Alex293]

This is painful when you have multiples levels of optionality though. I’m looking into adding subscript with force unwrap to keep a short syntax

[chwo]

I am getting the same error when scoping an enum-based Feature inside a ForEach store scoping in the view body. The error is at the key path for specifying the state and is happening because the subscript overload is marked @available(*, unavailable) in https://github.com/pointfreeco/swift-case-paths/blob/642e6aab8e03e5f992d9c83e38c5be98cfad5078/Sources/CasePaths/CasePathable.swift#L425

Getter for 'subscript(dynamicMember:)' has been explicitly marked unavailable here

This is working in Xcode 15.4.0 but results in an error in Xcode 16.0 Release Candidate (TCA version 1.15.0).

public struct StreamView: View {
    let store: StoreOf<StreamFeature>

    public init(store: StoreOf<StreamFeature>) {
        self.store = store
    }

    public var body: some View {
        ForEach(store.scope(state: \.cardStates, action: \.card), id: \.state.id) { cardStore in
            switch cardStore.state {
            case .card1:
                Card1FeatureView(
                    store: cardStore.scope(
                        state: \.card1, // <- Error: Getter for 'subscript(dynamicMember:)' is unavailable
                        action: \.card1
                    )
                )
            case .card2:
                Card2FeatureView(
                    store: cardStore.scope(
                        state: \.card2, // <- Error: Getter for 'subscript(dynamicMember:)' is unavailable
                        action: \.card2
                    )
                )
            }
        }
    }
}

Here is the full sample project: SubscriptXcode16Sample.zip

@stephencelis Is there another way to specify the key path or to add additional information, so that the compiler can pick the right subscript overload?

[stephencelis]

@chwo The error message is admittedly not great, but the crux of the issue you're encountering is you're dealing with enum state, and so each case is only optionally accessible. The fix is to either use the if let version of store.scope to first unwrap the store for each case:

 switch cardStore.state {
 case .card1:
+  if let card1Store = cardStore.scope(state: \.card1, action: \.card1) {
     Card1FeatureView(
-      store: cardStore.scope(
-        state: \.card1,
-        action: \.card1
-      )
+      store: card1Store
     )
+  }
 case .card2:
+  if let card2Store = cardStore.scope(state: \.card2, action: \.card2) {
     Card2FeatureView(
-      store: cardStore.scope(
-        state: \.card2,
-        action: \.card2
-      )
+      store: card2Store
     )
+  }
 }

Or you could use the enum style of @Reducer described here, which unlocks store.case for scoping to child stores:

switch cardStore.case {
case let .card1(card1Store):
  Card1FeatureView(store: card1Store)
case let .card2(card2Store):
  Card2FeatureView(store: card2Store)
}

[chwo]

@stephencelis Thank you for the explanation! The error message is indeed not very helpful but I could fix it by using the if let for unwrapping the store.scope.

I also tried using the enum style @Reducer macro which generates its parts, but I ran into runtime memory issues by doing that (the enum has around 20 cases). So I am wondering if there is a functional difference between the macro generated enum Reducer code vs. manually implementing it as a struct Reducer.