Use task's logger where appropriate

KT-28836

Using project's logger prevents messages
from showing in task's output (in command-line and build scans)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleCompilerRunnerWithWorkers.kt

@@ -16,7 +16,7 @@ internal class GradleCompilerRunnerWithWorkers(
     private val workersExecutor: WorkerExecutor
 ) : GradleCompilerRunner(task) {
     override fun runCompilerAsync(workArgs: GradleKotlinCompilerWorkArguments) {
-        project.logger.kotlinDebug { "Starting Kotlin compiler work from task '${task.path}'" }
+        task.logger.kotlinDebug { "Starting Kotlin compiler work from task '${task.path}'" }
         // todo: write tests with Workers enabled;
         workersExecutor.submit(GradleKotlinCompilerWork::class.java) { config ->
             config.isolationMode = IsolationMode.NONE

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerRunner.kt

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.cli.common.arguments.K2MetadataCompilerArguments
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.daemon.client.CompileServiceSession
 import org.jetbrains.kotlin.daemon.common.*
+import org.jetbrains.kotlin.gradle.plugin.TaskLoggers
 import org.jetbrains.kotlin.gradle.plugin.kotlinDebug
 import org.jetbrains.kotlin.gradle.tasks.*
 import org.jetbrains.kotlin.gradle.utils.newTmpFile
@@ -121,7 +122,7 @@ internal open class GradleCompilerRunner(protected val task: Task) {
         buildFile: File? = null
     ) {
         if (compilerArgs.version) {
-            project.logger.lifecycle(
+            task.logger.lifecycle(
                 "Kotlin version " + loadCompilerVersion(environment.compilerClasspath) +
                         " (JRE " + System.getProperty("java.runtime.version") + ")"
             )
@@ -139,8 +140,10 @@ internal open class GradleCompilerRunner(protected val task: Task) {
             incrementalCompilationEnvironment = incrementalCompilationEnvironment,
             incrementalModuleInfo = modulesInfo,
             buildFile = buildFile,
-            localStateDirectories = environment.localStateDirectories
+            localStateDirectories = environment.localStateDirectories,
+            taskPath = task.path
         )
+        TaskLoggers.put(task.path, task.logger)
         runCompilerAsync(workArgs)
     }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerWork.kt

@@ -56,7 +56,8 @@ internal class GradleKotlinCompilerWorkArguments(
     val incrementalCompilationEnvironment: IncrementalCompilationEnvironment?,
     val incrementalModuleInfo: IncrementalModuleInfo?,
     val buildFile: File?,
-    val localStateDirectories: List<File>
+    val localStateDirectories: List<File>,
+    val taskPath: String
 ) : Serializable {
     companion object {
         const val serialVersionUID: Long = 0
@@ -84,9 +85,14 @@ internal class GradleKotlinCompilerWork @Inject constructor(
     private val incrementalModuleInfo = config.incrementalModuleInfo
     private val buildFile = config.buildFile
     private val localStateDirectories = config.localStateDirectories
+    private val taskPath = config.taskPath
 
     private val log: KotlinLogger =
-        SL4JKotlinLogger(LoggerFactory.getLogger("GradleKotlinCompilerWork"))
+        TaskLoggers.get(taskPath)?.let { GradleKotlinLogger(it) }
+            ?: run {
+                System.err.println("Could not get logger for '$taskPath'. Falling back to sl4j logger")
+                SL4JKotlinLogger(LoggerFactory.getLogger("GradleKotlinCompilerWork"))
+            }
     private val messageCollector = GradleMessageCollector(log)
 
     private val isIncremental: Boolean

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinGradleBuildServices.kt

@@ -66,6 +66,7 @@ internal class KotlinGradleBuildServices private constructor(gradle: Gradle) : B
     // but it is called before any plugin can attach build listener
     fun buildStarted() {
         startMemory = getUsedMemoryKb()
+        TaskLoggers.clear()
     }
 
     override fun buildFinished(result: BuildResult) {
@@ -97,6 +98,7 @@ internal class KotlinGradleBuildServices private constructor(gradle: Gradle) : B
             log.lifecycle("[KOTLIN][PERF] Used memory after build: $endMem kb (difference since build start: ${"%+d".format(endMem - startMem)} kb)")
         }
 
+        TaskLoggers.clear()
         gradle.removeListener(this)
         instance = null
         log.kotlinDebug(DISPOSE_MESSAGE)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinMultiplatformPlugin.kt

@@ -84,11 +84,11 @@ open class KotlinPlatformImplementationPluginBase(platformName: String) : Kotlin
 
         val incrementalMultiplatform = PropertiesProvider(project).incrementalMultiplatform ?: true
         project.afterEvaluate {
-            project.tasks.withType(AbstractKotlinCompile::class.java).all {
+            project.tasks.withType(AbstractKotlinCompile::class.java).all { task ->
-                if (it.incremental && !incrementalMultiplatform) {
+                if (task.incremental && !incrementalMultiplatform) {
-                    project.logger.debug("IC is turned off for task '${it.path}' because multiplatform IC is not enabled")
+                    task.logger.debug("IC is turned off for task '${task.path}' because multiplatform IC is not enabled")
                 }
-                it.incremental = it.incremental && incrementalMultiplatform
+                task.incremental = task.incremental && incrementalMultiplatform
             }
         }
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/TaskLoggers.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.plugin
+
+import org.gradle.api.logging.Logger
+import java.lang.ref.WeakReference
+import java.util.HashMap
+
+// todo: remove when https://github.com/gradle/gradle/issues/2678 is resolved
+object TaskLoggers {
+    private val taskLoggers = HashMap<String, WeakReference<Logger>>()
+
+    @Synchronized
+    fun put(path: String, logger: Logger) {
+        taskLoggers[path] = WeakReference(logger)
+    }
+
+    @Synchronized
+    fun get(path: String): Logger? =
+        taskLoggers[path]?.get()
+
+    @Synchronized
+    fun clear() {
+        taskLoggers.clear()
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/scripting/internal/ScriptingGradleSubplugin.kt

@@ -91,14 +91,14 @@ open class DiscoverScriptExtensionsTask : DefaultTask() {
         val definitions =
             ScriptDefinitionsFromClasspathDiscoverySource(
                 scriptingClasspath.toList(), emptyMap(),
-                GradleMessageCollector(project.logger)
+                GradleMessageCollector(logger)
             ).definitions
         val extensions = definitions.mapTo(arrayListOf(), KotlinScriptDefinition::fileExtension)
         val kotlinSourceSet = sourceSet.getConvention(KOTLIN_DSL_NAME) as? KotlinSourceSet
         if (kotlinSourceSet == null) {
-            project.logger.warn("kotlin scripting plugin: kotlin source set not found: $project.$sourceSet")
+            logger.warn("kotlin scripting plugin: kotlin source set not found: $project.$sourceSet")
         } else if (extensions.isNotEmpty()) {
-            project.logger.info("kotlin scripting plugin: Add new extensions to the sourceset $project.$sourceSet: $extensions")
+            logger.info("kotlin scripting plugin: Add new extensions to the sourceset $project.$sourceSet: $extensions")
             kotlinSourceSet.kotlin.filter.include(extensions.map { "**/*.$it" })
         }
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/KotlinJsDce.kt

@@ -73,7 +73,7 @@ open class KotlinJsDce : AbstractKotlinCompileTool<K2JSDceArguments>(), KotlinJs
 
         val argsArray = serializedCompilerArguments.toTypedArray()
 
-        val log = GradleKotlinLogger(project.logger)
+        val log = GradleKotlinLogger(logger)
         val allArgs = argsArray + outputDirArgs + inputFiles
         val exitCode = runToolInSeparateProcess(
             allArgs, K2JSDce::class.java.name, computedCompilerClasspath,

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt

@@ -50,7 +50,7 @@ const val USING_JS_INCREMENTAL_COMPILATION_MESSAGE = "Using Kotlin/JS incrementa
 
 abstract class AbstractKotlinCompileTool<T : CommonToolArguments>() : AbstractCompile(), CompilerArgumentAwareWithInput<T> {
     private fun useCompilerClasspathConfigurationMessage(propertyName: String) {
-        project.logger.kotlinWarn(
+        logger.kotlinWarn(
             "'$path.$propertyName' is deprecated and will be removed soon. " +
                     "Use '$COMPILER_CLASSPATH_CONFIGURATION_NAME' " +
                     "configuration for customizing compiler classpath."
@@ -94,7 +94,7 @@ abstract class AbstractKotlinCompileTool<T : CommonToolArguments>() : AbstractCo
                 try {
                     project.configurations.getByName(COMPILER_CLASSPATH_CONFIGURATION_NAME).resolve().toList()
                 } catch (e: Exception) {
-                    project.logger.error(
+                    logger.error(
                         "Could not resolve compiler classpath. " +
                                 "Check if Kotlin Gradle plugin repository is configured in $project."
                     )
@@ -296,7 +296,7 @@ abstract class AbstractKotlinCompile<T : CommonCompilerArguments>() : AbstractKo
 
         logger.kotlinDebug { "args.coroutinesState=${args.coroutinesState}" }
 
-        if (project.logger.isDebugEnabled) {
+        if (logger.isDebugEnabled) {
             args.verbose = true
         }
 
@@ -428,7 +428,7 @@ open class KotlinCompile : AbstractKotlinCompile<K2JVMCompilerArguments>(), Kotl
         }.firstOrNull() as? AbstractCompile
 
         if (illegalTask != null) {
-            project.logger.info(
+            logger.info(
                 "Kotlin inter-project IC is disabled: " +
                         "unknown task '$illegalTask' destination dir ${illegalTask.destinationDir} " +
                         "intersects with java destination dir $javaOutputDir"
@@ -577,7 +577,7 @@ private fun Task.getGradleVersion(): ParsedGradleVersion? {
     val gradleVersion = project.gradle.gradleVersion
     val result = ParsedGradleVersion.parse(gradleVersion)
     if (result == null) {
-        project.logger.kotlinDebug("Could not parse gradle version: $gradleVersion")
+        logger.kotlinDebug("Could not parse gradle version: $gradleVersion")
     }
     return result
 }