IssueTracker

SavedStateHandle.saveable requires passing a key.

In the case where the value returned by Saveable is the only place where this value is written to and read, the exact value of key doesn't really matter, so long as it is unique.

Therefore, there's the possibility of using property delegates to automatically pull the name of the property to use as a key. An implementation would look something like the following:

fun <T : Any> SavedStateHandle.saveable(
    saver: Saver<T, out Any> = autoSaver(),
    init: () -> T,
): PropertyDelegateProvider<Any, ReadOnlyProperty<Any, T>> =
    PropertyDelegateProvider { _, property ->
        val value = saveable(
            key = property.name,
            saver = saver,
            init = init
        )

        ReadOnlyProperty { _, _ -> value }
    }

And then usage would look like:

val customState by savedStateHandle.saveable(CustomStateSaver) {
    CustomState()
}

If b/224565154 is created, then an additional property delegate for MutableState could also be created, using something like the following:

@JvmName("saveableMutableState")
fun <T : Any> SavedStateHandle.saveable(
    stateSaver: Saver<T, out Any> = autoSaver(),
    init: () -> MutableState<T>,
): PropertyDelegateProvider<Any, ReadWriteProperty<Any, T>> =
    PropertyDelegateProvider<Any, ReadWriteProperty<Any, T>> { _, property ->
        val mutableState = saveable(
            key = property.name,
            stateSaver = stateSaver,
            init = init
        )

        object : ReadWriteProperty<Any, T> {
            override fun getValue(thisRef: Any, property: KProperty<*>): T =
                mutableState.getValue(thisRef, property)

            override fun setValue(thisRef: Any, property: KProperty<*>, value: T) =
                mutableState.setValue(thisRef, property, value)
        }
    }

Usage here would then match rememberSaveable almost identically for simple mutableStateOf usages:

var count by savedStateHandle.saveable { mutableStateOf(0) }