[JS IR] Properly report compiler errors

Report compiler errors using message collector
Instead of crashing with stack trace

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -31,10 +31,7 @@ import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer
-import org.jetbrains.kotlin.ir.backend.js.compile
+import org.jetbrains.kotlin.ir.backend.js.*
-import org.jetbrains.kotlin.ir.backend.js.generateKLib
-import org.jetbrains.kotlin.ir.backend.js.jsPhases
-import org.jetbrains.kotlin.ir.backend.js.jsResolveLibraries
 import org.jetbrains.kotlin.js.config.EcmaVersion
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
@@ -185,31 +182,39 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                 else
                     outputFilePath
 
-            generateKLib(
+            try {
-                project = config.project,
+                generateKLib(
-                files = sourcesFiles,
+                    project = config.project,
-                configuration = config.configuration,
+                    files = sourcesFiles,
-                allDependencies = resolvedLibraries,
+                    configuration = config.configuration,
-                friendDependencies = friendDependencies,
+                    allDependencies = resolvedLibraries,
-                outputKlibPath = outputKlibPath,
+                    friendDependencies = friendDependencies,
-                nopack = arguments.irProduceKlibDir
+                    outputKlibPath = outputKlibPath,
-            )
+                    nopack = arguments.irProduceKlibDir
+                )
+            } catch (e: JsIrCompilationError) {
+                return COMPILATION_ERROR
+            }
         }
 
         if (arguments.irProduceJs) {
             val phaseConfig = createPhaseConfig(jsPhases, arguments, messageCollector)
 
-            val compiledModule = compile(
+            val compiledModule = try {
-                projectJs,
+                compile(
-                sourcesFiles,
+                    projectJs,
-                config.configuration,
+                    sourcesFiles,
-                phaseConfig,
+                    config.configuration,
-                allDependencies = resolvedLibraries,
+                    phaseConfig,
-                friendDependencies = friendDependencies,
+                    allDependencies = resolvedLibraries,
-                mainArguments = mainCallArguments,
+                    friendDependencies = friendDependencies,
-                generateFullJs = !arguments.irDce,
+                    mainArguments = mainCallArguments,
-                generateDceJs = arguments.irDce
+                    generateFullJs = !arguments.irDce,
-            )
+                    generateDceJs = arguments.irDce
+                )
+            } catch (e: JsIrCompilationError) {
+                return COMPILATION_ERROR
+            }
 
             val jsCode = if (arguments.irDce) compiledModule.dceJsCode!! else compiledModule.jsCode!!
             outputFile.writeText(jsCode)
@@ -370,7 +375,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 }
 
 fun messageCollectorLogger(collector: MessageCollector) = object : Logger {
-    override fun warning(message: String)= collector.report(STRONG_WARNING, message)
+    override fun warning(message: String) = collector.report(STRONG_WARNING, message)
     override fun error(message: String) = collector.report(ERROR, message)
     override fun log(message: String) = collector.report(LOGGING, message)
     override fun fatal(message: String): Nothing {

compiler/ir/serialization.js/build.gradle.kts

@@ -8,6 +8,7 @@ dependencies {
     compile(project(":compiler:ir.psi2ir"))
     compile(project(":compiler:ir.serialization.common"))
     compile(project(":js:js.frontend"))
+    compile(project(":compiler:cli"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
 

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

@@ -16,6 +16,9 @@ import org.jetbrains.kotlin.backend.common.serialization.KlibIrVersion
 import org.jetbrains.kotlin.backend.common.serialization.metadata.DynamicTypeDeserializer
 import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataVersion
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -256,6 +259,8 @@ fun getModuleDescriptorByLibrary(current: KotlinLibrary, mapping: Map<String, Mo
     return md
 }
 
+object JsIrCompilationError : Throwable()
+
 private class ModulesStructure(
     private val project: Project,
     private val files: List<KtFile>,
@@ -278,7 +283,14 @@ private class ModulesStructure(
     val builtInsDep = allDependencies.getFullList().find { it.isBuiltIns }
 
     fun runAnalysis(): JsAnalysisResult {
-        val analysisResult =
+        val messageCollector: MessageCollector =
+            compilerConfiguration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY) ?: MessageCollector.NONE
+        val analyzerWithCompilerReport = AnalyzerWithCompilerReport(
+            messageCollector,
+            compilerConfiguration.languageVersionSettings
+        )
+
+        analyzerWithCompilerReport.analyzeAndReport(files) {
             TopDownAnalyzerFacadeForJSIR.analyzeFiles(
                 files,
                 project,
@@ -288,6 +300,12 @@ private class ModulesStructure(
                 thisIsBuiltInsModule = builtInModuleDescriptor == null,
                 customBuiltInsModule = builtInModuleDescriptor
             )
+        }
+
+        val analysisResult = analyzerWithCompilerReport.analysisResult
+
+        if (analyzerWithCompilerReport.hasErrors() || analysisResult !is JsAnalysisResult)
+            throw JsIrCompilationError
 
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
         TopDownAnalyzerFacadeForJSIR.checkForErrors(files, analysisResult.bindingContext)