[KLIB Resolver] Report KLIB resolver issues as compiler messages

The reason of this change is to make messages (especially warnings)
that are reported by the KLIB resolver become visible to the end user.
This can be achieved to forwarding such messages to the appropriate
compiler's components such as
`org.jetbrains.kotlin.cli.common.messages.MessageCollector` and
`org.jetbrains.kotlin.ir.util.IrMessageLogger`.

Also: The default `DummyLogger` should be used as minimal as possible.
Because it just forwards messages to the standard output (console)
where they can remain unattended. When the compiler is executed
from the Gradle plugin such messages appear only in DEBUG Gradle's log.

^KT-63573

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/CompilerLoggerAdapter.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.cli.common.messages
+
+import org.jetbrains.kotlin.analyzer.CompilationErrorException
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.util.Logger
+
+/**
+ * An adapter for the [Logger] interface that reports all messages to compiler's [MessageCollector].
+ *
+ * @property messageCollector - The destination for the messages.
+ * @property treatWarningsAsErrors - Whether to treat warnings as errors. Can be used in tests.
+ */
+private class CompilerLoggerAdapter(
+    private val messageCollector: MessageCollector,
+    private val treatWarningsAsErrors: Boolean
+) : Logger {
+    override fun log(message: String) = messageCollector.report(LOGGING, message, null)
+    override fun warning(message: String) = messageCollector.report(if (treatWarningsAsErrors) ERROR else STRONG_WARNING, message, null)
+    override fun error(message: String) = messageCollector.report(ERROR, message, null)
+
+    override fun fatal(message: String): Nothing {
+        error(message)
+        (messageCollector as? GroupingMessageCollector)?.flush()
+        throw CompilationErrorException()
+    }
+}
+
+fun MessageCollector.toLogger(treatWarningsAsErrors: Boolean = false): Logger =
+    CompilerLoggerAdapter(this, treatWarningsAsErrors)
+
+fun CompilerConfiguration.getLogger(treatWarningsAsErrors: Boolean = false): Logger =
+    getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).toLogger(treatWarningsAsErrors)

compiler/cli/src/org/jetbrains/kotlin/cli/common/utils.kt

@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.text
 import org.jetbrains.kotlin.util.Logger
 import java.io.File
-import kotlin.system.exitProcess
+import org.jetbrains.kotlin.cli.common.messages.toLogger as toLoggerNew
 
 fun incrementalCompilationIsEnabled(arguments: CommonCompilerArguments): Boolean {
     return arguments.incrementalCompilation ?: IncrementalCompilation.isEnabledForJvm()
@@ -127,23 +127,9 @@ fun <PathProvider : Any> getLibraryFromHome(
     return null
 }
 
-fun MessageCollector.toLogger(): Logger =
-    object : Logger {
-        override fun error(message: String) {
-            report(CompilerMessageSeverity.ERROR, message)
-        }
-
-        override fun fatal(message: String): Nothing {
-            report(CompilerMessageSeverity.ERROR, message)
-            exitProcess(1)
-        }
-
-        override fun warning(message: String) {
-            report(CompilerMessageSeverity.WARNING, message)
-        }
-
-        override fun log(message: String) {
-            report(CompilerMessageSeverity.LOGGING, message)
-        }
-    }
-
+@Deprecated(
+    "Use org.jetbrains.kotlin.cli.common.messages.toLogger() instead",
+    ReplaceWith("toLogger()", "org.jetbrains.kotlin.cli.common.messages.toLogger"),
+    DeprecationLevel.ERROR
+)
+fun MessageCollector.toLogger(): Logger = toLoggerNew()

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.cli.common.checkKotlinPackageUsageForPsi
 import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
 import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
-import org.jetbrains.kotlin.cli.common.toLogger
+import org.jetbrains.kotlin.cli.common.messages.toLogger
 import org.jetbrains.kotlin.cli.jvm.compiler.FirKotlinToJvmBytecodeCompiler.runFrontend
 import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.convertToIrAndActualizeForJvm
 import org.jetbrains.kotlin.cli.jvm.config.*

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/FirMetadataSerializer.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
 import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.cli.common.*
 import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter
+import org.jetbrains.kotlin.cli.common.messages.toLogger
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.VfsBasedProjectEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.createContextForIncrementalCompilation
@@ -43,7 +44,6 @@ import org.jetbrains.kotlin.library.metadata.KlibMetadataProtoBuf
 import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.CommonPlatforms
-import org.jetbrains.kotlin.util.DummyLogger
 import java.io.File
 
 internal class FirMetadataSerializer(
@@ -78,7 +78,7 @@ internal class FirMetadataSerializer(
             .filterIsInstance<JvmClasspathRoot>()
             .filter { it.file.isDirectory || it.file.extension == "klib" }
             .map { it.file.absolutePath }
-        val resolvedLibraries = CommonKLibResolver.resolve(klibFiles, DummyLogger).getFullResolvedList()
+        val resolvedLibraries = CommonKLibResolver.resolve(klibFiles, messageCollector.toLogger()).getFullResolvedList()
 
         val outputs = if (isLightTree) {
             val projectEnvironment = environment.toAbstractProjectEnvironment() as VfsBasedProjectEnvironment

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataKlibSerializer.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
 import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataMonolithicSerializer
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
@@ -34,6 +35,7 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.utils.keysToMap
 import java.io.File
+import org.jetbrains.kotlin.konan.file.File as KFile
 
 internal class K2MetadataKlibSerializer(
     configuration: CompilerConfiguration,
@@ -78,8 +80,8 @@ private class KlibMetadataDependencyContainer(
         val klibFiles = classpathFiles
             .filter { it.extension == "klib" || it.isDirectory }
 
-        // TODO: need to move K2Metadata to SearchPathResolver.
-        klibFiles.map { resolveSingleFileKlib(org.jetbrains.kotlin.konan.file.File(it.absolutePath)) }
+        val logger = configuration.getLogger()
+        klibFiles.map { resolveSingleFileKlib(KFile(it.absolutePath), logger) }
     }
 
     private val friendPaths = configuration.get(K2MetadataConfigurationKeys.FRIEND_PATHS).orEmpty().toSet()

compiler/fir/analysis-tests/test/org/jetbrains/kotlin/test/LoadedMetadataDumpHandler.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFileManager
 import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.cli.common.SessionWithSources
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.cli.common.prepareJsSessions
 import org.jetbrains.kotlin.cli.common.prepareJvmSessions
 import org.jetbrains.kotlin.cli.jvm.compiler.VfsBasedProjectEnvironment
@@ -53,7 +54,6 @@ import org.jetbrains.kotlin.test.services.*
 import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndRemoveRedundantEmptyLinesAtTheEnd
 import org.jetbrains.kotlin.test.utils.MultiModuleInfoDumper
 import org.jetbrains.kotlin.test.utils.withExtension
-import org.jetbrains.kotlin.util.DummyLogger
 import org.jetbrains.kotlin.utils.addToStdlib.shouldNotBeCalled
 import java.io.File
 
@@ -107,7 +107,11 @@ class KlibLoadedMetadataDumpHandler(testServices: TestServices) : AbstractLoaded
         libraryList: DependencyListForCliModule,
     ): List<SessionWithSources<KtFile>> {
         val libraries = getAllJsDependenciesPaths(module, testServices)
-        val resolvedLibraries = CommonKLibResolver.resolve(libraries, DummyLogger).getFullResolvedList()
+        val resolvedLibraries = CommonKLibResolver.resolve(
+            libraries,
+            configuration.getLogger(treatWarningsAsErrors = true)
+        ).getFullResolvedList()
+
         return prepareJsSessions(
             files = emptyList(),
             configuration,

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheUpdater.kt

@@ -8,6 +8,7 @@ import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.common.serialization.IrInterningService
 import org.jetbrains.kotlin.backend.common.serialization.cityHash64String
+import org.jetbrains.kotlin.backend.common.toLogger
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.ir.backend.js.*
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.JsGenerationGranularity
@@ -91,7 +92,11 @@ class CacheUpdater(
         // libraries in topological order: [stdlib, ..., main]
         val libraryDependencies = stopwatch.measure("Resolving and loading klib dependencies") {
             val zipAccessor = compilerConfiguration.get(JSConfigurationKeys.ZIP_FILE_SYSTEM_ACCESSOR)
-            val allResolvedDependencies = CommonKLibResolver.resolve(allModules, compilerConfiguration.resolverLogger, zipAccessor)
+            val allResolvedDependencies = CommonKLibResolver.resolve(
+                allModules,
+                compilerConfiguration.irMessageLogger.toLogger(),
+                zipAccessor
+            )
 
             val libraries = allResolvedDependencies.getFullList(TopologicalLibraryOrder).let { resolvedLibraries ->
                 val mainLibraryIndex = resolvedLibraries.indexOfLast {

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/IrMessageLoggerAdapter.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.backend.common
+
+import org.jetbrains.kotlin.analyzer.CompilationErrorException
+import org.jetbrains.kotlin.ir.util.IrMessageLogger
+import org.jetbrains.kotlin.ir.util.IrMessageLogger.Severity.*
+import org.jetbrains.kotlin.util.DummyLogger
+import org.jetbrains.kotlin.util.Logger
+
+/**
+ * An adapter for the [Logger] interface that reports all messages to compiler's [IrMessageLogger].
+ */
+private class IrMessageLoggerAdapter(private val irMessageLogger: IrMessageLogger) : Logger {
+    override fun log(message: String) = irMessageLogger.report(INFO, message, null)
+    override fun warning(message: String) = irMessageLogger.report(WARNING, message, null)
+    override fun error(message: String) = irMessageLogger.report(ERROR, message, null)
+
+    override fun fatal(message: String): Nothing {
+        error(message)
+        throw CompilationErrorException()
+    }
+}
+
+fun IrMessageLogger.toLogger(): Logger {
+    return if (this != IrMessageLogger.None) IrMessageLoggerAdapter(this) else DummyLogger
+}

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.backend.common.serialization.mangle.ManglerChecker
 import org.jetbrains.kotlin.backend.common.serialization.mangle.descriptor.Ir2DescriptorManglerAdapter
 import org.jetbrains.kotlin.backend.common.serialization.metadata.*
 import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor
+import org.jetbrains.kotlin.backend.common.toLogger
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -70,8 +71,6 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingContextUtils
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.util.DummyLogger
-import org.jetbrains.kotlin.util.Logger
 import org.jetbrains.kotlin.utils.DFS
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 import org.jetbrains.kotlin.utils.memoryOptimizedFilter
@@ -103,21 +102,6 @@ private val CompilerConfiguration.metadataVersion
 internal val SerializedIrFile.fileMetadata: ByteArray
     get() = backendSpecificMetadata ?: error("Expect file caches to have backendSpecificMetadata, but '$path' doesn't")
 
-val CompilerConfiguration.resolverLogger: Logger
-    get() = when (val messageLogger = this[IrMessageLogger.IR_MESSAGE_LOGGER]) {
-        null -> DummyLogger
-        else -> object : Logger {
-            override fun log(message: String) = messageLogger.report(IrMessageLogger.Severity.INFO, message, null)
-            override fun error(message: String) = messageLogger.report(IrMessageLogger.Severity.ERROR, message, null)
-            override fun warning(message: String) = messageLogger.report(IrMessageLogger.Severity.WARNING, message, null)
-
-            override fun fatal(message: String): Nothing {
-                messageLogger.report(IrMessageLogger.Severity.ERROR, message, null)
-                throw CompilationErrorException()
-            }
-        }
-    }
-
 class KotlinFileSerializedData(val metadata: ByteArray, val irData: SerializedIrFile)
 
 fun generateKLib(
@@ -485,7 +469,7 @@ class ModulesStructure(
 
     val allDependenciesResolution = CommonKLibResolver.resolveWithoutDependencies(
         dependencies,
-        compilerConfiguration.resolverLogger,
+        compilerConfiguration.irMessageLogger.toLogger(),
         compilerConfiguration.get(JSConfigurationKeys.ZIP_FILE_SYSTEM_ACCESSOR)
     )
 

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForJSIR
 import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForWasm
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
@@ -44,7 +45,6 @@ import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.ir.backend.js.JsFactories
-import org.jetbrains.kotlin.ir.backend.js.resolverLogger
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.WasmTarget
@@ -281,7 +281,7 @@ class ClassicFrontendFacade(
     ): List<ModuleDescriptor> {
         val resolvedLibraries = CommonKLibResolver.resolve(
             names,
-            configuration.resolverLogger
+            configuration.getLogger(treatWarningsAsErrors = true)
         ).getFullResolvedList()
 
         var builtInsModule: KotlinBuiltIns? = null

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/SessionFactoryHelpers.kt

@@ -6,8 +6,8 @@
 package org.jetbrains.kotlin.test.frontend.fir
 
 import org.jetbrains.kotlin.backend.common.CommonKLibResolver
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.ir.backend.js.resolverLogger
 import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
 import org.jetbrains.kotlin.test.model.DependencyRelation
 import org.jetbrains.kotlin.test.model.TestModule
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.test.services.configuration.getKlibDependencies
 import java.io.File
 
 fun resolveLibraries(configuration: CompilerConfiguration, paths: List<String>): List<KotlinResolvedLibrary> {
-    return CommonKLibResolver.resolve(paths, configuration.resolverLogger).getFullResolvedList()
+    return CommonKLibResolver.resolve(paths, configuration.getLogger()).getFullResolvedList()
 }
 
 fun getTransitivesAndFriendsPaths(module: TestModule, testServices: TestServices): List<String> {

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirWasmSessionFactory.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.session.FirSessionConfigurator
 import org.jetbrains.kotlin.fir.session.FirWasmSessionFactory
 import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.ir.backend.js.resolverLogger
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.WasmTarget
 import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -16,9 +16,7 @@ import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.backend.jvm.JvmIrDeserializerImpl
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.GroupingMessageCollector
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.cli.common.output.writeAllTo
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
@@ -42,8 +40,6 @@ import org.jetbrains.kotlin.resolve.AnalyzingUtils
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.FirParser
-import org.jetbrains.kotlin.util.DummyLogger
-import org.jetbrains.kotlin.util.Logger
 import java.io.File
 
 object GenerationUtils {
@@ -160,17 +156,6 @@ object GenerationUtils {
         return generationState
     }
 
-    fun messageCollectorLogger(collector: MessageCollector) = object : Logger {
-        override fun warning(message: String) = collector.report(CompilerMessageSeverity.STRONG_WARNING, message)
-        override fun error(message: String) = collector.report(CompilerMessageSeverity.ERROR, message)
-        override fun log(message: String) = collector.report(CompilerMessageSeverity.LOGGING, message)
-        override fun fatal(message: String): Nothing {
-            collector.report(CompilerMessageSeverity.ERROR, message)
-            (collector as? GroupingMessageCollector)?.flush()
-            kotlin.error(message)
-        }
-    }
-
     private fun compileFilesUsingStandardMode(
         project: Project,
         files: List<KtFile>,
@@ -179,10 +164,8 @@ object GenerationUtils {
         packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
         trace: BindingTrace
     ): GenerationState {
-        val logger = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)?.let { messageCollectorLogger(it) }
-            ?: DummyLogger
         val resolvedKlibs = configuration.get(JVMConfigurationKeys.KLIB_PATHS)?.let { klibPaths ->
-            jvmResolveLibraries(klibPaths, logger)
+            jvmResolveLibraries(klibPaths, configuration.getLogger(treatWarningsAsErrors = true))
         }
 
         val analysisResult =

compiler/util-io/src/org/jetbrains/kotlin/util/WithLogger.kt

@@ -13,6 +13,18 @@ interface WithLogger {
     val logger: Logger
 }
 
+/**
+ * The default logger that just prints messages to console.
+ *
+ * Caution: Whenever possible please try to use more appropriate alternatives to [DummyLogger] that
+ * would direct the output to the proper logs. Here are some of them:
+ * - [org.jetbrains.kotlin.gradle.utils.GradleLoggerAdapter] - to be used in Gradle plugins.
+ * - [org.jetbrains.kotlin.cli.common.messages.CompilerLoggerAdapter] - to be used in all flavors of the Kotlin compiler. Can be accessed
+ *   via [org.jetbrains.kotlin.cli.common.messages.toLogger] and [org.jetbrains.kotlin.cli.common.messages.getLogger].
+ * - [org.jetbrains.kotlin.backend.common.IrMessageLoggerAdapter] - to be used in those parts of the compiler where
+ *   [org.jetbrains.kotlin.cli.common.messages.CompilerLoggerAdapter] is not available. Can be accessed via
+ *   [org.jetbrains.kotlin.backend.common.toLogger].
+ */
 object DummyLogger : Logger {
     override fun log(message: String) = println(message)
     override fun error(message: String) = println("e: $message")

compiler/util-klib/src/org/jetbrains/kotlin/library/SingleFileResolve.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.library
 
 import org.jetbrains.kotlin.konan.file.File
+import org.jetbrains.kotlin.util.DummyLogger
 import org.jetbrains.kotlin.util.Logger
 
 interface SingleFileKlibResolveStrategy {
@@ -14,11 +15,6 @@ interface SingleFileKlibResolveStrategy {
 
 fun resolveSingleFileKlib(
     libraryFile: File,
-    logger: Logger = object : Logger {
-        override fun log(message: String) {}
-        override fun error(message: String) = kotlin.error("e: $message")
-        override fun warning(message: String) {}
-        override fun fatal(message: String) = kotlin.error("e: $message")
-    },
+    logger: Logger = DummyLogger,
     strategy: SingleFileKlibResolveStrategy = CompilerSingleFileKlibResolveStrategy
 ): KotlinLibrary = strategy.resolve(libraryFile, logger)

js/js.tests/test/org/jetbrains/kotlin/js/test/converters/FirJsKlibBackendFacade.kt

@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.js.test.converters
 
 import org.jetbrains.kotlin.backend.common.CommonKLibResolver
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.ir.backend.js.JsFactories
-import org.jetbrains.kotlin.ir.backend.js.resolverLogger
 import org.jetbrains.kotlin.ir.backend.js.serializeModuleIntoKlib
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.js.test.utils.JsIrIncrementalDataProvider
@@ -81,7 +81,7 @@ class FirJsKlibBackendFacade(
         // TODO: consider avoiding repeated libraries resolution
         val lib = CommonKLibResolver.resolve(
             getAllJsDependenciesPaths(module, testServices) + listOf(outputFile),
-            configuration.resolverLogger
+            configuration.getLogger(treatWarningsAsErrors = true)
         ).getFullResolvedList().last().library
 
         val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(

js/js.tests/test/org/jetbrains/kotlin/js/test/converters/JsKlibBackendFacade.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.js.test.converters
 
 import org.jetbrains.kotlin.backend.common.CommonKLibResolver
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -70,7 +71,7 @@ class JsKlibBackendFacade(
         val dependencies = JsEnvironmentConfigurator.getAllRecursiveDependenciesFor(module, testServices).toList()
         val lib = CommonKLibResolver.resolve(
             dependencies.map { testServices.libraryProvider.getPathByDescriptor(it) } + listOf(outputFile),
-            configuration.resolverLogger
+            configuration.getLogger(treatWarningsAsErrors = true)
         ).getFullResolvedList().last().library
 
         val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanLibrariesResolveSupport.kt

@@ -5,8 +5,7 @@
 
 package org.jetbrains.kotlin.backend.konan
 
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.konan.file.File
 import org.jetbrains.kotlin.konan.library.defaultResolver
@@ -15,7 +14,6 @@ import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.library.UnresolvedLibrary
 import org.jetbrains.kotlin.library.metadata.resolver.impl.libraryResolver
 import org.jetbrains.kotlin.library.toUnresolvedLibraries
-import org.jetbrains.kotlin.util.Logger
 
 class KonanLibrariesResolveSupport(
         configuration: CompilerConfiguration,
@@ -34,24 +32,13 @@ class KonanLibrariesResolveSupport(
     private val unresolvedLibraries = libraryNames.toUnresolvedLibraries
 
     private val repositories = configuration.getList(KonanConfigKeys.REPOSITORIES)
-    private val resolverLogger =
-            object : Logger {
-                private val collector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
-                override fun warning(message: String)= collector.report(CompilerMessageSeverity.STRONG_WARNING, message)
-                override fun error(message: String) = collector.report(CompilerMessageSeverity.ERROR, message)
-                override fun log(message: String) = collector.report(CompilerMessageSeverity.LOGGING, message)
-                override fun fatal(message: String): Nothing {
-                    collector.report(CompilerMessageSeverity.ERROR, message)
-                    throw KonanCompilationException()
-                }
-            }
 
     private val resolver = defaultResolver(
             repositories,
             libraryNames.filter { it.contains(File.separator) } + includedLibraryFiles.map { it.absolutePath },
             target,
             distribution,
-            resolverLogger
+            configuration.getLogger()
     ).libraryResolver(resolveManifestDependenciesLenient)
 
     // We pass included libraries by absolute paths to avoid repository-based resolution for them.

kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/konan/tasks/KonanCacheTask.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.gradle.plugin.konan.tasks
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.provider.Property
-import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
 import org.jetbrains.kotlin.gradle.plugin.konan.KonanCliCompilerRunner
 import org.jetbrains.kotlin.konan.library.defaultResolver
@@ -17,6 +16,7 @@ import org.jetbrains.kotlin.konan.target.Distribution
 import org.jetbrains.kotlin.konan.target.PlatformManager
 import org.jetbrains.kotlin.library.uniqueName
 import org.jetbrains.kotlin.*
+import org.jetbrains.kotlin.util.Logger
 import java.io.File
 
 enum class KonanCacheKind(val outputKind: CompilerOutputKind) {
@@ -54,9 +54,16 @@ abstract class KonanCacheTask : DefaultTask() {
     private fun readKlibUniqNameFromManifest(): String {
         val konanHome = compilerDistributionPath.get().absolutePath
         val resolver = defaultResolver(
-            emptyList(),
-            PlatformManager(konanHome).targetByName(target),
-            Distribution(konanHome)
+                repositories = emptyList(),
+                directLibs = emptyList(),
+                target = PlatformManager(konanHome).targetByName(target),
+                distribution = Distribution(konanHome),
+                logger = object : Logger {
+                    override fun log(message: String) = logger.info(message)
+                    override fun warning(message: String) = logger.warn(message)
+                    override fun error(message: String): Unit = logger.error(message)
+                    override fun fatal(message: String): Nothing = kotlin.error(message)
+                }
         )
         return resolver.resolve(originalKlib.asFile.get().absolutePath).uniqueName
     }

native/utils/src/org/jetbrains/kotlin/konan/library/SearchPathResolver.kt

@@ -1,7 +1,6 @@
 package org.jetbrains.kotlin.konan.library
 
 import org.jetbrains.kotlin.konan.file.File
-import org.jetbrains.kotlin.konan.library.impl.KonanLibraryImpl
 import org.jetbrains.kotlin.konan.library.impl.createKonanLibraryComponents
 import org.jetbrains.kotlin.konan.target.Distribution
 import org.jetbrains.kotlin.konan.target.KonanTarget
@@ -13,12 +12,6 @@ interface SearchPathResolverWithTarget<L: KotlinLibrary>: SearchPathResolver<L>
     val target: KonanTarget
 }
 
-fun defaultResolver(
-        repositories: List<String>,
-        target: KonanTarget,
-        distribution: Distribution
-): SearchPathResolverWithTarget<KonanLibrary> = defaultResolver(repositories, emptyList(), target, distribution)
-
 fun defaultResolver(
     repositories: List<String>,
     directLibs: List<String>,

wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/FirWasmKlibBackendFacade.kt

@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.wasm.test.converters
 
 import org.jetbrains.kotlin.backend.common.CommonKLibResolver
+import org.jetbrains.kotlin.cli.common.messages.getLogger
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.ir.backend.js.JsFactories
-import org.jetbrains.kotlin.ir.backend.js.resolverLogger
 import org.jetbrains.kotlin.ir.backend.js.serializeModuleIntoKlib
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
@@ -81,7 +81,7 @@ class FirWasmKlibBackendFacade(
         // TODO: consider avoiding repeated libraries resolution
         val lib = CommonKLibResolver.resolve(
             getAllWasmDependenciesPaths(module, testServices, target) + listOf(outputFile),
-            configuration.resolverLogger
+            configuration.getLogger(treatWarningsAsErrors = true)
         ).getFullResolvedList().last().library
 
         val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(