Merge branch 'jb-main' into integration

# Conflicts:
#	collection/collection/build.gradle
#	window/window-core/build.gradle

Author: MatkovIvan

buildSrc/private/src/main/kotlin/androidx/build/MavenUploadHelper.kt

@@ -20,7 +20,6 @@ import com.android.build.gradle.AppPlugin
 import com.android.build.gradle.LibraryPlugin
 import com.android.utils.childrenIterator
 import com.android.utils.forEach
-import com.android.utils.mapValuesNotNull
 import com.google.gson.GsonBuilder
 import com.google.gson.JsonObject
 import com.google.gson.stream.JsonWriter
@@ -59,8 +58,10 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginWrapper
 import org.xml.sax.InputSource
 import org.xml.sax.XMLReader
-import androidx.build.jetbrains.ArtifactRedirecting
-import androidx.build.jetbrains.artifactRedirecting
+import androidx.build.jetbrains.originalToRedirectedDependency
+import org.gradle.api.artifacts.ModuleIdentifier
+import org.gradle.api.artifacts.ModuleVersionIdentifier
+import org.gradle.api.internal.artifacts.DefaultModuleIdentifier
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
 
 fun Project.configureMavenArtifactUpload(
@@ -120,19 +121,6 @@ private fun Project.configureComponentPublishing(
     )
     group = androidxGroup.group
 
-    val mavenCoordsToRedirecting: Provider<Map<String, ArtifactRedirecting>> = provider {
-        project
-            .getProjectsMap()
-            .values
-            .mapNotNull { project.findProject(it) }
-            .associateBy {
-                val group = it.group
-                val name = it.name
-                "$group:$name"
-            }
-            .mapValuesNotNull { it.value.artifactRedirecting() }
-    }
-
     /*
      * Provides a set of maven coordinates (groupId:artifactId) of artifacts in AndroidX
      * that are Android Libraries.
@@ -206,10 +194,21 @@ private fun Project.configureComponentPublishing(
     }
     project.tasks.withType(GenerateMavenPom::class.java).configureEach { task ->
         task.doLast {
+            fun hasTargetWithComponent(componentName: String) =
+                multiplatformExtension?.targets?.find { target ->
+                    target.components.any { it.name == componentName }
+                } != null
+
+            // extract heuristically from:
+            // "build/publications/kotlinMultiplatformDecorated/pom-default.xml"
+            // "build/publications/desktop/pom-default.xml"
+            // ...
+            // and take only if it is a target's component (we redirect only targets)
+            val componentName = task.destination.parentFile.name.takeIf(::hasTargetWithComponent)
+
             val pomFile = task.destination
             val pom = pomFile.readText()
-            val modifiedPom = modifyPomDependencies(pom, mavenCoordsToRedirecting.get())
-
+            val modifiedPom = modifyPomDependencies(pom, componentName)
             if (pom != modifiedPom) {
                 pomFile.writeText(modifiedPom)
             }
@@ -234,10 +233,7 @@ private fun Project.configureComponentPublishing(
 /**
  * Looks for a dependencies XML element within [pom], sorts its contents and modify it by redirecting coordinates
  */
-internal fun modifyPomDependencies(
-    pom: String,
-    mavenCoordsToRedirecting: Map<String, ArtifactRedirecting>
-): String {
+internal fun Project.modifyPomDependencies(pom: String, componentName: String?): String {
     // Workaround for using the default namespace in dom4j.
     val namespaceUris = mapOf("ns" to "http://maven.apache.org/POM/4.0.0")
     val docFactory = DocumentFactory()
@@ -246,14 +242,20 @@ internal fun modifyPomDependencies(
     val xmlReader = JAXPSAXParser()
     val document = parseText(docFactory, xmlReader, pom)
 
+    val originalToRedirected = if (componentName != null) {
+        originalToRedirectedDependency(componentName)
+    } else {
+        emptyMap()
+    }
+
     // For each <dependencies> element, sort the contained elements in-place.
     document.rootElement
         .selectNodes("ns:dependencies")
         .filterIsInstance<Element>()
         .forEach { element ->
             val deps = element.elements()
             val modifiedDeps = deps
-                .map { modifyPomDependency(it, mavenCoordsToRedirecting) }
+                .onEach { modifyPomDependency(it, originalToRedirected) }
                 .sortedBy { it.stringValue }
 
             // Content contains formatting nodes, so to avoid modifying those we replace
@@ -284,22 +286,18 @@ internal fun modifyPomDependencies(
 
 internal fun modifyPomDependency(
     dependency: Element,
-    mavenCoordsToRedirecting: Map<String, ArtifactRedirecting>
-): Element {
-    val groupId = dependency.selectSingleNode("ns:groupId")
-    val artifactId = dependency.selectSingleNode("ns:artifactId")
-    val version = dependency.selectSingleNode("ns:version")
-    val name = artifactId.stringValue.substringBeforeLast("-")
-    val target = artifactId.stringValue.substringAfterLast("-")
-
-    val coords = "${groupId.stringValue}:$name"
-    val redirecting = mavenCoordsToRedirecting[coords] ?: return dependency
-    val shouldReplace = redirecting.targetNames.contains(target)
-    if (shouldReplace) {
-        groupId.text = redirecting.groupId
-        version.text = redirecting.versionForTargetOrDefault(target)
+    originalToRedirected: Map<ModuleIdentifier, ModuleVersionIdentifier>
+) {
+    val groupIdNode = dependency.selectSingleNode("ns:groupId")
+    val artifactIdNode = dependency.selectSingleNode("ns:artifactId")
+    val versionNode = dependency.selectSingleNode("ns:version")
+    val id = DefaultModuleIdentifier.newId(groupIdNode.stringValue, artifactIdNode.stringValue)
+    val redirected = originalToRedirected[id]
+    if (redirected != null) {
+        groupIdNode.text = redirected.group
+        artifactIdNode.text = redirected.name
+        versionNode.text = redirected.version
     }
-    return dependency
 }
 
 // Coped from org.dom4j.DocumentHelper with modifications to allow SAXReader configuration.

buildSrc/private/src/main/kotlin/androidx/build/jetbrains/JetbrainsAndroidXRedirectingPublicationHelpers.kt

@@ -16,22 +16,27 @@
 
 package androidx.build.jetbrains
 
+import androidx.build.getProjectsMap
+import com.android.utils.mapValuesNotNull
 import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
 import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.internal.publication.DefaultMavenPublication
-import org.gradle.api.attributes.Usage
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.DependencyConstraint
 import org.gradle.api.artifacts.ExcludeRule
 import org.gradle.api.artifacts.ModuleDependency
+import org.gradle.api.artifacts.ModuleIdentifier
 import org.gradle.api.artifacts.ModuleVersionIdentifier
 import org.gradle.api.artifacts.PublishArtifact
+import org.gradle.api.artifacts.ResolvedDependency
 import org.gradle.api.attributes.AttributeContainer
 import org.gradle.api.capabilities.Capability
 import org.gradle.api.component.ComponentWithCoordinates
 import org.gradle.api.component.ComponentWithVariants
 import org.gradle.api.component.SoftwareComponent
+import org.gradle.api.internal.artifacts.DefaultModuleIdentifier
+import org.gradle.api.internal.artifacts.DefaultModuleVersionIdentifier
 import org.gradle.api.internal.component.SoftwareComponentInternal
 import org.gradle.api.internal.component.UsageContext
 import org.gradle.api.publish.maven.MavenPublication
@@ -150,4 +155,85 @@ internal class CustomRootComponent(
             )
         )
     }
-}
+}
+
+internal fun Project.originalToRedirectedDependency(
+    componentName: String
+): Map<ModuleIdentifier, ModuleVersionIdentifier> {
+    /**
+     * Find a redirect to another group and version.
+     *
+     * Use heuristic method that compares modules names. Example:
+     *   [first-level-dependency] org.jetbrains.androidx.lifecycle:lifecycle-runtime:2.8.4 ->
+     *   [artifact-with-the-same-name] androidx.lifecycle:lifecycle-runtime:2.8.5 ->
+     *   [artifact-with-the-same-name-plus-suffix] androidx.lifecycle:lifecycle-runtime-desktop:2.8.5
+     *
+     * The first dependency redirects to the last one.
+     */
+    fun ResolvedDependency.findRedirectedDependencyHeuristically() =
+        children
+            .find { it.moduleName == moduleName }
+            ?.children
+            // don't check `it.moduleName == "moduleName-$target"` here,
+            // as it can be resolved to any other suitable target
+            // (for example, to jvm, or any other custom)
+            ?.find { it.moduleName.startsWith(moduleName) }
+
+    /**
+     * Extract redirections from project configuration
+     *
+     * Example for compose:ui
+     * org.jetbrains.androidx.performance:performance-annotation-iosarm64=androidx.performance:performance-annotation-iosarm64:1.0.0-alpha01
+     * org.jetbrains.androidx.performance:performance-annotation-jvm=androidx.performance:performance-annotation-jvm:1.0.0-alpha01
+     * org.jetbrains.compose.annotation-internal:annotation-jvm=androidx.annotation:annotation-jvm:1.9.1
+     * org.jetbrains.compose.collection-internal:collection-jvm=androidx.collection:collection-jvm:1.5.0-beta01
+     * ...
+     */
+    val projectDefined =
+        getProjectsMap()
+            .values
+            .mapNotNull { project.findProject(it) }
+            .flatMap { project ->
+                val redirecting = project.artifactRedirecting()
+                redirecting.targetNames.filter { it.isNotEmpty() }.map {
+                    val group = project.group.toString()
+                    val name = project.name.toString()
+                    val target = it
+                    val original = DefaultModuleIdentifier.newId(group, "$name-$target")
+                    val redirected = DefaultModuleVersionIdentifier.newId(
+                        redirecting.groupId,
+                        "$name-$target",
+                        redirecting.versionForTargetOrDefault(target)
+                    )
+                    original to redirected
+                }
+            }
+            .associate { it }
+
+    fun mainConfiguration() =
+        configurations.find { it.name == "${componentName}RuntimeClasspath" } ?:
+        configurations.find { it.name == "${componentName}CompileKlibraries" }!!
+
+    /**
+     * Extract redirections for dependencies using heuristic method (for both project, and external)
+     *
+     * Example for compose:ui
+     * org.jetbrains.compose.annotation-internal:annotation=androidx.annotation:annotation-jvm:1.9.1
+     * org.jetbrains.compose.collection-internal:collection=androidx.collection:collection-jvm:1.5.0-beta02
+     * org.jetbrains.androidx.lifecycle:lifecycle-common=androidx.lifecycle:lifecycle-common-jvm:2.8.5
+     * org.jetbrains.androidx.lifecycle:lifecycle-runtime=androidx.lifecycle:lifecycle-runtime-desktop:2.8.5
+     * org.jetbrains.androidx.lifecycle:lifecycle-viewmodel=androidx.lifecycle:lifecycle-viewmodel-desktop:2.8.5
+     *
+     * It is workaround for
+     * https://youtrack.jetbrains.com/issue/CMP-7764/Redirection-of-artifacts-breaks-poms-for-multiplatform-libraries-that-use-them
+     * After it is resolved, externalWithHeuristic shouldn't be needed.
+     */
+    val externalWithHeuristic = mainConfiguration()
+        .resolvedConfiguration
+        .firstLevelModuleDependencies
+        .orEmpty()
+        .associateBy { DefaultModuleIdentifier.newId(it.moduleGroup, it.moduleName) }
+        .mapValuesNotNull { it.value.findRedirectedDependencyHeuristically()?.module?.id }
+
+    return projectDefined + externalWithHeuristic
+}

buildSrc/public/src/main/kotlin/androidx/build/jetbrains/ArtifactRedirecting.kt

@@ -22,7 +22,11 @@ data class ArtifactRedirecting(
     val groupId: String,
     val defaultVersion: String,
     val targetNames: Set<String>,
-    val targetVersions: Map<String, String>
+
+    /**
+     * Versions for specific targets. If not specified, [defaultVersion] is used.
+     */
+    val targetVersions: Map<String, String> = emptyMap()
 ) {
     fun versionForTargetOrDefault(target: String): String {
         return targetVersions[target.lowercase()] ?: defaultVersion

collection/collection-compatibility-stub/build.gradle

@@ -66,7 +66,7 @@ kotlin {
         commonMain {
             dependencies {
                 api(libs.kotlinStdlib)
-                api("androidx.collection:collection:1.5.0-beta02")
+                api("androidx.collection:collection:1.5.0")
             }
         }
 

compose/foundation/foundation/build.gradle

@@ -108,7 +108,6 @@ if (AndroidXComposePlugin.isMultiplatformEnabled(project)) {
                 implementation(libs.kotlinStdlib)
                 implementation(project(":annotation:annotation"))
                 implementation(project(":collection:collection"))
-                implementation(project(":performance:performance-annotation"))
                 api(project(':compose:animation:animation'))
                 api(project(':compose:runtime:runtime'))
                 api(project(':compose:ui:ui'))

compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/text/input/internal/TextInputSession.skiko.kt

@@ -57,20 +57,22 @@ internal actual suspend fun PlatformTextInputSession.platformSpecificTextInputSe
             value = state.untransformedText.toTextFieldValue(),
             textInputSession = null
         )
-
         val newValue = editProcessor.apply(commands)
 
-        state.replaceAll(newValue.text)
         state.editUntransformedTextAsUser {
-            val untransformedSelection = state.mapFromTransformed(newValue.selection)
-            setSelectionCoerced(untransformedSelection.start, untransformedSelection.end)
+            // Update text
+            replace(0, length, newValue.text)
+
+            // Update selection
+            val selection = newValue.selection
+            setSelectionCoerced(selection.start, selection.end)
 
+            // Update composition
             val composition = newValue.composition
             if (composition == null) {
                 commitComposition()
             } else {
-                val untransformedComposition = state.mapFromTransformed(composition)
-                setComposition(untransformedComposition.start, untransformedComposition.end)
+                setComposition(composition.start, composition.end)
             }
         }
     }