IssueTracker

Filed as a separate issue from b/396584142#comment5

an issue with kotlin 2.1.20 and AGP 8.11.0-alpha02

a.kt:109: Error: Access to private constructor of class SliderBrushColor2 requires synthetic accessor [SyntheticAccessor]
          var result = thumbColor.hashCode()
                       ~~~~~~~~~~~~~~~~~~~

Small repro:

import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.SolidColor

data class SliderBrushColor2(
    val color: Color = Color.Unspecified,
    val brush: Brush? = null,
) {
    val activeBrush: Brush
        get() = brush ?: solidColor
    val solidColor = SolidColor(color)
}

interface MaterialSliderColors2 {
    @Composable
    fun thumbColor(enabled: Boolean): State<Brush>

    @Composable
    fun trackColor(enabled: Boolean, active: Boolean): State<Brush>

    @Composable
    fun tickColor(enabled: Boolean, active: Boolean): State<Brush>
}

class DefaultMaterialSliderColors(
    private val thumbColor: SliderBrushColor2,
    private val disabledThumbColor: SliderBrushColor2,
    private val activeTrackColor: SliderBrushColor2,
    private val disabledActiveTrackColor: SliderBrushColor2,
    private val inactiveTrackColor: SliderBrushColor2,
    private val disabledInactiveTrackColor: SliderBrushColor2,
    private val activeTickColor: SliderBrushColor2 = SliderBrushColor2(),
    private val inactiveTickColor: SliderBrushColor2 = SliderBrushColor2(),
    private val disabledActiveTickColor: SliderBrushColor2 = SliderBrushColor2(),
    private val disabledInactiveTickColor: SliderBrushColor2 = SliderBrushColor2(),
) : MaterialSliderColors2 {

    @Composable
    override fun thumbColor(enabled: Boolean): State<Brush> {
        return rememberUpdatedState(
            if (enabled) {
                thumbColor.activeBrush
            } else {
                disabledThumbColor.activeBrush
            },
        )
    }

    @Composable
    override fun trackColor(enabled: Boolean, active: Boolean): State<Brush> {
        return rememberUpdatedState(
            if (enabled) {
                if (active) {
                    activeTrackColor.activeBrush
                } else {
                    inactiveTrackColor.activeBrush
                }
            } else {
                if (active) {
                    disabledActiveTrackColor.activeBrush
                } else {
                    disabledInactiveTrackColor.activeBrush
                }
            },
        )
    }

    @Composable
    override fun tickColor(enabled: Boolean, active: Boolean): State<Brush> {
        return rememberUpdatedState(
            if (enabled) {
                if (active) {
                    activeTickColor.activeBrush
                } else {
                    inactiveTickColor.activeBrush
                }
            } else {
                if (active) {
                    disabledActiveTickColor.activeBrush
                } else {
                    disabledInactiveTickColor.activeBrush
                }
            },
        )
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other == null || this::class != other::class) return false

        other as DefaultMaterialSliderColors

        if (thumbColor != other.thumbColor) return false
        if (disabledThumbColor != other.disabledThumbColor) return false
        if (activeTrackColor != other.activeTrackColor) return false
        if (inactiveTrackColor != other.inactiveTrackColor) return false
        if (disabledActiveTrackColor != other.disabledActiveTrackColor) return false
        if (disabledInactiveTrackColor != other.disabledInactiveTrackColor) return false

        return true
    }

    override fun hashCode(): Int {
        var result = thumbColor.hashCode()
        result = 31 * result + disabledThumbColor.hashCode()
        result = 31 * result + activeTrackColor.hashCode()
        result = 31 * result + inactiveTrackColor.hashCode()
        result = 31 * result + disabledActiveTrackColor.hashCode()
        result = 31 * result + disabledInactiveTrackColor.hashCode()
        return result
    }
}