(CoroutineDebugger) fails to start in gradle mode

#KT-39634 fixed

idea/idea-gradle/src/org/jetbrains/kotlin/idea/configuration/KotlinGradleCoroutineDebugProjectResolver.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.idea.configuration
 
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.util.Consumer
+import org.jetbrains.kotlin.idea.debugger.KotlinDebuggerSettings
 import org.jetbrains.plugins.gradle.service.project.AbstractProjectResolverExtension
 
 class KotlinGradleCoroutineDebugProjectResolver : AbstractProjectResolverExtension() {
@@ -14,7 +15,9 @@ class KotlinGradleCoroutineDebugProjectResolver : AbstractProjectResolverExtensi
 
     override fun enhanceTaskProcessing(taskNames: MutableList<String>, jvmParametersSetup: String?, initScriptConsumer: Consumer<String>) {
         try {
-            setupCoroutineAgentForJvmForkedTestTasks(initScriptConsumer)
+            val disableCoroutineAgent = KotlinDebuggerSettings.getInstance().debugDisableCoroutineAgent
+            if (!disableCoroutineAgent)
+                setupCoroutineAgentForJvmForkedTestTasks(initScriptConsumer)
         } catch (e: Exception) {
             log.error("Gradle: not possible to attach a coroutine debugger agent.", e)
         }
@@ -25,11 +28,22 @@ class KotlinGradleCoroutineDebugProjectResolver : AbstractProjectResolverExtensi
             //language=Gradle
             """
             gradle.taskGraph.beforeTask { Task task ->
-              if (task instanceof Test) {
-                def kotlinxCoroutinesDebugJar = task.classpath.find { it.name.startsWith("kotlinx-coroutines-debug") }
-                if (kotlinxCoroutinesDebugJar)
-                    task.jvmArgs ("-javaagent:${'$'}{kotlinxCoroutinesDebugJar?.absolutePath}", "-ea")
-              }
+                if (task instanceof Test) {
+                    def kotlinxCoroutinesDebugJar = task.classpath.find { it.name.startsWith("kotlinx-coroutines-debug") }
+                    if (kotlinxCoroutinesDebugJar)
+                        task.jvmArgs ("-javaagent:${'$'}{kotlinxCoroutinesDebugJar?.absolutePath}", "-ea")
+                    else {
+                        for (lib in task.getClasspath()) {
+                            def results = (lib.getName() =~ /kotlinx-coroutines-core\-([\d\.]+)\.jar${'$'}/).findAll()
+                            if (results) {
+                                def version = results.first()[1]
+                                if (org.gradle.util.VersionNumber.parse( version ) >= org.gradle.util.VersionNumber.parse( '1.3.6' )) {
+                                    task.jvmArgs ("-javaagent:${'$'}{lib?.absolutePath}", "-ea")
+                                }
+                            }
+                        }
+                    }
+                }
             }
             """.trimIndent()
         initScriptConsumer.consume(script)

idea/jvm-debugger/jvm-debugger-coroutine/src/org/jetbrains/kotlin/idea/debugger/coroutine/DebuggerConnection.kt

@@ -33,14 +33,15 @@ class DebuggerConnection(
     val project: Project,
     val configuration: RunConfigurationBase<*>,
     val params: JavaParameters?,
-    val runnerSettings: DebuggingRunnerData?
+    val runnerSettings: DebuggingRunnerData?,
+    modifyArgs: Boolean = true
 ) : XDebuggerManagerListener {
     var disposable: Disposable? = null
     var connection: MessageBusConnection? = null
     private val log by logger
 
     init {
-        if (params is JavaParameters) {
+        if (params is JavaParameters && modifyArgs) {
             // gradle related logic in KotlinGradleCoroutineDebugProjectResolver
             val kotlinxCoroutinesCore = params.classPath?.pathList?.firstOrNull { it.contains("kotlinx-coroutines-core") }
             val kotlinxCoroutinesDebug = params.classPath?.pathList?.firstOrNull { it.contains("kotlinx-coroutines-debug") }

idea/jvm-debugger/jvm-debugger-coroutine/src/org/jetbrains/kotlin/idea/debugger/coroutine/DebuggerListener.kt

@@ -34,12 +34,16 @@ class CoroutineDebuggerListener(val project: Project) : DebuggerListener {
         val isExternalSystemRunConfiguration = configuration is ExternalSystemRunConfiguration
         val isGradleConfiguration = gradleConfiguration(configuration.type.id)
         val disableCoroutineAgent = KotlinDebuggerSettings.getInstance().debugDisableCoroutineAgent
-        if (!disableCoroutineAgent && runnerSettings is DebuggingRunnerData && !isExternalSystemRunConfiguration && !isGradleConfiguration)
-            return DebuggerConnection(project, configuration, params, runnerSettings)
+        if (!disableCoroutineAgent && runnerSettings is DebuggingRunnerData) {
+            if (isExternalSystemRunConfiguration && isGradleConfiguration)
+                // gradle related logic in KotlinGradleCoroutineDebugProjectResolver
+                return DebuggerConnection(project, configuration, params, runnerSettings, false)
+            else
+                return DebuggerConnection(project, configuration, params, runnerSettings, true)
+        }
         return null
     }
 
     private fun gradleConfiguration(configurationName: String) =
         "GradleRunConfiguration" == configurationName || "KotlinGradleRunConfiguration" == configurationName
-
 }