diff --git a/compose/material/material/samples/src/main/java/androidx/compose/material/samples/SwipeToDismissSamples.kt b/compose/material/material/samples/src/main/java/androidx/compose/material/samples/SwipeToDismissSamples.kt
index a10706d..03d234b 100644
--- a/compose/material/material/samples/src/main/java/androidx/compose/material/samples/SwipeToDismissSamples.kt
+++ b/compose/material/material/samples/src/main/java/androidx/compose/material/samples/SwipeToDismissSamples.kt
@@ -33,7 +33,6 @@
 import androidx.compose.material.DismissValue.DismissedToEnd
 import androidx.compose.material.DismissValue.DismissedToStart
 import androidx.compose.material.ExperimentalMaterialApi
-import androidx.compose.material.FractionalThreshold
 import androidx.compose.material.Icon
 import androidx.compose.material.ListItem
 import androidx.compose.material.SwipeToDismiss
@@ -94,9 +93,6 @@
                 state = dismissState,
                 modifier = Modifier.padding(vertical = 4.dp),
                 directions = setOf(StartToEnd, EndToStart),
-                dismissThresholds = { direction ->
-                    FractionalThreshold(if (direction == StartToEnd) 0.25f else 0.5f)
-                },
                 background = {
                     val direction = dismissState.dismissDirection ?: return@SwipeToDismiss
                     val color by animateColorAsState(
diff --git a/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeToDismiss.kt b/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeToDismiss.kt
index 31c09ad..0aa1377 100644
--- a/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeToDismiss.kt
+++ b/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SwipeToDismiss.kt
@@ -37,6 +37,7 @@
 import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.CancellationException
 import kotlin.math.roundToInt
 
@@ -173,7 +174,9 @@
     state: DismissState,
     modifier: Modifier = Modifier,
     directions: Set<DismissDirection> = setOf(EndToStart, StartToEnd),
-    dismissThresholds: (DismissDirection) -> ThresholdConfig = { FractionalThreshold(0.5f) },
+    dismissThresholds: (DismissDirection) -> ThresholdConfig = {
+        FixedThreshold(DISMISS_THRESHOLD)
+    },
     background: @Composable RowScope.() -> Unit,
     dismissContent: @Composable RowScope.() -> Unit
 ) = BoxWithConstraints(modifier) {
@@ -236,3 +239,5 @@
         else -> null
     }
 }
+
+private val DISMISS_THRESHOLD = 56.dp
\ No newline at end of file
diff --git a/compose/runtime/runtime/api/current.txt b/compose/runtime/runtime/api/current.txt
index b405fc2..5654983 100644
--- a/compose/runtime/runtime/api/current.txt
+++ b/compose/runtime/runtime/api/current.txt
@@ -750,6 +750,18 @@
 
 }
 
+package androidx.compose.runtime.reflect {
+
+  public final class ComposableMethodInvokerKt {
+    method @kotlin.jvm.Throws(exceptionClasses=NoSuchMethodException::class) public static java.lang.reflect.Method getDeclaredComposableMethod(Class<?>, String methodName, Class<?>... args) throws java.lang.NoSuchMethodException;
+    method public static java.lang.reflect.Parameter![] getRealParameters(java.lang.reflect.Method);
+    method public static int getRealParametersCount(java.lang.reflect.Method);
+    method public static Object? invokeComposable(java.lang.reflect.Method, androidx.compose.runtime.Composer composer, Object? instance, java.lang.Object?... args);
+    method public static boolean isComposable(java.lang.reflect.Method);
+  }
+
+}
+
 package androidx.compose.runtime.snapshots {
 
   public final class ListUtilsKt {
diff --git a/compose/runtime/runtime/api/public_plus_experimental_current.txt b/compose/runtime/runtime/api/public_plus_experimental_current.txt
index e121f57..75793d0 100644
--- a/compose/runtime/runtime/api/public_plus_experimental_current.txt
+++ b/compose/runtime/runtime/api/public_plus_experimental_current.txt
@@ -815,6 +815,18 @@
 
 }
 
+package androidx.compose.runtime.reflect {
+
+  public final class ComposableMethodInvokerKt {
+    method @kotlin.jvm.Throws(exceptionClasses=NoSuchMethodException::class) public static java.lang.reflect.Method getDeclaredComposableMethod(Class<?>, String methodName, Class<?>... args) throws java.lang.NoSuchMethodException;
+    method public static java.lang.reflect.Parameter![] getRealParameters(java.lang.reflect.Method);
+    method public static int getRealParametersCount(java.lang.reflect.Method);
+    method public static Object? invokeComposable(java.lang.reflect.Method, androidx.compose.runtime.Composer composer, Object? instance, java.lang.Object?... args);
+    method public static boolean isComposable(java.lang.reflect.Method);
+  }
+
+}
+
 package androidx.compose.runtime.snapshots {
 
   public final class ListUtilsKt {
diff --git a/compose/runtime/runtime/api/restricted_current.txt b/compose/runtime/runtime/api/restricted_current.txt
index 786f2b7..2643f45 100644
--- a/compose/runtime/runtime/api/restricted_current.txt
+++ b/compose/runtime/runtime/api/restricted_current.txt
@@ -778,6 +778,18 @@
 
 }
 
+package androidx.compose.runtime.reflect {
+
+  public final class ComposableMethodInvokerKt {
+    method @kotlin.jvm.Throws(exceptionClasses=NoSuchMethodException::class) public static java.lang.reflect.Method getDeclaredComposableMethod(Class<?>, String methodName, Class<?>... args) throws java.lang.NoSuchMethodException;
+    method public static java.lang.reflect.Parameter![] getRealParameters(java.lang.reflect.Method);
+    method public static int getRealParametersCount(java.lang.reflect.Method);
+    method public static Object? invokeComposable(java.lang.reflect.Method, androidx.compose.runtime.Composer composer, Object? instance, java.lang.Object?... args);
+    method public static boolean isComposable(java.lang.reflect.Method);
+  }
+
+}
+
 package androidx.compose.runtime.snapshots {
 
   public final class ListUtilsKt {
diff --git a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Composition.kt b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Composition.kt
index e318d61b..1dc664c 100644
--- a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Composition.kt
+++ b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Composition.kt
@@ -919,7 +919,10 @@
     }
 
     internal fun removeDerivedStateObservation(state: DerivedState<*>) {
-        derivedStates.removeScope(state)
+        // remove derived state if it is not observed in other scopes
+        if (state !in observations) {
+            derivedStates.removeScope(state)
+        }
     }
 
     /**
diff --git a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/internal/ComposableLambda.kt b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/internal/ComposableLambda.kt
index 368da08..3accee3 100644
--- a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/internal/ComposableLambda.kt
+++ b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/internal/ComposableLambda.kt
@@ -24,7 +24,7 @@
 import androidx.compose.runtime.RecomposeScopeImpl
 import androidx.compose.runtime.Stable
 
-private const val SLOTS_PER_INT = 10
+internal const val SLOTS_PER_INT = 10
 private const val BITS_PER_SLOT = 3
 
 internal fun bitsForSlot(bits: Int, slot: Int): Int {
diff --git a/compose/runtime/runtime/src/commonTest/kotlin/androidx/compose/runtime/CompositionAndDerivedStateTests.kt b/compose/runtime/runtime/src/commonTest/kotlin/androidx/compose/runtime/CompositionAndDerivedStateTests.kt
index c73242e..125ac7d 100644
--- a/compose/runtime/runtime/src/commonTest/kotlin/androidx/compose/runtime/CompositionAndDerivedStateTests.kt
+++ b/compose/runtime/runtime/src/commonTest/kotlin/androidx/compose/runtime/CompositionAndDerivedStateTests.kt
@@ -387,6 +387,54 @@
     }
 
     @Test
+    fun observingDerivedStateInMultipleScopes() = compositionTest {
+        var observeInFirstScope by mutableStateOf(true)
+        var count by mutableStateOf(0)
+
+        compose {
+            val items by remember {
+                derivedStateOf {
+                    List(count) { it }
+                }
+            }
+
+            Linear {
+                if (observeInFirstScope) {
+                    Text("List of size ${items.size}")
+                }
+            }
+
+            Linear {
+                Text("List of size ${items.size}")
+            }
+        }
+
+        validate {
+            Linear {
+                Text("List of size 0")
+            }
+
+            Linear {
+                Text("List of size 0")
+            }
+        }
+
+        observeInFirstScope = false
+        advance()
+        count++
+        advance()
+
+        validate {
+            Linear {
+            }
+
+            Linear {
+                Text("List of size 1")
+            }
+        }
+    }
+
+    @Test
     fun changingTheDerivedStateInstanceShouldClearDependencies() = compositionTest {
         var reload by mutableStateOf(0)
 
diff --git a/compose/runtime/runtime/src/jvmMain/kotlin/androidx/compose/runtime/internal/ComposableLambdaN.jvm.kt b/compose/runtime/runtime/src/jvmMain/kotlin/androidx/compose/runtime/internal/ComposableLambdaN.jvm.kt
index 3193f395..121e1e1 100644
--- a/compose/runtime/runtime/src/jvmMain/kotlin/androidx/compose/runtime/internal/ComposableLambdaN.jvm.kt
+++ b/compose/runtime/runtime/src/jvmMain/kotlin/androidx/compose/runtime/internal/ComposableLambdaN.jvm.kt
@@ -24,8 +24,6 @@
 import androidx.compose.runtime.Stable
 import kotlin.jvm.functions.FunctionN
 
-private const val SLOTS_PER_INT = 10
-
 @Stable
 internal class ComposableLambdaNImpl(
     val key: Int,
diff --git a/compose/runtime/runtime/src/jvmMain/kotlin/androidx/compose/runtime/reflect/ComposableMethodInvoker.kt b/compose/runtime/runtime/src/jvmMain/kotlin/androidx/compose/runtime/reflect/ComposableMethodInvoker.kt
new file mode 100644
index 0000000..3b7777a
--- /dev/null
+++ b/compose/runtime/runtime/src/jvmMain/kotlin/androidx/compose/runtime/reflect/ComposableMethodInvoker.kt
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime.reflect
+
+import androidx.compose.runtime.Composer
+import androidx.compose.runtime.internal.SLOTS_PER_INT
+import java.lang.reflect.Method
+import java.lang.reflect.Modifier
+import java.lang.reflect.Parameter
+import kotlin.math.ceil
+
+private inline fun <reified T> T.dup(count: Int): Array<T> {
+    return (0 until count).map { this }.toTypedArray()
+}
+
+/**
+ * Find the given @Composable method by name.
+ */
+@Throws(NoSuchMethodException::class)
+fun Class<*>.getDeclaredComposableMethod(methodName: String, vararg args: Class<*>): Method {
+    val changedParams = changedParamCount(args.size, 0)
+    val method = try {
+        // without defaults
+        getDeclaredMethod(
+            methodName,
+            *args,
+            Composer::class.java, // composer param
+            *Int::class.java.dup(changedParams) // changed params
+        )
+    } catch (e: ReflectiveOperationException) {
+        val defaultParams = defaultParamCount(args.size)
+        try {
+            getDeclaredMethod(
+                methodName,
+                *args,
+                Composer::class.java, // composer param
+                *Int::class.java.dup(changedParams), // changed param
+                *Int::class.java.dup(defaultParams) // default param
+            )
+        } catch (e2: ReflectiveOperationException) {
+            null
+        }
+    } ?: throw NoSuchMethodException("$name.$methodName")
+
+    return method
+}
+
+/**
+ * Returns the default value for the [Class] type. This will be 0 for numeric types, false for
+ * boolean and null for object references.
+ */
+private fun Class<*>.getDefaultValue(): Any? = when (name) {
+    "int" -> 0.toInt()
+    "short" -> 0.toShort()
+    "byte" -> 0.toByte()
+    "long" -> 0.toLong()
+    "double" -> 0.toDouble()
+    "float" -> 0.toFloat()
+    "boolean" -> false
+    "char" -> 0.toChar()
+    else -> null
+}
+
+/**
+ * Structure intended to be used exclusively by [getComposableInfo].
+ */
+private data class ComposableInfo(
+    val isComposable: Boolean,
+    val realParamsCount: Int,
+    val changedParams: Int,
+    val defaultParams: Int
+)
+
+/**
+ * Checks whether the method is Composable function and returns result along with the real
+ * parameters count and changed parameter count (if composable) and packed in a structure.
+ */
+private fun Method.getComposableInfo(): ComposableInfo {
+    val realParamsCount = parameterTypes.indexOfLast { it == Composer::class.java }
+    if (realParamsCount == -1) {
+        return ComposableInfo(false, parameterTypes.size, 0, 0)
+    }
+    val thisParams = if (Modifier.isStatic(this.modifiers)) 0 else 1
+    val changedParams = changedParamCount(realParamsCount, thisParams)
+    val totalParamsWithoutDefaults = realParamsCount +
+        1 + // composer
+        changedParams
+    val totalParams = parameterTypes.size
+    val isDefault = totalParams != totalParamsWithoutDefaults
+    val defaultParams = if (isDefault)
+        defaultParamCount(realParamsCount)
+    else
+        0
+    return ComposableInfo(
+        totalParamsWithoutDefaults + defaultParams == totalParams,
+        realParamsCount,
+        changedParams,
+        defaultParams
+    )
+}
+
+/**
+ * Calls the Composable method on the given [instance]. If the method accepts default values, this
+ * function will call it with the correct options set.
+ */
+@Suppress("BanUncheckedReflection", "ListIterator")
+fun Method.invokeComposable(
+    composer: Composer,
+    instance: Any?,
+    vararg args: Any?
+): Any? {
+    val (isComposable, realParamsCount, changedParams, defaultParams) = getComposableInfo()
+
+    check(isComposable)
+
+    val totalParams = parameterTypes.size
+    val changedStartIndex = realParamsCount + 1
+    val defaultStartIndex = changedStartIndex + changedParams
+
+    val defaultsMasks = Array(defaultParams) { index ->
+        val start = index * BITS_PER_INT
+        val end = minOf(start + BITS_PER_INT, realParamsCount)
+        val useDefault =
+            (start until end).map { if (it >= args.size || args[it] == null) 1 else 0 }
+        val mask = useDefault.foldIndexed(0) { i, mask, default -> mask or (default shl i) }
+        mask
+    }
+
+    val arguments = Array(totalParams) { idx ->
+        when (idx) {
+            // pass in "empty" value for all real parameters since we will be using defaults.
+            in 0 until realParamsCount -> args.getOrElse(idx) {
+                parameterTypes[idx].getDefaultValue()
+            }
+            // the composer is the first synthetic parameter
+            realParamsCount -> composer
+            // since this is the root we don't need to be anything unique. 0 should suffice.
+            // changed parameters should be 0 to indicate "uncertain"
+            changedStartIndex -> 1
+            in changedStartIndex + 1 until defaultStartIndex -> 0
+            // Default values mask, all parameters set to use defaults
+            in defaultStartIndex until totalParams -> defaultsMasks[idx - defaultStartIndex]
+            else -> error("Unexpected index")
+        }
+    }
+    return invoke(instance, *arguments)
+}
+
+private const val BITS_PER_INT = 31
+
+private fun changedParamCount(realValueParams: Int, thisParams: Int): Int {
+    if (realValueParams == 0) return 1
+    val totalParams = realValueParams + thisParams
+    return ceil(
+        totalParams.toDouble() / SLOTS_PER_INT.toDouble()
+    ).toInt()
+}
+
+private fun defaultParamCount(realValueParams: Int): Int {
+    return ceil(
+        realValueParams.toDouble() / BITS_PER_INT.toDouble()
+    ).toInt()
+}
+
+/**
+ * Returns true if the method is a Composable function and false otherwise.
+ */
+val Method.isComposable: Boolean
+    get() = getComposableInfo().isComposable
+
+/**
+ * Returns real parameters count for the method, it returns the actual parameters count for the
+ * usual methods and for Composable functions it excludes the utility Compose-specific parameters
+ * from counting.
+ */
+val Method.realParametersCount: Int
+    get() {
+        val (isComposable, realParametersCount, _, _) = getComposableInfo()
+        if (isComposable) {
+            return realParametersCount
+        }
+        return parameterTypes.size
+    }
+
+/**
+ * Returns real parameters for the method, it returns the actual parameters for the usual methods
+ * and for Composable functions it excludes the utility Compose-specific parameters.
+ */
+val Method.realParameters: Array<out Parameter>
+    @Suppress("ClassVerificationFailure", "NewApi")
+    get() {
+        val (isComposable, realParametersCount, _, _) = getComposableInfo()
+        if (isComposable) {
+            return parameters.copyOfRange(0, realParametersCount)
+        }
+        return parameters
+    }
diff --git a/compose/runtime/runtime/src/jvmTest/kotlin/androidx/compose/runtime/reflect/ComposableMethodInvokerTest.kt b/compose/runtime/runtime/src/jvmTest/kotlin/androidx/compose/runtime/reflect/ComposableMethodInvokerTest.kt
new file mode 100644
index 0000000..a976fad
--- /dev/null
+++ b/compose/runtime/runtime/src/jvmTest/kotlin/androidx/compose/runtime/reflect/ComposableMethodInvokerTest.kt
@@ -0,0 +1,581 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime.reflect
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Composer
+import androidx.compose.runtime.Composition
+import androidx.compose.runtime.MonotonicFrameClock
+import androidx.compose.runtime.Recomposer
+import androidx.compose.runtime.currentComposer
+import androidx.compose.runtime.mock.EmptyApplier
+import androidx.compose.runtime.withRunningRecomposer
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
+import kotlinx.coroutines.runBlocking
+
+@Composable
+private fun composableFunction() {
+}
+
+private fun nonComposableFunction() {
+}
+
+@Suppress("UNUSED_PARAMETER")
+private fun nonComposableFunctionWithComposerParam(unused: Composer) {
+}
+
+@Composable
+private fun composableFunctionWithDefaults(
+    s1: String,
+    s2: String,
+    s3: String = "a",
+    s4: String = "a",
+    s5: String = "a"
+): String { return s1 + s2 + s3 + s4 + s5 }
+
+@Composable
+private fun overloadedComposable() {
+}
+
+@Suppress("UNUSED_PARAMETER")
+@Composable
+private fun overloadedComposable(s: String) {
+}
+
+@Suppress("UNUSED_PARAMETER")
+@Composable
+private fun overloadedComposable(
+    v1: String,
+    v2: String,
+    v3: String,
+    v4: String,
+    v5: String,
+    v6: String,
+    v7: String,
+    v8: String,
+    v9: String,
+    v10: String
+) { }
+
+@Suppress("UNUSED_PARAMETER")
+@Composable
+private fun overloadedComposable(
+    v1: String,
+    v2: String,
+    v3: String,
+    v4: String,
+    v5: String,
+    v6: String,
+    v7: String,
+    v8: String,
+    v9: String,
+    v10: String,
+    v11: String
+) { }
+
+@Suppress("UNUSED_PARAMETER")
+@Composable
+private fun overloadedComposable(
+    v1: String,
+    v2: String,
+    v3: String,
+    v4: String,
+    v5: String,
+    v6: String,
+    v7: String,
+    v8: String,
+    v9: String,
+    v10: String,
+    v11: String,
+    v12: String
+) { }
+
+@Suppress("UNUSED_PARAMETER")
+@Composable
+private fun differentParametersTypes(
+    v1: String,
+    v2: Any,
+    v3: Int,
+    v4: Float,
+    v5: Double,
+    v6: Long
+) { }
+
+private class ComposablesWrapper {
+    @Composable
+    fun composableMethod() {
+    }
+
+    fun nonComposableMethod() {
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    fun nonComposableMethodWithComposerParam(unused: Composer) {
+    }
+
+    @Composable
+    fun composableMethodWithDefaults(
+        s1: String,
+        s2: String,
+        s3: String = "a",
+        s4: String = "a",
+        s5: String = "a"
+    ): String { return s1 + s2 + s3 + s4 + s5 }
+
+    @Composable
+    fun overloadedComposableMethod() {
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    @Composable
+    fun overloadedComposableMethod(s: String) {
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    @Composable
+    fun overloadedComposableMethod(
+        v1: String,
+        v2: String,
+        v3: String,
+        v4: String,
+        v5: String,
+        v6: String,
+        v7: String,
+        v8: String,
+        v9: String,
+        v10: String
+    ) { }
+
+    @Suppress("UNUSED_PARAMETER")
+    @Composable
+    fun overloadedComposableMethod(
+        v1: String,
+        v2: String,
+        v3: String,
+        v4: String,
+        v5: String,
+        v6: String,
+        v7: String,
+        v8: String,
+        v9: String,
+        v10: String,
+        v11: String
+    ) { }
+
+    @Suppress("UNUSED_PARAMETER")
+    @Composable
+    fun overloadedComposableMethod(
+        v1: String,
+        v2: String,
+        v3: String,
+        v4: String,
+        v5: String,
+        v6: String,
+        v7: String,
+        v8: String,
+        v9: String,
+        v10: String,
+        v11: String,
+        v12: String
+    ) { }
+
+    @Suppress("UNUSED_PARAMETER")
+    @Composable
+    fun differentParametersTypesMethod(
+        v1: String,
+        v2: Any,
+        v3: Int,
+        v4: Float,
+        v5: Double,
+        v6: Long
+    ) { }
+}
+
+class ComposableMethodInvokerTest {
+    private val clazz =
+        Class.forName("androidx.compose.runtime.reflect.ComposableMethodInvokerTestKt")
+    private val wrapperClazz =
+        Class.forName("androidx.compose.runtime.reflect.ComposablesWrapper")
+
+    private val composable = clazz.declaredMethods.find { it.name == "composableFunction" }!!
+    private val nonComposable = clazz.declaredMethods.find { it.name == "nonComposableFunction" }!!
+    private val nonComposableWithComposer =
+        clazz.declaredMethods.find { it.name == "nonComposableFunctionWithComposerParam" }!!
+    private val composableMethod =
+        wrapperClazz.declaredMethods.find { it.name == "composableMethod" }!!
+    private val nonComposableMethod =
+        wrapperClazz.declaredMethods.find { it.name == "nonComposableMethod" }!!
+    private val nonComposableMethodWithComposer =
+        wrapperClazz.declaredMethods.find { it.name == "nonComposableMethodWithComposerParam" }!!
+
+    @Test
+    fun test_isComposable_correctly_checks_functions() {
+        assertTrue(composable.isComposable)
+        assertFalse(nonComposable.isComposable)
+        assertFalse(nonComposableWithComposer.isComposable)
+        assertTrue(composableMethod.isComposable)
+        assertFalse(nonComposableMethod.isComposable)
+        assertFalse(nonComposableMethodWithComposer.isComposable)
+    }
+
+    @Throws(NoSuchMethodException::class)
+    @Test
+    fun test_getDeclaredComposableMethod_differentiates_overloaded_functions() {
+        val method0 = clazz.getDeclaredComposableMethod("overloadedComposable")
+        val method1 = clazz.getDeclaredComposableMethod("overloadedComposable", String::class.java)
+        val method10 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(10) { String::class.java }
+            )
+        val method11 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(11) { String::class.java }
+            )
+        val method12 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(12) { String::class.java }
+            )
+
+        assertNotEquals(method0, method1)
+        assertNotEquals(method0, method10)
+        assertNotEquals(method0, method11)
+        assertNotEquals(method0, method12)
+        assertNotEquals(method1, method10)
+        assertNotEquals(method1, method11)
+        assertNotEquals(method1, method12)
+        assertNotEquals(method10, method11)
+        assertNotEquals(method10, method12)
+        assertNotEquals(method11, method12)
+    }
+
+    @Throws(NoSuchMethodException::class)
+    @Test
+    fun test_getDeclaredComposableMethod_differentiates_overloaded_methods() {
+        val method0 = wrapperClazz.getDeclaredComposableMethod("overloadedComposableMethod")
+        val method1 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                String::class.java
+            )
+        val method10 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(10) { String::class.java }
+            )
+        val method11 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(11) { String::class.java }
+            )
+        val method12 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(12) { String::class.java }
+            )
+
+        assertNotEquals(method0, method1)
+        assertNotEquals(method0, method10)
+        assertNotEquals(method0, method11)
+        assertNotEquals(method0, method12)
+        assertNotEquals(method1, method10)
+        assertNotEquals(method1, method11)
+        assertNotEquals(method1, method12)
+        assertNotEquals(method10, method11)
+        assertNotEquals(method10, method12)
+        assertNotEquals(method11, method12)
+    }
+
+    @Throws(NoSuchMethodException::class)
+    @Test
+    fun test_getDeclaredComposableMethod_works_with_default_params() {
+        clazz.getDeclaredComposableMethod(
+            "composableFunctionWithDefaults",
+            *Array(5) { String::class.java }
+        )
+
+        wrapperClazz.getDeclaredComposableMethod(
+            "composableMethodWithDefaults",
+            *Array(5) { String::class.java }
+        )
+    }
+
+    @Throws(NoSuchMethodException::class)
+    @Test
+    fun test_realParametersCount_returns_correct_number_of_parameters() {
+        val function0 = clazz.getDeclaredComposableMethod("overloadedComposable")
+        val function1 =
+            clazz.getDeclaredComposableMethod("overloadedComposable", String::class.java)
+        val function10 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(10) { String::class.java }
+            )
+        val function11 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(11) { String::class.java }
+            )
+        val function12 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(12) { String::class.java }
+            )
+
+        val method0 = wrapperClazz.getDeclaredComposableMethod("overloadedComposableMethod")
+        val method1 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod", String::class.java
+            )
+        val method10 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(10) { String::class.java }
+            )
+        val method11 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(11) { String::class.java }
+            )
+        val method12 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(12) { String::class.java }
+            )
+
+        assertEquals(0, function0.realParametersCount)
+        assertEquals(1, function1.realParametersCount)
+        assertEquals(10, function10.realParametersCount)
+        assertEquals(11, function11.realParametersCount)
+        assertEquals(12, function12.realParametersCount)
+
+        assertEquals(0, method0.realParametersCount)
+        assertEquals(1, method1.realParametersCount)
+        assertEquals(10, method10.realParametersCount)
+        assertEquals(11, method11.realParametersCount)
+        assertEquals(12, method12.realParametersCount)
+
+        assertEquals(0, nonComposable.realParametersCount)
+        assertEquals(1, nonComposableWithComposer.realParametersCount)
+        assertEquals(0, composableMethod.realParametersCount)
+        assertEquals(0, nonComposableMethod.realParametersCount)
+        assertEquals(1, nonComposableMethodWithComposer.realParametersCount)
+    }
+
+    @Suppress("ClassVerificationFailure", "NewApi")
+    @Throws(NoSuchMethodException::class)
+    @Test
+    fun test_realParameters_returns_correct_parameters() {
+        val function0 = clazz.getDeclaredComposableMethod("overloadedComposable")
+        val function1 =
+            clazz.getDeclaredComposableMethod("overloadedComposable", String::class.java)
+        val function10 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(10) { String::class.java }
+            )
+        val function11 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(11) { String::class.java }
+            )
+        val function12 =
+            clazz.getDeclaredComposableMethod(
+                "overloadedComposable",
+                *Array(12) { String::class.java }
+            )
+
+        val method0 = wrapperClazz.getDeclaredComposableMethod("overloadedComposableMethod")
+        val method1 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                String::class.java
+            )
+        val method10 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(10) { String::class.java }
+            )
+        val method11 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(11) { String::class.java }
+            )
+        val method12 =
+            wrapperClazz.getDeclaredComposableMethod(
+                "overloadedComposableMethod",
+                *Array(12) { String::class.java }
+            )
+
+        val diffParameters =
+            clazz.getDeclaredComposableMethod(
+                "differentParametersTypes",
+                String::class.java,
+                Any::class.java,
+                Int::class.java,
+                Float::class.java,
+                Double::class.java,
+                Long::class.java
+            )
+
+        val diffParametersMethod =
+            wrapperClazz.getDeclaredComposableMethod(
+                "differentParametersTypesMethod",
+                String::class.java,
+                Any::class.java,
+                Int::class.java,
+                Float::class.java,
+                Double::class.java,
+                Long::class.java
+            )
+
+        assertEquals(0, function0.realParameters.size)
+        assertEquals(1, function1.realParameters.size)
+        assertEquals(10, function10.realParameters.size)
+        assertEquals(11, function11.realParameters.size)
+        assertEquals(12, function12.realParameters.size)
+        assertEquals(12, function12.realParameters.size)
+
+        assertEquals(0, method0.realParameters.size)
+        assertEquals(1, method1.realParameters.size)
+        assertEquals(10, method10.realParameters.size)
+        assertEquals(11, method11.realParameters.size)
+        assertEquals(12, method12.realParameters.size)
+
+        assertEquals(0, nonComposable.realParameters.size)
+        assertEquals(1, nonComposableWithComposer.realParameters.size)
+        assertEquals(0, composableMethod.realParameters.size)
+        assertEquals(0, nonComposableMethod.realParameters.size)
+        assertEquals(1, nonComposableMethodWithComposer.realParameters.size)
+
+        assertEquals(6, diffParameters.realParameters.size)
+        assertEquals(
+            listOf(String::class.java, Any::class.java, Int::class.java, Float::class.java,
+                Double::class.java, Long::class.java),
+            diffParameters.realParameters.map { it.type })
+
+        assertEquals(6, diffParametersMethod.realParameters.size)
+        assertEquals(
+            listOf(String::class.java, Any::class.java, Int::class.java, Float::class.java,
+                Double::class.java, Long::class.java),
+            diffParametersMethod.realParameters.map { it.type })
+    }
+
+    private class TestFrameClock : MonotonicFrameClock {
+        override suspend fun <R> withFrameNanos(onFrame: (Long) -> R): R = onFrame(0L)
+    }
+
+    private fun <T> executeWithComposer(block: (composer: Composer) -> T): T =
+        runBlocking(TestFrameClock()) {
+            fun compose(
+                recomposer: Recomposer,
+                block: @Composable () -> Unit
+            ): Composition {
+                return Composition(
+                    EmptyApplier(),
+                    recomposer
+                ).apply {
+                    setContent(block)
+                }
+            }
+
+            var res: T? = null
+            withRunningRecomposer { r ->
+                compose(r) {
+                    res = block(currentComposer)
+                }
+            }
+            res!!
+        }
+
+    @Test
+    fun testInvokeComposableFunctions() {
+
+        val composableWithDefaults =
+            clazz.declaredMethods.find { it.name == "composableFunctionWithDefaults" }!!
+        composableWithDefaults.isAccessible = true
+
+        val resABAAA = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, null, "a", "b") as String
+        }
+
+        val resABCAA = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, null, "a", "b", "c") as String
+        }
+
+        val resABCDA = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, null, "a", "b", "c", "d") as String
+        }
+
+        val resABCDE = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, null, "a", "b", "c", "d", "e") as String
+        }
+
+        val resABADA = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, null, "a", "b", null, "d") as String
+        }
+
+        assertEquals("abaaa", resABAAA)
+        assertEquals("abcaa", resABCAA)
+        assertEquals("abcda", resABCDA)
+        assertEquals("abcde", resABCDE)
+        assertEquals("abada", resABADA)
+    }
+
+    @Test
+    fun testInvokeComposableMethods() {
+
+        val composableWithDefaults =
+            wrapperClazz.declaredMethods.find { it.name == "composableMethodWithDefaults" }!!
+        composableWithDefaults.isAccessible = true
+
+        val instance = ComposablesWrapper()
+
+        val resABAAA = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, instance, "a", "b") as String
+        }
+
+        val resABCAA = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, instance, "a", "b", "c") as String
+        }
+
+        val resABCDA = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, instance, "a", "b", "c", "d") as String
+        }
+
+        val resABCDE = executeWithComposer {
+            composableWithDefaults
+                .invokeComposable(it, instance, "a", "b", "c", "d", "e") as String
+        }
+
+        val resABADA = executeWithComposer {
+            composableWithDefaults.invokeComposable(it, instance, "a", "b", null, "d") as String
+        }
+
+        assertEquals("abaaa", resABAAA)
+        assertEquals("abcaa", resABCAA)
+        assertEquals("abcda", resABCDA)
+        assertEquals("abcde", resABCDE)
+        assertEquals("abada", resABADA)
+    }
+}
\ No newline at end of file
diff --git a/compose/ui/ui-tooling/api/public_plus_experimental_current.txt b/compose/ui/ui-tooling/api/public_plus_experimental_current.txt
index cfbe91f..6428016 100644
--- a/compose/ui/ui-tooling/api/public_plus_experimental_current.txt
+++ b/compose/ui/ui-tooling/api/public_plus_experimental_current.txt
@@ -1,9 +1,9 @@
 // Signature format: 4.0
 package androidx.compose.ui.tooling {
 
-  @androidx.compose.ui.ExperimentalComposeUiApi public final class ComposableInvoker {
-    method @androidx.compose.ui.ExperimentalComposeUiApi public void invokeComposable(String className, String methodName, androidx.compose.runtime.Composer composer, java.lang.Object?... args);
-    field public static final androidx.compose.ui.tooling.ComposableInvoker INSTANCE;
+  @Deprecated @androidx.compose.ui.ExperimentalComposeUiApi public final class ComposableInvoker {
+    method @Deprecated @androidx.compose.ui.ExperimentalComposeUiApi public void invokeComposable(String className, String methodName, androidx.compose.runtime.Composer composer, java.lang.Object?... args);
+    field @Deprecated public static final androidx.compose.ui.tooling.ComposableInvoker INSTANCE;
   }
 
   public final class ComposeViewAdapterKt {
diff --git a/compose/ui/ui-tooling/src/androidMain/kotlin/androidx/compose/ui/tooling/ComposeViewAdapter.kt b/compose/ui/ui-tooling/src/androidMain/kotlin/androidx/compose/ui/tooling/ComposeViewAdapter.kt
index 7c484d32..5d07d1a 100644
--- a/compose/ui/ui-tooling/src/androidMain/kotlin/androidx/compose/ui/tooling/ComposeViewAdapter.kt
+++ b/compose/ui/ui-tooling/src/androidMain/kotlin/androidx/compose/ui/tooling/ComposeViewAdapter.kt
@@ -49,7 +49,6 @@
 import androidx.compose.ui.platform.LocalFontLoader
 import androidx.compose.ui.platform.ViewRootForTest
 import androidx.compose.ui.text.font.createFontFamilyResolver
-import androidx.compose.ui.tooling.ComposableInvoker.invokeComposable
 import androidx.compose.ui.tooling.animation.PreviewAnimationClock
 import androidx.compose.ui.tooling.data.Group
 import androidx.compose.ui.tooling.data.SourceLocation
@@ -553,6 +552,7 @@
      * @param onCommit callback invoked after every commit of the preview composable.
      * @param onDraw callback invoked after every draw of the adapter. Only for test use.
      */
+    @Suppress("DEPRECATION")
     @OptIn(ExperimentalComposeUiApi::class)
     @VisibleForTesting
     internal fun init(
@@ -587,7 +587,7 @@
                 // class loads correctly.
                 val composable = {
                     try {
-                        invokeComposable(
+                        ComposableInvoker.invokeComposable(
                             className,
                             methodName,
                             composer,
diff --git a/compose/ui/ui-tooling/src/androidMain/kotlin/androidx/compose/ui/tooling/PreviewActivity.kt b/compose/ui/ui-tooling/src/androidMain/kotlin/androidx/compose/ui/tooling/PreviewActivity.kt
index 6e5cad2..ec5b8d9 100644
--- a/compose/ui/ui-tooling/src/androidMain/kotlin/androidx/compose/ui/tooling/PreviewActivity.kt
+++ b/compose/ui/ui-tooling/src/androidMain/kotlin/androidx/compose/ui/tooling/PreviewActivity.kt
@@ -28,7 +28,6 @@
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.ui.ExperimentalComposeUiApi
-import androidx.compose.ui.tooling.ComposableInvoker.invokeComposable
 
 /**
  * Activity used to run `@Composable` previews from Android Studio.
@@ -59,6 +58,7 @@
         intent?.getStringExtra("composable")?.let { setComposableContent(it) }
     }
 
+    @Suppress("DEPRECATION")
     @OptIn(ExperimentalComposeUiApi::class)
     private fun setComposableContent(composableFqn: String) {
         Log.d(TAG, "PreviewActivity has composable $composableFqn")
@@ -71,7 +71,7 @@
         }
         Log.d(TAG, "Previewing '$methodName' without a parameter provider.")
         setContent {
-            invokeComposable(
+            ComposableInvoker.invokeComposable(
                 className,
                 methodName,
                 currentComposer
@@ -86,6 +86,7 @@
      * Otherwise, the content will display a FAB that changes the argument value on click, cycling
      * through all the values in the provider's sequence.
      */
+    @Suppress("DEPRECATION")
     @OptIn(ExperimentalComposeUiApi::class)
     private fun setParameterizedContent(
         className: String,
@@ -107,7 +108,7 @@
 
                 Scaffold(
                     content = {
-                        invokeComposable(
+                        ComposableInvoker.invokeComposable(
                             className,
                             methodName,
                             currentComposer,
@@ -124,7 +125,7 @@
             }
         } else {
             setContent {
-                invokeComposable(
+                ComposableInvoker.invokeComposable(
                     className,
                     methodName,
                     currentComposer,
diff --git a/compose/ui/ui-tooling/src/desktopMain/kotlin/androidx/compose/desktop/ui/tooling/preview/runtime/NonInteractivePreviewFacade.kt b/compose/ui/ui-tooling/src/desktopMain/kotlin/androidx/compose/desktop/ui/tooling/preview/runtime/NonInteractivePreviewFacade.kt
index e569bf9..5cec2cc 100644
--- a/compose/ui/ui-tooling/src/desktopMain/kotlin/androidx/compose/desktop/ui/tooling/preview/runtime/NonInteractivePreviewFacade.kt
+++ b/compose/ui/ui-tooling/src/desktopMain/kotlin/androidx/compose/desktop/ui/tooling/preview/runtime/NonInteractivePreviewFacade.kt
@@ -20,7 +20,6 @@
 import androidx.compose.runtime.currentComposer
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.platform.TestComposeWindow
-import androidx.compose.ui.tooling.ComposableInvoker
 import androidx.compose.ui.unit.Density
 
 /**
@@ -43,7 +42,7 @@
  *    preview classpath (a requested preview function or a requested frame size may differ).
  * 7. A rendered frame is sent back to the IDE plugin and is shown in the IDE as an image.
  */
-@Suppress("unused")
+@Suppress("DEPRECATION", "unused")
 internal class NonInteractivePreviewFacade {
     companion object {
         @JvmStatic
@@ -57,7 +56,7 @@
                 // We need to delay the reflection instantiation of the class until we are in the
                 // composable to ensure all the right initialization has happened and the Composable
                 // class loads correctly.
-                ComposableInvoker.invokeComposable(
+                androidx.compose.ui.tooling.ComposableInvoker.invokeComposable(
                     className,
                     methodName,
                     currentComposer
diff --git a/compose/ui/ui-tooling/src/desktopMain/kotlin/androidx/compose/desktop/ui/tooling/preview/runtime/PreviewRunner.kt b/compose/ui/ui-tooling/src/desktopMain/kotlin/androidx/compose/desktop/ui/tooling/preview/runtime/PreviewRunner.kt
index 89a9b0c..a64124c 100644
--- a/compose/ui/ui-tooling/src/desktopMain/kotlin/androidx/compose/desktop/ui/tooling/preview/runtime/PreviewRunner.kt
+++ b/compose/ui/ui-tooling/src/desktopMain/kotlin/androidx/compose/desktop/ui/tooling/preview/runtime/PreviewRunner.kt
@@ -19,7 +19,6 @@
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.currentComposer
 import androidx.compose.ui.ExperimentalComposeUiApi
-import androidx.compose.ui.tooling.ComposableInvoker.invokeComposable
 import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.launchApplication
 import kotlinx.coroutines.DelicateCoroutinesApi
@@ -29,6 +28,7 @@
     companion object {
         private var previewComposition: @Composable () -> Unit = {}
 
+        @Suppress("DEPRECATION")
         @JvmStatic
         @OptIn(ExperimentalComposeUiApi::class)
         fun main(args: Array<String>) {
@@ -40,7 +40,7 @@
                 // We need to delay the reflection instantiation of the class until we are in the
                 // composable to ensure all the right initialization has happened and the Composable
                 // class loads correctly.
-                invokeComposable(
+                androidx.compose.ui.tooling.ComposableInvoker.invokeComposable(
                     className,
                     methodName,
                     currentComposer
diff --git a/compose/ui/ui-tooling/src/jvmMain/kotlin/androidx/compose/ui/tooling/ComposableInvoker.kt b/compose/ui/ui-tooling/src/jvmMain/kotlin/androidx/compose/ui/tooling/ComposableInvoker.kt
index 20309f7..28d41ec 100644
--- a/compose/ui/ui-tooling/src/jvmMain/kotlin/androidx/compose/ui/tooling/ComposableInvoker.kt
+++ b/compose/ui/ui-tooling/src/jvmMain/kotlin/androidx/compose/ui/tooling/ComposableInvoker.kt
@@ -25,6 +25,7 @@
 /**
  * A utility object to invoke composable function by its name and containing class.
  */
+@Deprecated("Use androidx.compose.runtime.reflect.ComposableMethodInvoker instead")
 @ExperimentalComposeUiApi
 object ComposableInvoker {
 
@@ -56,7 +57,7 @@
     }
 
     private inline fun <reified T> T.dup(count: Int): Array<T> {
-        return (0..count).map { this }.toTypedArray()
+        return (0 until count).map { this }.toTypedArray()
     }
 
     /**
@@ -71,7 +72,6 @@
                 methodName,
                 *args.mapNotNull { it?.javaClass }.toTypedArray(),
                 Composer::class.java, // composer param
-                kotlin.Int::class.java, // key param
                 *kotlin.Int::class.java.dup(changedParams) // changed params
             )
         } catch (e: ReflectiveOperationException) {
@@ -97,7 +97,7 @@
         "double" -> 0.toDouble()
         "float" -> 0.toFloat()
         "boolean" -> false
-        "char" -> '0'
+        "char" -> 0.toChar()
         else -> null
     }
 
@@ -155,7 +155,7 @@
         return invoke(instance, *arguments)
     }
 
-    private const val SLOTS_PER_INT = 15
+    private const val SLOTS_PER_INT = 10
     private const val BITS_PER_INT = 31
 
     private fun changedParamCount(realValueParams: Int, thisParams: Int): Int {
diff --git a/compose/ui/ui/build.gradle b/compose/ui/ui/build.gradle
index 2e7abc3..a2f5105 100644
--- a/compose/ui/ui/build.gradle
+++ b/compose/ui/ui/build.gradle
@@ -60,7 +60,7 @@
 
         implementation("androidx.core:core:1.5.0")
         implementation('androidx.collection:collection:1.0.0')
-        implementation(project(":customview:customview-poolingcontainer"))
+        implementation("androidx.customview:customview-poolingcontainer:1.0.0-rc01")
         implementation("androidx.savedstate:savedstate-ktx:1.2.0-rc01")
         implementation("androidx.lifecycle:lifecycle-common-java8:2.3.0")
         implementation("androidx.lifecycle:lifecycle-runtime:2.3.0")
@@ -151,7 +151,7 @@
                 implementation("androidx.autofill:autofill:1.0.0")
                 implementation(libs.kotlinCoroutinesAndroid)
 
-                implementation(project(":customview:customview-poolingcontainer"))
+                implementation("androidx.customview:customview-poolingcontainer:1.0.0-rc01")
                 implementation("androidx.savedstate:savedstate-ktx:1.2.0-rc01")
                 implementation("androidx.lifecycle:lifecycle-common-java8:2.3.0")
                 implementation("androidx.lifecycle:lifecycle-runtime:2.3.0")
diff --git a/emoji2/emoji2-views-helper/src/androidTest/java/androidx/emoji2/viewsintegration/EmojiEditableFactoryTest.java b/emoji2/emoji2-views-helper/src/androidTest/java/androidx/emoji2/viewsintegration/EmojiEditableFactoryTest.java
index e7862f4..a886719 100644
--- a/emoji2/emoji2-views-helper/src/androidTest/java/androidx/emoji2/viewsintegration/EmojiEditableFactoryTest.java
+++ b/emoji2/emoji2-views-helper/src/androidTest/java/androidx/emoji2/viewsintegration/EmojiEditableFactoryTest.java
@@ -24,10 +24,12 @@
 import static org.mockito.Mockito.mock;
 
 import android.annotation.SuppressLint;
+import android.os.Build;
 import android.text.Editable;
 import android.text.SpannableString;
 import android.text.Spanned;
 
+import androidx.annotation.RequiresApi;
 import androidx.emoji2.text.EmojiMetadata;
 import androidx.emoji2.text.EmojiSpan;
 import androidx.emoji2.text.SpannableBuilder;
@@ -58,6 +60,7 @@
         assertThat(editable, instanceOf(Editable.class));
     }
 
+    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
     @Test
     public void testNewEditable_preservesCharSequenceData() {
         final String string = "abc";
diff --git a/emoji2/emoji2/src/androidTest/java/androidx/emoji2/text/SpannableBuilderTest.java b/emoji2/emoji2/src/androidTest/java/androidx/emoji2/text/SpannableBuilderTest.java
index 3e7d8ca..d0ba42d 100644
--- a/emoji2/emoji2/src/androidTest/java/androidx/emoji2/text/SpannableBuilderTest.java
+++ b/emoji2/emoji2/src/androidTest/java/androidx/emoji2/text/SpannableBuilderTest.java
@@ -35,6 +35,7 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.withSettings;
 
+import android.os.Build;
 import android.text.DynamicLayout;
 import android.text.Editable;
 import android.text.Layout;
@@ -45,6 +46,7 @@
 import android.text.style.QuoteSpan;
 import android.text.style.TypefaceSpan;
 
+import androidx.annotation.RequiresApi;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.filters.MediumTest;
 import androidx.test.filters.SdkSuppress;
@@ -125,6 +127,7 @@
         assertEquals(1, start);
     }
 
+    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
     @Test
     public void testBlocksSpanCallbacks_forEmojiSpans() {
         final EmojiSpan span = mock(EmojiSpan.class);
@@ -186,6 +189,7 @@
         verify(mWatcher, times(1)).afterTextChanged(any(Editable.class));
     }
 
+    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
     @Test
     public void testDoesNotBlockSpanCallbacksForOtherWatchers() {
         final TextWatcher textWatcher = mock(TextWatcher.class);
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index e5bafaa..3f27db1 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -121,7 +121,7 @@
 kotlinCoroutinesRx3 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-rx3", version.ref = "kotlinCoroutines" }
 kotlinDaemonEmbeddable = { module = "org.jetbrains.kotlin:kotlin-daemon-embeddable", version.ref = "kotlin" }
 kotlinKlibCommonizer = { module = "org.jetbrains.kotlin:kotlin-klib-commonizer", version.ref = "kotlin" }
-kotlinMetadataJvm = { module = "org.jetbrains.kotlinx:kotlinx-metadata-jvm", version = "0.4.2" }
+kotlinMetadataJvm = { module = "org.jetbrains.kotlinx:kotlinx-metadata-jvm", version = "0.5.0" }
 kotlinStdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
 kotlinStdlibCommon = { module = "org.jetbrains.kotlin:kotlin-stdlib-common", version.ref = "kotlin" }
 kotlinStdlibJdk8 = { module = "org.jetbrains.kotlin:kotlin-stdlib-jdk8", version.ref = "kotlin" }
diff --git a/slidingpanelayout/slidingpanelayout/api/current.txt b/slidingpanelayout/slidingpanelayout/api/current.txt
index 076425d..9340904 100644
--- a/slidingpanelayout/slidingpanelayout/api/current.txt
+++ b/slidingpanelayout/slidingpanelayout/api/current.txt
@@ -6,7 +6,7 @@
     ctor public SlidingPaneLayout(android.content.Context, android.util.AttributeSet?);
     ctor public SlidingPaneLayout(android.content.Context, android.util.AttributeSet?, int);
     method public void addPanelSlideListener(androidx.slidingpanelayout.widget.SlidingPaneLayout.PanelSlideListener);
-    method protected boolean canScroll(android.view.View!, boolean, int, int, int);
+    method protected boolean canScroll(android.view.View, boolean, int, int, int);
     method @Deprecated public boolean canSlide();
     method public void close();
     method public boolean closePane();
diff --git a/slidingpanelayout/slidingpanelayout/api/public_plus_experimental_current.txt b/slidingpanelayout/slidingpanelayout/api/public_plus_experimental_current.txt
index 076425d..9340904 100644
--- a/slidingpanelayout/slidingpanelayout/api/public_plus_experimental_current.txt
+++ b/slidingpanelayout/slidingpanelayout/api/public_plus_experimental_current.txt
@@ -6,7 +6,7 @@
     ctor public SlidingPaneLayout(android.content.Context, android.util.AttributeSet?);
     ctor public SlidingPaneLayout(android.content.Context, android.util.AttributeSet?, int);
     method public void addPanelSlideListener(androidx.slidingpanelayout.widget.SlidingPaneLayout.PanelSlideListener);
-    method protected boolean canScroll(android.view.View!, boolean, int, int, int);
+    method protected boolean canScroll(android.view.View, boolean, int, int, int);
     method @Deprecated public boolean canSlide();
     method public void close();
     method public boolean closePane();
diff --git a/slidingpanelayout/slidingpanelayout/api/restricted_current.txt b/slidingpanelayout/slidingpanelayout/api/restricted_current.txt
index 076425d..9340904 100644
--- a/slidingpanelayout/slidingpanelayout/api/restricted_current.txt
+++ b/slidingpanelayout/slidingpanelayout/api/restricted_current.txt
@@ -6,7 +6,7 @@
     ctor public SlidingPaneLayout(android.content.Context, android.util.AttributeSet?);
     ctor public SlidingPaneLayout(android.content.Context, android.util.AttributeSet?, int);
     method public void addPanelSlideListener(androidx.slidingpanelayout.widget.SlidingPaneLayout.PanelSlideListener);
-    method protected boolean canScroll(android.view.View!, boolean, int, int, int);
+    method protected boolean canScroll(android.view.View, boolean, int, int, int);
     method @Deprecated public boolean canSlide();
     method public void close();
     method public boolean closePane();
diff --git a/slidingpanelayout/slidingpanelayout/lint-baseline.xml b/slidingpanelayout/slidingpanelayout/lint-baseline.xml
deleted file mode 100644
index dc294c0..0000000
--- a/slidingpanelayout/slidingpanelayout/lint-baseline.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<issues format="6" by="lint 7.3.0-alpha07" type="baseline" client="gradle" dependencies="false" name="AGP (7.3.0-alpha07)" variant="all" version="7.3.0-alpha07">
-
-    <issue
-        id="UnknownNullness"
-        message="Unknown nullability; explicitly declare as `@Nullable` or `@NonNull` to improve Kotlin interoperability; see https://developer.android.com/kotlin/interop#nullability_annotations"
-        errorLine1="    protected boolean canScroll(View v, boolean checkV, int dx, int x, int y) {"
-        errorLine2="                                ~~~~">
-        <location
-            file="src/main/java/androidx/slidingpanelayout/widget/SlidingPaneLayout.java"/>
-    </issue>
-
-    <issue
-        id="UnknownNullness"
-        message="Unknown nullability; explicitly declare as `@Nullable` or `@NonNull` to improve Kotlin interoperability; see https://developer.android.com/kotlin/interop#nullability_annotations"
-        errorLine1="    protected Parcelable onSaveInstanceState() {"
-        errorLine2="              ~~~~~~~~~~">
-        <location
-            file="src/main/java/androidx/slidingpanelayout/widget/SlidingPaneLayout.java"/>
-    </issue>
-
-</issues>
diff --git a/slidingpanelayout/slidingpanelayout/src/main/java/androidx/slidingpanelayout/widget/SlidingPaneLayout.java b/slidingpanelayout/slidingpanelayout/src/main/java/androidx/slidingpanelayout/widget/SlidingPaneLayout.java
index 9ba74f4..9de4b03 100644
--- a/slidingpanelayout/slidingpanelayout/src/main/java/androidx/slidingpanelayout/widget/SlidingPaneLayout.java
+++ b/slidingpanelayout/slidingpanelayout/src/main/java/androidx/slidingpanelayout/widget/SlidingPaneLayout.java
@@ -1426,7 +1426,7 @@
      * @param y      Y coordinate of the active touch point
      * @return true if child views of v can be scrolled by delta of dx.
      */
-    protected boolean canScroll(View v, boolean checkV, int dx, int x, int y) {
+    protected boolean canScroll(@NonNull View v, boolean checkV, int dx, int x, int y) {
         if (v instanceof ViewGroup) {
             final ViewGroup group = (ViewGroup) v;
             final int scrollX = v.getScrollX();
@@ -1479,6 +1479,7 @@
         return new LayoutParams(getContext(), attrs);
     }
 
+    @NonNull
     @Override
     protected Parcelable onSaveInstanceState() {
         Parcelable superState = super.onSaveInstanceState();