Unable to cast Decompose Child to subclass in Swift (sealed interface interop issue)

[okmand]

I'm using Decompose for navigation in a Kotlin Multiplatform project.
On Android everything works as expected.
However, in iOS (SwiftUI), I'm unable to cast a Child instance from the navigation ChildStack to its expected subclass.

Swift silently fails to match the correct subclass and falls into the default case — even though the runtime type is valid and visible in Swift.

Architecture Overview:

Navigation is defined in a :core:navigation module:

interface Root {
    val childStack: Value<ChildStack<*, Child>>

    sealed interface Child {
        class ScreenAChild(val component: AComponent) : Child
        class ScreenBChild(val component: BComponent) : Child
    }
}

class RootComponent(...) : Root, ComponentContext by componentContext {

    private val navigation = StackNavigation<ScreenConfig>()

    override val childStack: Value<ChildStack<*, Child>> = childStack(
        source = navigation,
        serializer = ScreenConfig.serializer(),
        initialConfiguration = ScreenConfig.ScreenA,
        handleBackButton = true,
        childFactory = ::createChild
    )

    private fun createChild(config: ScreenConfig, context: ComponentContext): Child {
        return when (config) {
            is ScreenConfig.ScreenA -> Child.ScreenAChild(aComponentFactory(componentContext = context))
            is ScreenConfig.ScreenB -> Child.ScreenBChild(BComponent(componentContext = context, text = config.text))
        }
    }

    @Serializable
    private sealed interface ScreenConfig {
        @Serializable data object ScreenA : ScreenConfig
        @Serializable data class ScreenB(val text: String) : ScreenConfig
    }
}

build.gradle.kts related to :core:navigation module:

import org.jetbrains.kotlin.gradle.dsl.JvmTarget

plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.kotlinCocoapods)
    alias(libs.plugins.androidLibrary)
    alias(libs.plugins.kotlinSerialization)
}

kotlin {
    androidTarget {
        compilerOptions {
            jvmTarget.set(JvmTarget.JVM_1_8)
        }
    }
    iosX64()
    iosArm64()
    iosSimulatorArm64()

    cocoapods {
        summary = "Navigation Module"
        homepage = "https://github.com/JetBrains/kotlin"
        version = "1.0"
        ios.deploymentTarget = "16.0"
        framework {
            baseName = "navigation"
            isStatic = true
        }
    }

    sourceSets {
        commonMain.dependencies {
            implementation(libs.koin.core)
            implementation(libs.kotlinx.coroutines.core)

            implementation(libs.decompose)
        }
    }
}

android {
    namespace = "com.example.myproject.core.navigation"
    compileSdk = libs.versions.android.compileSdk.get().toInt()

    defaultConfig {
        minSdk = libs.versions.android.minSdk.get().toInt()
    }

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
}

In Android I use it this way and everything works as expected:

@Composable
fun RootScreen(root: Root) {
    val childStack by root.childStack.subscribeAsState()

    Children(stack = childStack, animation = stackAnimation(slide())) {
        when (val child = it.instance) {
            is Root.Child.ScreenAChild -> ScreenA(child.component)
            is Root.Child.ScreenBChild -> ScreenB(child.component)
        }
    }
}

In Swift, I observe the current child using ObservableValue and attempt to render the correct view via casting:

@main
struct iOSApp: App {

    let navigationRootComponent: NavigationRootComponent

    init() {
        KoinModules_nativeKt.doInitKoin()

        let rootComponentHelper = RootComponentHelper()
        let rootComponentFactory = rootComponentHelper.rootComponentFactory

        let componentContext = DefaultComponentContext(lifecycle: ApplicationLifecycle())

        navigationRootComponent = rootComponentFactory.invoke(componentContext: componentContext)
    }

    var body: some Scene {
        WindowGroup {
            RootView(root: navigationRootComponent)
        }
    }
}

struct RootView: View {

    @ObservedObject
    private var routerStates: ObservableValue<ChildStack<AnyObject, NavigationRootChild>>

    var body: some View {
        var child: NavigationRootChild = self.routerStates.value.active.instance
        switch child {
        case let screenA as RootChildScreenAChild:
            ScreenAView(component: screenA.component)
        case let screenB as RootChildScreenBChild:
            ScreenBView(component: screenB.component)
        default:
            Text("empty")
        }
    }

    init(root: NavigationRootComponent) {
        self.routerStates = ObservableValue(root.childStack)
    }
}

The problem

Even though:

• The Child subclass is instantiated correctly in Kotlin (verified via debugger),
• The corresponding Swift type (RootChildScreenAChild) is generated and visible,
• The project builds and runs successfully,

Swift fails to recognize the correct type and falls into the default case.

This seems to be caused by Swift's inability to cast sealed subclasses generated by Kotlin/Native interop (Objective-C) — even though the class hierarchy is intact and visible.

Is there a recommended way to expose Child subclasses from Decompose so that they can be safely distinguished and cast in Swift?

Thank you in advance!

Environment

kotlin: 2.1.10
decompose: 3.3.0
essenty-lifecycle: 2.5.0
Koin used for DI
iOS target: 16+

[arkivanov]

Could you please try using sealed class instead of sealed interface? See the example:

Decompose/sample/shared/shared/src/commonMain/kotlin/com/arkivanov/sample/shared/root/RootComponent.kt

Line 20 in a53e5ef

sealed class Child {

[okmand]

Hi, thank you for the suggestion. I've just tried to use sealed class instead, but it's the same result

[arkivanov]

Can you try printing the actual type of the var child: NavigationRootChild variable? Also worth trying the approach from the sample app here.

[arkivanov]

Without the debugger it hard to determine the issue, might be something wrong with types. Try using the @StateValue property wrapper, can be found here. Also worth trying to extract a separate property for the active child, as it done here.

[okmand]

Thanks for the suggestions - I tried them, but unfortunately the issue remains. The switch block still falls into the default case.

Here’s what I observed when experimenting with @StateValue and extracting the active child from ChildStack:

• When I print type(of: activeChild), the output is:
  App_kobjcc2

• However, when I print stack.active, I get:
  Created(configuration=ScreenA, instance=com.example.myproject.core.navigation.Root.Child.ScreenAChild@52670b8, key=ScreenA)

This confirms that the correct ScreenAChild instance is being used internally - but for some reason, Swift still can’t recognize the actual type

[arkivanov]

Sorry to hear that! I think I'd need a reproducer project in order to help. Or you can check the sample project linked above and try find the difference. Let me know!

[okmand]

Thank you for the offer! Would it be possible to share the project with you privately? If so, could you please provide an email address where I can send a zipped archive safely? I'd be happy to share everything needed to reproduce the issue.

[arkivanov]

Feel free to email you project to [email protected]. Alternatively, you can try creating a separate minimal reproducer.