Refactor CompilationErrorHandler

It only had one implementation THROW_EXCEPTION, inline it everywhere
with a call to a static method

compiler/backend/src/org/jetbrains/kotlin/codegen/CodegenFactory.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStat
 import org.jetbrains.kotlin.psi.KtFile
 
 interface CodegenFactory {
-    fun generateModule(state: GenerationState, files: Collection<KtFile>, errorHandler: CompilationErrorHandler)
+    fun generateModule(state: GenerationState, files: Collection<KtFile>)
 
     fun createPackageCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName): PackageCodegen
 
@@ -40,7 +40,7 @@ interface CodegenFactory {
 }
 
 object DefaultCodegenFactory : CodegenFactory {
-    override fun generateModule(state: GenerationState, files: Collection<KtFile>, errorHandler: CompilationErrorHandler) {
+    override fun generateModule(state: GenerationState, files: Collection<KtFile>) {
         val filesInPackages = MultiMap<FqName, KtFile>()
         val filesInMultifileClasses = MultiMap<FqName, KtFile>()
 
@@ -58,13 +58,13 @@ object DefaultCodegenFactory : CodegenFactory {
         val obsoleteMultifileClasses = HashSet(state.obsoleteMultifileClasses)
         for (multifileClassFqName in filesInMultifileClasses.keySet() + obsoleteMultifileClasses) {
             CodegenFactory.doCheckCancelled(state)
-            generateMultifileClass(state, multifileClassFqName, filesInMultifileClasses.get(multifileClassFqName), errorHandler)
+            generateMultifileClass(state, multifileClassFqName, filesInMultifileClasses.get(multifileClassFqName))
         }
 
         val packagesWithObsoleteParts = HashSet(state.packagesWithObsoleteParts)
         for (packageFqName in packagesWithObsoleteParts + filesInPackages.keySet()) {
             CodegenFactory.doCheckCancelled(state)
-            generatePackage(state, packageFqName, filesInPackages.get(packageFqName), errorHandler)
+            generatePackage(state, packageFqName, filesInPackages.get(packageFqName))
         }
     }
 
@@ -74,25 +74,17 @@ object DefaultCodegenFactory : CodegenFactory {
     override fun createMultifileClassCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName) =
             MultifileClassCodegenImpl(state, files, fqName)
 
-    private fun generateMultifileClass(
+    private fun generateMultifileClass(state: GenerationState, multifileClassFqName: FqName, files: Collection<KtFile>) {
-            state: GenerationState,
+        state.factory.forMultifileClass(multifileClassFqName, files).generate()
-            multifileClassFqName: FqName,
-            files: Collection<KtFile>,
-            handler: CompilationErrorHandler
-    ) {
-        val codegen = state.factory.forMultifileClass(multifileClassFqName, files)
-        codegen.generate(handler)
     }
 
     fun generatePackage(
             state: GenerationState,
             packageFqName: FqName,
-            jetFiles: Collection<KtFile>,
+            jetFiles: Collection<KtFile>
-            errorHandler: CompilationErrorHandler
     ) {
         // We do not really generate package class, but use old package fqName to identify package in module-info.
         //FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(packageFqName);
-        val codegen = state.factory.forPackage(packageFqName, jetFiles)
+        state.factory.forPackage(packageFqName, jetFiles).generate()
-        codegen.generate(errorHandler)
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/CompilationErrorHandler.java

@@ -20,13 +20,14 @@ import org.jetbrains.kotlin.util.ExceptionUtilKt;
 
 import static org.jetbrains.kotlin.utils.ExceptionUtilsKt.rethrow;
 
-public interface CompilationErrorHandler {
+public class CompilationErrorHandler {
-    CompilationErrorHandler THROW_EXCEPTION = (exception, fileUrl) -> {
+    public static void reportException(Throwable exception, String fileUrl) {
         // CompilationException is already supposed to have all information about the context
         if (exception instanceof CompilationException) {
             try {
                 throw exception;
-            } catch (Throwable t) {
+            }
+            catch (Throwable t) {
                 throw rethrow(t);
             }
         }
@@ -35,7 +36,5 @@ public interface CompilationErrorHandler {
                 ExceptionUtilKt.getExceptionMessage("Backend", "Exception during code generation", exception, fileUrl),
                 exception
         );
-    };
+    }
-
-    void reportException(Throwable exception, String fileUrl);
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java

@@ -25,38 +25,21 @@ import org.jetbrains.kotlin.psi.KtFile;
 import java.util.Collection;
 
 public class KotlinCodegenFacade {
-
+    public static void compileCorrectFiles(@NotNull GenerationState state) {
-    public static void compileCorrectFiles(
-            @NotNull GenerationState state,
-            @NotNull CompilationErrorHandler errorHandler
-    ) {
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
         state.beforeCompile();
 
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
-        doGenerateFiles(state.getFiles(), state, errorHandler);
+        state.getCodegenFactory().generateModule(state, state.getFiles());
-    }
-
-    public static void doGenerateFiles(
-            @NotNull Collection<KtFile> files,
-            @NotNull GenerationState state,
-            @NotNull CompilationErrorHandler errorHandler
-    ) {
-        state.getCodegenFactory().generateModule(state, files, errorHandler);
 
         CodegenFactory.Companion.doCheckCancelled(state);
         state.getFactory().done();
     }
 
-    public static void generatePackage(
+    public static void generatePackage(@NotNull GenerationState state, @NotNull FqName packageFqName, @NotNull Collection<KtFile> files) {
-            @NotNull GenerationState state,
+        DefaultCodegenFactory.INSTANCE.generatePackage(state, packageFqName, files);
-            @NotNull FqName packageFqName,
-            @NotNull Collection<KtFile> jetFiles,
-            @NotNull CompilationErrorHandler errorHandler
-    ) {
-        DefaultCodegenFactory.INSTANCE.generatePackage(state, packageFqName, jetFiles, errorHandler);
     }
 
     private KotlinCodegenFacade() {}

compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt

@@ -54,7 +54,8 @@ import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
 
 interface MultifileClassCodegen {
-    fun generate(errorHandler: CompilationErrorHandler)
+    fun generate()
+
     fun generateClassOrObject(classOrObject: KtClassOrObject, packagePartContext: FieldOwnerContext<PackageFragmentDescriptor>)
 }
 
@@ -147,10 +148,10 @@ class MultifileClassCodegenImpl(
         }
     }
 
-    override fun generate(errorHandler: CompilationErrorHandler) {
+    override fun generate() {
         assert(delegateGenerationTasks.isEmpty()) { "generate() is called twice for facade class $facadeFqName" }
 
-        generateCodeForSourceFiles(errorHandler)
+        generateCodeForSourceFiles()
 
         generateDelegatesToPreviouslyCompiledParts()
 
@@ -161,7 +162,7 @@ class MultifileClassCodegenImpl(
         done()
     }
 
-    private fun generateCodeForSourceFiles(errorHandler: CompilationErrorHandler) {
+    private fun generateCodeForSourceFiles() {
         for (file in files) {
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
             try {
@@ -170,7 +171,7 @@ class MultifileClassCodegenImpl(
             } catch (e: ProcessCanceledException) {
                 throw e
             } catch (e: Throwable) {
-                errorHandler.reportException(e, file.virtualFile?.url ?: "no file")
+                CompilationErrorHandler.reportException(e, file.virtualFile?.url ?: "no file")
                 DiagnosticUtils.throwIfRunningOnServer(e)
                 if (ApplicationManager.getApplication().isInternal) {
                     e.printStackTrace()

compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java

@@ -16,11 +16,10 @@
 
 package org.jetbrains.kotlin.codegen;
 
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
 
 public interface PackageCodegen {
-    void generate(@NotNull CompilationErrorHandler errorHandler);
+    void generate();
 
     PackageFragmentDescriptor getPackageFragment();
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegenImpl.java

@@ -61,7 +61,7 @@ public class PackageCodegenImpl implements PackageCodegen {
     }
 
     @Override
-    public void generate(@NotNull CompilationErrorHandler errorHandler) {
+    public void generate() {
         for (KtFile file : files) {
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
             try {
@@ -73,7 +73,7 @@ public class PackageCodegenImpl implements PackageCodegen {
             }
             catch (Throwable e) {
                 VirtualFile vFile = file.getVirtualFile();
-                errorHandler.reportException(e, vFile == null ? "no file" : vFile.getUrl());
+                CompilationErrorHandler.reportException(e, vFile == null ? "no file" : vFile.getUrl());
                 DiagnosticUtils.throwIfRunningOnServer(e);
                 if (ApplicationManager.getApplication().isInternal()) {
                     //noinspection CallToPrintStackTrace

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

@@ -362,9 +362,7 @@ object KotlinToJVMBytecodeCompiler {
             val performanceManager = environment.configuration.get(CLIConfigurationKeys.PERF_MANAGER)
             performanceManager?.notifyGenerationStarted()
             generationState.beforeCompile()
-            codegenFactory.generateModuleInFrontendIRMode(
+            codegenFactory.generateModuleInFrontendIRMode(generationState, moduleFragment, symbolTable, sourceManager)
-                generationState, moduleFragment, CompilationErrorHandler.THROW_EXCEPTION, symbolTable, sourceManager
-            )
             CodegenFactory.doCheckCancelled(generationState)
             generationState.factory.done()
             performanceManager?.notifyGenerationFinished(
@@ -633,7 +631,7 @@ object KotlinToJVMBytecodeCompiler {
         val performanceManager = environment.configuration.get(CLIConfigurationKeys.PERF_MANAGER)
         performanceManager?.notifyGenerationStarted()
 
-        KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION)
+        KotlinCodegenFacade.compileCorrectFiles(generationState)
 
         performanceManager?.notifyGenerationFinished(
             sourceFiles.size,

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt

@@ -15,21 +15,16 @@ import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.types.defaultType
 import org.jetbrains.kotlin.ir.util.SymbolTable
+import org.jetbrains.kotlin.ir.util.generateTypicalIrProviderList
 import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
 import org.jetbrains.kotlin.psi2ir.PsiSourceManager
 
 object JvmBackendFacade {
-    fun doGenerateFiles(
+    fun doGenerateFiles(files: Collection<KtFile>, state: GenerationState, phaseConfig: PhaseConfig) {
-        files: Collection<KtFile>,
-        state: GenerationState,
-        errorHandler: CompilationErrorHandler,
-        phaseConfig: PhaseConfig
-    ) {
         val extensions = JvmGeneratorExtensions()
         val psi2ir = Psi2IrTranslator(state.languageVersionSettings, mangler = JvmMangler)
         val psi2irContext = psi2ir.createGeneratorContext(state.module, state.bindingContext, extensions = extensions)
@@ -55,14 +50,11 @@ object JvmBackendFacade {
             extensions = extensions
         )
         val irModuleFragment = psi2ir.generateModuleFragment(psi2irContext, files, irProviders = irProviders)
-        doGenerateFilesInternal(
+        doGenerateFilesInternal(state, irModuleFragment, psi2irContext.symbolTable, psi2irContext.sourceManager, phaseConfig, extensions)
-            state, errorHandler, irModuleFragment, psi2irContext.symbolTable, psi2irContext.sourceManager, phaseConfig, extensions
-        )
     }
 
     internal fun doGenerateFilesInternal(
         state: GenerationState,
-        errorHandler: CompilationErrorHandler,
         irModuleFragment: IrModuleFragment,
         symbolTable: SymbolTable,
         sourceManager: PsiSourceManager,
@@ -82,7 +74,7 @@ object JvmBackendFacade {
         try {
             JvmLower(context).lower(irModuleFragment)
         } catch (e: Throwable) {
-            errorHandler.reportException(e, null)
+            CompilationErrorHandler.reportException(e, null)
         }
 
         for (generateMultifileFacade in listOf(true, false)) {
@@ -103,7 +95,7 @@ object JvmBackendFacade {
                     }
                     state.afterIndependentPart()
                 } catch (e: Throwable) {
-                    errorHandler.reportException(e, null) // TODO ktFile.virtualFile.url
+                    CompilationErrorHandler.reportException(e, null) // TODO ktFile.virtualFile.url
                 }
             }
         }

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt

@@ -17,7 +17,10 @@
 package org.jetbrains.kotlin.backend.jvm
 
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
-import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.CodegenFactory
+import org.jetbrains.kotlin.codegen.MultifileClassCodegen
+import org.jetbrains.kotlin.codegen.PackageCodegen
+import org.jetbrains.kotlin.codegen.PackageCodegenImpl
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -30,31 +33,27 @@ import org.jetbrains.kotlin.psi2ir.PsiSourceManager
 
 class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory {
 
-    override fun generateModule(state: GenerationState, files: Collection<KtFile>, errorHandler: CompilationErrorHandler) {
+    override fun generateModule(state: GenerationState, files: Collection<KtFile>) {
-        JvmBackendFacade.doGenerateFiles(files, state, errorHandler, phaseConfig)
+        JvmBackendFacade.doGenerateFiles(files, state, phaseConfig)
     }
 
     fun generateModuleInFrontendIRMode(
-        state: GenerationState,
+        state: GenerationState, irModuleFragment: IrModuleFragment, symbolTable: SymbolTable, sourceManager: PsiSourceManager
-        irModuleFragment: IrModuleFragment,
-        errorHandler: CompilationErrorHandler,
-        symbolTable: SymbolTable,
-        sourceManager: PsiSourceManager
     ) {
         val extensions = JvmGeneratorExtensions()
         val irProviders = generateTypicalIrProviderList(
             irModuleFragment.descriptor, irModuleFragment.irBuiltins, symbolTable, extensions = extensions
         )
         ExternalDependenciesGenerator(symbolTable, irProviders).generateUnboundSymbolsAsDependencies()
-        JvmBackendFacade.doGenerateFilesInternal(state, errorHandler, irModuleFragment, symbolTable, sourceManager, phaseConfig, extensions)
+        JvmBackendFacade.doGenerateFilesInternal(state, irModuleFragment, symbolTable, sourceManager, phaseConfig, extensions)
     }
 
     override fun createPackageCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName): PackageCodegen {
         val impl = PackageCodegenImpl(state, files, fqName)
 
         return object : PackageCodegen {
-            override fun generate(errorHandler: CompilationErrorHandler) {
+            override fun generate() {
-                JvmBackendFacade.doGenerateFiles(files, state, errorHandler, phaseConfig)
+                JvmBackendFacade.doGenerateFiles(files, state, phaseConfig)
             }
 
             override fun getPackageFragment(): PackageFragmentDescriptor {

compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/LightClassDataProvider.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
 import org.jetbrains.kotlin.asJava.classes.safeIsLocal
-import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.MemberCodegen
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
@@ -83,13 +82,13 @@ sealed class LightClassDataProviderForFileFacade constructor(
                 val fileClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(representativeFile)
                 if (!fileClassInfo.withJvmMultifileClass) {
                     val codegen = state.factory.forPackage(representativeFile.packageFqName, files)
-                    codegen.generate(CompilationErrorHandler.THROW_EXCEPTION)
+                    codegen.generate()
                     state.factory.done()
                     return@generate
                 }
 
                 val codegen = state.factory.forMultifileClass(facadeFqName, files)
-                codegen.generate(CompilationErrorHandler.THROW_EXCEPTION)
+                codegen.generate()
                 state.factory.done()
             }
         }
@@ -142,7 +141,7 @@ class LightClassDataProviderForScript(private val script: KtScript) : CachedValu
                 state, files ->
                 val scriptFile = files.first()
                 val codegen = state.factory.forPackage(scriptFile.packageFqName, files)
-                codegen.generate(CompilationErrorHandler.THROW_EXCEPTION)
+                codegen.generate()
                 state.factory.done()
             }
         }

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

@@ -139,9 +139,7 @@ object GenerationUtils {
         ).build()
 
         generationState.beforeCompile()
-        codegenFactory.generateModuleInFrontendIRMode(
+        codegenFactory.generateModuleInFrontendIRMode(generationState, moduleFragment, symbolTable, sourceManager)
-            generationState, moduleFragment, CompilationErrorHandler.THROW_EXCEPTION, symbolTable, sourceManager
-        )
         generationState.factory.done()
         return generationState
     }
@@ -170,8 +168,8 @@ object GenerationUtils {
             else DefaultCodegenFactory
         ).isIrBackend(isIrBackend).build()
         if (analysisResult.shouldGenerateCode) {
-            KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION)
+            KotlinCodegenFacade.compileCorrectFiles(generationState)
         }
         return generationState
     }
-}
+}

idea/idea-jvm/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.kt

@@ -26,11 +26,14 @@ import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.backend.jvm.jvmPhases
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
-import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.DefaultCodegenFactory
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.idea.debugger.DebuggerUtils
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
@@ -38,14 +41,13 @@ import org.jetbrains.kotlin.idea.project.platform
 import org.jetbrains.kotlin.idea.util.InfinitePeriodicalTask
 import org.jetbrains.kotlin.idea.util.LongRunningReadTask
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
+import org.jetbrains.kotlin.platform.isCommon
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScript
-import org.jetbrains.kotlin.config.JvmTarget
-import org.jetbrains.kotlin.platform.isCommon
-import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
-import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.utils.join
 import java.awt.BorderLayout
 import java.awt.FlowLayout
@@ -329,7 +331,7 @@ class KotlinBytecodeToolWindow(private val myProject: Project, private val toolW
                 )
                 .build()
 
-            KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)
+            KotlinCodegenFacade.compileCorrectFiles(state)
 
             return state
         }

idea/idea-jvm/src/org/jetbrains/kotlin/idea/scratch/compile/KtScratchExecutionSession.kt

@@ -15,7 +15,6 @@ import com.intellij.openapi.project.DumbService
 import com.intellij.openapi.util.Computable
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
-import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.filterClassFiles
 import org.jetbrains.kotlin.codegen.state.GenerationState
@@ -131,7 +130,7 @@ class KtScratchExecutionSession(
             CompilerConfiguration.EMPTY
         ).generateDeclaredClassFilter(generateClassFilter).build()
 
-        KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)
+        KotlinCodegenFacade.compileCorrectFiles(state)
 
         return writeClassFilesToTempDir(state)
     }

idea/jvm-debugger/jvm-debugger-evaluation/src/org/jetbrains/kotlin/idea/debugger/evaluate/compilation/CodeFragmentCompiler.kt

@@ -15,11 +15,13 @@ import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.*
-import org.jetbrains.kotlin.idea.debugger.evaluate.*
+import org.jetbrains.kotlin.idea.debugger.evaluate.EvaluationStatus
+import org.jetbrains.kotlin.idea.debugger.evaluate.ExecutionContext
 import org.jetbrains.kotlin.idea.debugger.evaluate.classLoading.ClassToLoad
 import org.jetbrains.kotlin.idea.debugger.evaluate.classLoading.GENERATED_CLASS_NAME
 import org.jetbrains.kotlin.idea.debugger.evaluate.classLoading.GENERATED_FUNCTION_NAME
 import org.jetbrains.kotlin.idea.debugger.evaluate.compilation.CompiledDataDescriptor.MethodSignature
+import org.jetbrains.kotlin.idea.debugger.evaluate.getResolutionFacadeForCodeFragment
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.incremental.components.LookupLocation
@@ -87,7 +89,7 @@ class CodeFragmentCompiler(private val executionContext: ExecutionContext, priva
         CodeFragmentCodegen.setCodeFragmentInfo(codeFragment, codegenInfo)
 
         try {
-            KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION)
+            KotlinCodegenFacade.compileCorrectFiles(generationState)
 
             val classes = generationState.factory.asList().filterClassFiles()
                 .map { ClassToLoad(it.internalClassName, it.relativePath, it.asByteArray()) }

idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/DebuggerTestCompilerFacility.kt

@@ -18,8 +18,11 @@ import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.cli.common.output.writeAllTo
 import org.jetbrains.kotlin.cli.jvm.compiler.findMainClass
-import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.CodegenTestCase.TestFile
+import org.jetbrains.kotlin.codegen.CodegenTestUtil
+import org.jetbrains.kotlin.codegen.DefaultCodegenFactory
+import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -160,7 +163,7 @@ class DebuggerTestCompilerFacility(files: List<TestFile>, private val jvmTarget:
             .codegenFactory(DefaultCodegenFactory)
             .build()
 
-        KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)
+        KotlinCodegenFacade.compileCorrectFiles(state)
 
         val extraDiagnostics = state.collectedExtraJvmDiagnostics
         if (!extraDiagnostics.isEmpty()) {

plugins/jvm-abi-gen/src/org/jetbrains/kotlin/jvm/abi/JvmAbiAnalysisHandlerExtension.kt

@@ -13,7 +13,10 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
-import org.jetbrains.kotlin.codegen.*
+import org.jetbrains.kotlin.codegen.ClassBuilder
+import org.jetbrains.kotlin.codegen.ClassBuilderFactory
+import org.jetbrains.kotlin.codegen.ClassBuilderMode
+import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.compilerRunner.OutputItemsCollector
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
@@ -37,7 +40,10 @@ import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
-import org.jetbrains.org.objectweb.asm.*
+import org.jetbrains.org.objectweb.asm.ClassReader
+import org.jetbrains.org.objectweb.asm.ClassVisitor
+import org.jetbrains.org.objectweb.asm.ClassWriter
+import org.jetbrains.org.objectweb.asm.Opcodes
 import java.io.File
 import java.util.*
 
@@ -66,7 +72,7 @@ class JvmAbiAnalysisHandlerExtension(
             files.toList(),
             compilerConfiguration
         ).targetId(targetId).build()
-        KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION)
+        KotlinCodegenFacade.compileCorrectFiles(generationState)
 
         val outputDir = compilerConfiguration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)!!
         val outputs = ArrayList<AbiOutput>()

plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/Kapt3Extension.kt

@@ -24,14 +24,18 @@ import com.sun.tools.javac.tree.TreeMaker
 import com.sun.tools.javac.util.Context
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.backend.common.output.OutputFile
+import org.jetbrains.kotlin.base.kapt3.AptMode.APT_ONLY
+import org.jetbrains.kotlin.base.kapt3.AptMode.WITH_COMPILATION
+import org.jetbrains.kotlin.base.kapt3.DetectMemoryLeaksMode
+import org.jetbrains.kotlin.base.kapt3.KaptFlag
 import org.jetbrains.kotlin.base.kapt3.KaptOptions
+import org.jetbrains.kotlin.base.kapt3.collectJavaSourceFiles
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.OUTPUT
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.common.output.writeAll
 import org.jetbrains.kotlin.cli.jvm.plugins.ServiceLoaderLite
 import org.jetbrains.kotlin.codegen.ClassBuilderMode
-import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.OriginCollectingClassBuilderFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
@@ -40,12 +44,10 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.base.kapt3.AptMode.APT_ONLY
+import org.jetbrains.kotlin.kapt3.base.KaptContext
-import org.jetbrains.kotlin.base.kapt3.AptMode.WITH_COMPILATION
+import org.jetbrains.kotlin.kapt3.base.LoadedProcessors
-import org.jetbrains.kotlin.base.kapt3.DetectMemoryLeaksMode
+import org.jetbrains.kotlin.kapt3.base.ProcessorLoader
-import org.jetbrains.kotlin.base.kapt3.KaptFlag
+import org.jetbrains.kotlin.kapt3.base.doAnnotationProcessing
-import org.jetbrains.kotlin.base.kapt3.collectJavaSourceFiles
-import org.jetbrains.kotlin.kapt3.base.*
 import org.jetbrains.kotlin.kapt3.base.stubs.KaptStubLineInformation.Companion.KAPT_METADATA_EXTENSION
 import org.jetbrains.kotlin.kapt3.base.util.KaptBaseError
 import org.jetbrains.kotlin.kapt3.base.util.getPackageNameJava9Aware
@@ -268,7 +270,7 @@ abstract class AbstractKapt3Extension(
             .build()
 
         val (classFilesCompilationTime) = measureTimeMillis {
-            KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION)
+            KotlinCodegenFacade.compileCorrectFiles(generationState)
         }
 
         val compiledClasses = builderFactory.compiledClasses

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/KJvmReplCompilerImpl.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.cli.common.repl.LineId
 import org.jetbrains.kotlin.cli.common.repl.ReplCodeLine
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
-import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
@@ -150,12 +149,7 @@ class KJvmReplCompilerImpl(val hostConfiguration: ScriptingHostConfiguration) :
                 scriptSpecific.earlierScriptsForReplInterpreter = history.map { it.item }
                 beforeCompile()
             }
-            KotlinCodegenFacade.generatePackage(
+            KotlinCodegenFacade.generatePackage(generationState, snippetKtFile.script!!.containingKtFile.packageFqName, sourceFiles)
-                generationState,
-                snippetKtFile.script!!.containingKtFile.packageFqName,
-                sourceFiles,
-                CompilationErrorHandler.THROW_EXCEPTION
-            )
 
             history.push(LineId(codeLine), scriptDescriptor)
 

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/ScriptJvmCompilerImpls.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
-import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -206,16 +205,11 @@ private fun analyze(sourceFiles: Collection<KtFile>, environment: KotlinCoreEnvi
 
 private fun generate(
     analysisResult: AnalysisResult, sourceFiles: List<KtFile>, kotlinCompilerConfiguration: CompilerConfiguration
-): GenerationState {
+): GenerationState = GenerationState.Builder(
-    val generationState = GenerationState.Builder(
+    sourceFiles.first().project,
-        sourceFiles.first().project,
+    ClassBuilderFactories.BINARIES,
-        ClassBuilderFactories.BINARIES,
+    analysisResult.moduleDescriptor,
-        analysisResult.moduleDescriptor,
+    analysisResult.bindingContext,
-        analysisResult.bindingContext,
+    sourceFiles,
-        sourceFiles,
+    kotlinCompilerConfiguration
-        kotlinCompilerConfiguration
+).build().also(KotlinCodegenFacade::compileCorrectFiles)
-    ).build()
-
-    KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION)
-    return generationState
-}

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/repl/GenericReplCompiler.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.repl.*
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
-import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -105,8 +104,7 @@ open class GenericReplCompiler(
             KotlinCodegenFacade.generatePackage(
                 generationState,
                 psiFile.script!!.containingKtFile.packageFqName,
-                setOf(psiFile.script!!.containingKtFile),
+                setOf(psiFile.script!!.containingKtFile)
-                CompilationErrorHandler.THROW_EXCEPTION
             )
 
             compilerState.history.push(LineId(codeLine), scriptDescriptor)