[pull] androidx-main from androidx:androidx-main

activity/activity-compose/src/main/java/androidx/activity/compose/BackHandler.kt

@@ -37,6 +37,7 @@ import androidx.compose.ui.platform.LocalView
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.compose.LifecycleStartEffect
+import androidx.navigationevent.NavigationEventDispatcherOwner
 import androidx.navigationevent.NavigationEventInfo
 import androidx.navigationevent.compose.LocalNavigationEventDispatcherOwner
 
@@ -105,24 +106,26 @@ public object LocalOnBackPressedDispatcherOwner {
 @OptIn(ExperimentalActivityApi::class)
 @Composable
 public fun BackHandler(enabled: Boolean = true, onBack: () -> Unit) {
-    val navigationEventDispatcherOwner = LocalNavigationEventDispatcherOwner.current
-    val onBackPressedDispatcherOwner = LocalOnBackPressedDispatcherOwner.current
+    // Short-circuit: Only read the legacy owner if the new one is missing.
     val owner =
-        requireNotNull(navigationEventDispatcherOwner ?: onBackPressedDispatcherOwner) {
-            "No NavigationEventDispatcherOwner was provided via " +
-                "LocalNavigationEventDispatcherOwner and no OnBackPressedDispatcherOwner was " +
-                "provided via LocalOnBackPressedDispatcherOwner. Please provide one of the two."
+        LocalNavigationEventDispatcherOwner.current
+            ?: LocalOnBackPressedDispatcherOwner.current
+            ?: error(
+                "No NavigationEventDispatcherOwner was provided via " +
+                    "LocalNavigationEventDispatcherOwner and no OnBackPressedDispatcherOwner was " +
+                    "provided via LocalOnBackPressedDispatcherOwner. Please provide one of the two."
+            )
+
+    val dispatcher =
+        remember(owner) {
+            // Create a dispatcher compatibility layer that decides whether to use the new
+            // 'NavigationEventDispatcher' or the legacy 'OnBackPressedDispatcher'.
+            BackHandlerDispatcherCompat(
+                (owner as? NavigationEventDispatcherOwner)?.navigationEventDispatcher,
+                (owner as? OnBackPressedDispatcherOwner)?.onBackPressedDispatcher,
+            )
         }
 
-    val dispatcher = remember {
-        // Create a dispatcher compatibility layer that decides whether to use the new
-        // 'NavigationEventDispatcher' or the legacy 'OnBackPressedDispatcher'.
-        BackHandlerDispatcherCompat(
-            navigationEventDispatcher = navigationEventDispatcherOwner?.navigationEventDispatcher,
-            onBackPressedDispatcher = onBackPressedDispatcherOwner?.onBackPressedDispatcher,
-        )
-    }
-
     val compositeKey = currentCompositeKeyHashCode
     val handler =
         remember(dispatcher, compositeKey) {

activity/activity-compose/src/main/java/androidx/activity/compose/PredictiveBackHandler.kt

@@ -21,6 +21,7 @@ import androidx.activity.ActivityFlags
 import androidx.activity.BackEventCompat
 import androidx.activity.ExperimentalActivityApi
 import androidx.activity.OnBackPressedCallback
+import androidx.activity.OnBackPressedDispatcherOwner
 import androidx.activity.compose.internal.BackHandlerCompat
 import androidx.activity.compose.internal.BackHandlerDispatcherCompat
 import androidx.compose.runtime.Composable
@@ -32,6 +33,7 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.compose.LifecycleStartEffect
+import androidx.navigationevent.NavigationEventDispatcherOwner
 import androidx.navigationevent.NavigationEventInfo
 import androidx.navigationevent.compose.LocalNavigationEventDispatcherOwner
 import java.util.concurrent.CancellationException
@@ -115,23 +117,25 @@ public fun PredictiveBackHandler(
         suspend (progress: @JvmSuppressWildcards Flow<BackEventCompat>) -> @JvmSuppressWildcards
             Unit,
 ) {
-    val navigationEventDispatcherOwner = LocalNavigationEventDispatcherOwner.current
-    val onBackPressedDispatcherOwner = LocalOnBackPressedDispatcherOwner.current
+    // Short-circuit: Only read the legacy owner if the new one is missing.
     val owner =
-        requireNotNull(navigationEventDispatcherOwner ?: onBackPressedDispatcherOwner) {
-            "No NavigationEventDispatcherOwner was provided via " +
-                "LocalNavigationEventDispatcherOwner and no OnBackPressedDispatcherOwner was " +
-                "provided via LocalOnBackPressedDispatcherOwner. Please provide one of the two."
-        }
+        LocalNavigationEventDispatcherOwner.current
+            ?: LocalOnBackPressedDispatcherOwner.current
+            ?: error(
+                "No NavigationEventDispatcherOwner was provided via " +
+                    "LocalNavigationEventDispatcherOwner and no OnBackPressedDispatcherOwner was " +
+                    "provided via LocalOnBackPressedDispatcherOwner. Please provide one of the two."
+            )
 
-    val dispatcher = remember {
-        // Create a dispatcher compatibility layer that decides whether to use the new
-        // 'NavigationEventDispatcher' or the legacy 'OnBackPressedDispatcher'.
-        BackHandlerDispatcherCompat(
-            navigationEventDispatcher = navigationEventDispatcherOwner?.navigationEventDispatcher,
-            onBackPressedDispatcher = onBackPressedDispatcherOwner?.onBackPressedDispatcher,
-        )
-    }
+    val dispatcher =
+        remember(owner) {
+            // Create a dispatcher compatibility layer that decides whether to use the new
+            // 'NavigationEventDispatcher' or the legacy 'OnBackPressedDispatcher'.
+            BackHandlerDispatcherCompat(
+                (owner as? NavigationEventDispatcherOwner)?.navigationEventDispatcher,
+                (owner as? OnBackPressedDispatcherOwner)?.onBackPressedDispatcher,
+            )
+        }
 
     val scope = rememberCoroutineScope()
     val compositeKey = currentCompositeKeyHashCode

binarycompatibilityvalidator/binarycompatibilityvalidator/src/jvmMain/kotlin/androidx/binarycompatibilityvalidator/BinaryCompatibilityChecker.kt

@@ -158,7 +158,12 @@ class BinaryCompatibilityChecker(
             return
         }
         when (this) {
-            is AbiClass -> isBinaryCompatibleWith(oldDeclaration as AbiClass, errors)
+            is AbiClass ->
+                DecoratedAbiClass(this, newLibraryDeclarations)
+                    .isBinaryCompatibleWith(
+                        DecoratedAbiClass(oldDeclaration as AbiClass, oldLibraryDeclarations),
+                        errors,
+                    )
             is DecoratedAbiFunction ->
                 isBinaryCompatibleWith(oldDeclaration as DecoratedAbiFunction, errors)
             is DecoratedAbiProperty ->
@@ -171,7 +176,10 @@ class BinaryCompatibilityChecker(
         }
     }
 
-    private fun AbiClass.isBinaryCompatibleWith(oldClass: AbiClass, errors: CompatibilityErrors) {
+    private fun DecoratedAbiClass.isBinaryCompatibleWith(
+        oldClass: DecoratedAbiClass,
+        errors: CompatibilityErrors,
+    ) {
         if (modality != oldClass.modality) {
             when {
                 modality == AbiModality.OPEN && oldClass.modality == AbiModality.FINAL -> Unit
@@ -205,9 +213,9 @@ class BinaryCompatibilityChecker(
         }
 
         // Check that previous supertypes are still currently supertypes
-        allSuperTypes(newLibraryDeclarations)
+        allSuperTypes()
             .isBinaryCompatibleWith(
-                oldClass.allSuperTypes(oldLibraryDeclarations),
+                oldClass.allSuperTypes(),
                 entityName = "superType",
                 uniqueId = AbiType::asString,
                 isBinaryCompatibleWith = AbiType::isBinaryCompatibleWith,
@@ -223,8 +231,8 @@ class BinaryCompatibilityChecker(
             errors = errors,
             isAllowedAddition = { false },
         )
-        val newDecs = allDeclarationsIncludingInherited(newLibraryDeclarations)
-        val oldDecs = oldClass.allDeclarationsIncludingInherited(oldLibraryDeclarations)
+        val newDecs = allDeclarationsIncludingInherited()
+        val oldDecs = oldClass.allDeclarationsIncludingInherited()
         newDecs.isBinaryCompatibleWith(
             oldDecs,
             entityName = "declaration",
@@ -233,8 +241,14 @@ class BinaryCompatibilityChecker(
                 isBinaryCompatibleWith(other, parentName, errs)
             },
             isAllowedAddition = {
-                when {
-                    this is AbiFunction -> modality != AbiModality.ABSTRACT
+                when (this) {
+                    is DecoratedAbiFunction,
+                    is DecoratedAbiProperty -> (this as HasEffectiveModality).isSafeAddition()
+                    is AbiFunction,
+                    is AbiProperty ->
+                        throw IllegalStateException(
+                            "All functions / properties should be decorated"
+                        )
                     else -> true
                 }
             },
@@ -243,70 +257,6 @@ class BinaryCompatibilityChecker(
         )
     }
 
-    private fun AbiClass.allSuperTypes(declarations: Map<String, AbiDeclaration>): List<AbiType> {
-        return superTypes + superTypes.flatMap { it.allSuperTypes(declarations) }
-    }
-
-    private fun AbiType.allSuperTypes(declarations: Map<String, AbiDeclaration>): List<AbiType> {
-        val abiClass = declarations[asString()] as? AbiClass ?: return emptyList()
-        val superTypes = abiClass.superTypes
-        return superTypes + superTypes.flatMap { it.allSuperTypes(declarations) }
-    }
-
-    private fun AbiClass.allDeclarationsIncludingInherited(
-        oldLibraryDeclarations: Map<String, AbiDeclaration>
-    ): List<AbiDeclaration> {
-        // Collect all the declarations directly on the class (without functions) +
-        // + all functions, (including inherited). The filterNot is to avoid listing
-        // functions directly on the class twice.
-        return declarations.filterNot { it is AbiFunction }.filterNot { it is AbiProperty } +
-            allMethodsIncludingInherited(oldLibraryDeclarations) +
-            allPropertiesIncludingInherited(oldLibraryDeclarations)
-    }
-
-    private fun AbiClass.allPropertiesIncludingInherited(
-        oldLibraryDeclarations: Map<String, AbiDeclaration>,
-        baseClass: AbiClass = this,
-    ): List<DecoratedAbiProperty> {
-        val propertyMap =
-            declarations
-                .filterIsInstance<AbiProperty>()
-                .associate { it.asUnqualifiedTypeString() to DecoratedAbiProperty(it, baseClass) }
-                .toMutableMap()
-        superTypes
-            .map {
-                // we should throw here if we can't find the class in the package/dependencies
-                oldLibraryDeclarations[it.asString()]
-            }
-            .filterIsInstance<AbiClass>()
-            .flatMap { it.allPropertiesIncludingInherited(oldLibraryDeclarations, baseClass) }
-            .associateBy { it.asUnqualifiedTypeString() }
-            .forEach { (key, prop) -> propertyMap.putIfAbsent(key, prop) }
-        return propertyMap.values.toList()
-    }
-
-    private fun AbiClass.allMethodsIncludingInherited(
-        oldLibraryDeclarations: Map<String, AbiDeclaration>,
-        baseClass: AbiClass = this,
-    ): List<DecoratedAbiFunction> {
-        val functionMap =
-            declarations
-                .filterIsInstance<AbiFunction>()
-                .associate { it.asUnqualifiedTypeString() to DecoratedAbiFunction(it, baseClass) }
-                .toMutableMap()
-        superTypes
-            .map {
-                oldLibraryDeclarations.getOrElse(it.className.toString()) {
-                    throw IllegalStateException("Missing declaration ${it.asString()}")
-                }
-            }
-            .filterIsInstance<AbiClass>()
-            .flatMap { it.allMethodsIncludingInherited(oldLibraryDeclarations, baseClass) }
-            .associateBy { it.asUnqualifiedTypeString() }
-            .forEach { (key, func) -> functionMap.putIfAbsent(key, func) }
-        return functionMap.values.toList()
-    }
-
     private fun DecoratedAbiFunction.isBinaryCompatibleWith(
         otherFunction: DecoratedAbiFunction,
         errors: CompatibilityErrors,
@@ -854,24 +804,120 @@ private fun File.asBaselineErrors(): Set<String> =
         }
     }
 
-private class DecoratedAbiFunction(abiFunction: AbiFunction, val parentClass: AbiClass?) :
-    AbiFunction by abiFunction {
-    val effectiveModality
+private interface HasEffectiveModality {
+    val effectiveModality: AbiModality
+
+    fun isSafeAddition(): Boolean
+}
+
+private class ClassMember(
+    private val parentClass: DecoratedAbiClass?,
+    private val modality: AbiModality,
+) : HasEffectiveModality {
+    override val effectiveModality
         get() =
             when (parentClass?.modality) {
                 AbiModality.FINAL -> AbiModality.FINAL
                 else -> modality
             }
+
+    override fun isSafeAddition(): Boolean {
+        if (parentClass?.modality == AbiModality.SEALED && !parentClass.hasAbstractSubClasses()) {
+            return true
+        }
+        return modality != AbiModality.ABSTRACT
+    }
 }
 
-private class DecoratedAbiProperty(abiProperty: AbiProperty, val parentClass: AbiClass?) :
-    AbiProperty by abiProperty {
-    val effectiveModality
-        get() =
-            when (parentClass?.modality) {
-                AbiModality.FINAL -> AbiModality.FINAL
-                else -> modality
+private class DecoratedAbiFunction(abiFunction: AbiFunction, val parentClass: DecoratedAbiClass?) :
+    AbiFunction by abiFunction,
+    HasEffectiveModality by ClassMember(parentClass, abiFunction.modality)
+
+private class DecoratedAbiProperty(abiProperty: AbiProperty, val parentClass: DecoratedAbiClass?) :
+    AbiProperty by abiProperty,
+    HasEffectiveModality by ClassMember(parentClass, abiProperty.modality)
+
+private class DecoratedAbiClass(
+    abiClass: AbiClass,
+    private val allDeclarations: Map<String, AbiDeclaration>,
+) : AbiClass by abiClass {
+
+    fun allSuperTypes(): List<AbiType> {
+        return superTypes + superTypes.flatMap { it.allSuperTypes(allDeclarations) }
+    }
+
+    fun subClasses(): List<AbiClass> {
+        return allDeclarations.values.filterIsInstance<AbiClass>().filter { abiClass ->
+            DecoratedAbiClass(abiClass, allDeclarations).allSuperTypes().any {
+                it.className == qualifiedName
+            }
+        }
+    }
+
+    fun hasAbstractSubClasses(): Boolean = subClasses().any { it.modality == AbiModality.ABSTRACT }
+
+    fun allDeclarationsIncludingInherited(): List<AbiDeclaration> {
+        // Collect all the declarations directly on the class (without functions / properties) +
+        // + all functions / properties (including inherited). The filterNot is to avoid listing
+        // functions / properties directly on the class twice.
+        return declarations.filterNot { it is AbiFunction || it is AbiProperty } +
+            allMethodsIncludingInherited() +
+            allPropertiesIncludingInherited()
+    }
+
+    fun allPropertiesIncludingInherited(baseClass: AbiClass = this): List<DecoratedAbiProperty> {
+        val propertyMap =
+            declarations
+                .filterIsInstance<AbiProperty>()
+                .associate {
+                    it.asUnqualifiedTypeString() to
+                        DecoratedAbiProperty(it, DecoratedAbiClass(baseClass, allDeclarations))
+                }
+                .toMutableMap()
+        superTypes
+            .asSequence()
+            .map {
+                allDeclarations.getOrElse(it.className.toString()) {
+                    throw IllegalStateException("Missing declaration ${it.asString()}")
+                }
+            }
+            .filterIsInstance<AbiClass>()
+            .map { DecoratedAbiClass(it, allDeclarations) }
+            .flatMap { it.allPropertiesIncludingInherited(baseClass) }
+            .associateBy { it.asUnqualifiedTypeString() }
+            .forEach { (key, prop) -> propertyMap.putIfAbsent(key, prop) }
+        return propertyMap.values.toList()
+    }
+
+    fun allMethodsIncludingInherited(baseClass: AbiClass = this): List<DecoratedAbiFunction> {
+        val functionMap =
+            declarations
+                .filterIsInstance<AbiFunction>()
+                .associate {
+                    it.asUnqualifiedTypeString() to
+                        DecoratedAbiFunction(it, DecoratedAbiClass(baseClass, allDeclarations))
+                }
+                .toMutableMap()
+        superTypes
+            .asSequence()
+            .map {
+                allDeclarations.getOrElse(it.className.toString()) {
+                    throw IllegalStateException("Missing declaration ${it.asString()}")
+                }
             }
+            .filterIsInstance<AbiClass>()
+            .map { DecoratedAbiClass(it, allDeclarations) }
+            .flatMap { it.allMethodsIncludingInherited(baseClass) }
+            .associateBy { it.asUnqualifiedTypeString() }
+            .forEach { (key, func) -> functionMap.putIfAbsent(key, func) }
+        return functionMap.values.toList()
+    }
+
+    private fun AbiType.allSuperTypes(declarations: Map<String, AbiDeclaration>): List<AbiType> {
+        val abiClass = declarations[asString()] as? AbiClass ?: return emptyList()
+        val superTypes = abiClass.superTypes
+        return superTypes + superTypes.flatMap { it.allSuperTypes(declarations) }
+    }
 }
 
 private class DecoratedAbiValueParameter(val index: Int, param: AbiValueParameter) :