Refactor CompilationErrorHandler

It only had one implementation THROW_EXCEPTION, inline it everywhere with a call to a static method
2019-12-02 17:41:35 +01:00
parent 2435b8d9fa
commit fd627603a0
20 changed files with 97 additions and 137 deletions
@@ -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(
-            state: GenerationState,
-            multifileClassFqName: FqName,
-            files: Collection<KtFile>,
-            handler: CompilationErrorHandler
-    ) {
-        val codegen = state.factory.forMultifileClass(multifileClassFqName, files)
-        codegen.generate(handler)
+    private fun generateMultifileClass(state: GenerationState, multifileClassFqName: FqName, files: Collection<KtFile>) {
+        state.factory.forMultifileClass(multifileClassFqName, files).generate()
    }

    fun generatePackage(
            state: GenerationState,
            packageFqName: FqName,
-            jetFiles: Collection<KtFile>,
-            errorHandler: CompilationErrorHandler
+            jetFiles: Collection<KtFile>
    ) {
        // 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)
-        codegen.generate(errorHandler)
+        state.factory.forPackage(packageFqName, jetFiles).generate()
    }
 }
@@ -20,13 +20,14 @@ import org.jetbrains.kotlin.util.ExceptionUtilKt;

 import static org.jetbrains.kotlin.utils.ExceptionUtilsKt.rethrow;

-public interface CompilationErrorHandler {
-    CompilationErrorHandler THROW_EXCEPTION = (exception, fileUrl) -> {
+public class CompilationErrorHandler {
+    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);
+    }
 }
@@ -25,38 +25,21 @@ import org.jetbrains.kotlin.psi.KtFile;
 import java.util.Collection;

 public class KotlinCodegenFacade {
-
-    public static void compileCorrectFiles(
-            @NotNull GenerationState state,
-            @NotNull CompilationErrorHandler errorHandler
-    ) {
+    public static void compileCorrectFiles(@NotNull GenerationState state) {
        ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();

        state.beforeCompile();

        ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();

-        doGenerateFiles(state.getFiles(), state, errorHandler);
-    }
-
-    public static void doGenerateFiles(
-            @NotNull Collection<KtFile> files,
-            @NotNull GenerationState state,
-            @NotNull CompilationErrorHandler errorHandler
-    ) {
-        state.getCodegenFactory().generateModule(state, files, errorHandler);
+        state.getCodegenFactory().generateModule(state, state.getFiles());

        CodegenFactory.Companion.doCheckCancelled(state);
        state.getFactory().done();
    }

-    public static void generatePackage(
-            @NotNull GenerationState state,
-            @NotNull FqName packageFqName,
-            @NotNull Collection<KtFile> jetFiles,
-            @NotNull CompilationErrorHandler errorHandler
-    ) {
-        DefaultCodegenFactory.INSTANCE.generatePackage(state, packageFqName, jetFiles, errorHandler);
+    public static void generatePackage(@NotNull GenerationState state, @NotNull FqName packageFqName, @NotNull Collection<KtFile> files) {
+        DefaultCodegenFactory.INSTANCE.generatePackage(state, packageFqName, files);
    }

    private KotlinCodegenFacade() {}
@@ -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()
@@ -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();
 }
@@ -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
@@ -362,9 +362,7 @@ object KotlinToJVMBytecodeCompiler {
            val performanceManager = environment.configuration.get(CLIConfigurationKeys.PERF_MANAGER)
            performanceManager?.notifyGenerationStarted()
            generationState.beforeCompile()
-            codegenFactory.generateModuleInFrontendIRMode(
-                generationState, moduleFragment, CompilationErrorHandler.THROW_EXCEPTION, symbolTable, sourceManager
-            )
+            codegenFactory.generateModuleInFrontendIRMode(generationState, moduleFragment, 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,
@@ -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(
-        files: Collection<KtFile>,
-        state: GenerationState,
-        errorHandler: CompilationErrorHandler,
-        phaseConfig: PhaseConfig
-    ) {
+    fun doGenerateFiles(files: Collection<KtFile>, state: GenerationState, 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(
-            state, errorHandler, irModuleFragment, psi2irContext.symbolTable, psi2irContext.sourceManager, phaseConfig, extensions
-        )
+        doGenerateFilesInternal(state, 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
                }
            }
        }
@@ -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) {
-        JvmBackendFacade.doGenerateFiles(files, state, errorHandler, phaseConfig)
+    override fun generateModule(state: GenerationState, files: Collection<KtFile>) {
+        JvmBackendFacade.doGenerateFiles(files, state, phaseConfig)
    }

    fun generateModuleInFrontendIRMode(
-        state: GenerationState,
-        irModuleFragment: IrModuleFragment,
-        errorHandler: CompilationErrorHandler,
-        symbolTable: SymbolTable,
-        sourceManager: PsiSourceManager
+        state: GenerationState, irModuleFragment: IrModuleFragment, 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) {
-                JvmBackendFacade.doGenerateFiles(files, state, errorHandler, phaseConfig)
+            override fun generate() {
+                JvmBackendFacade.doGenerateFiles(files, state, phaseConfig)
            }

            override fun getPackageFragment(): PackageFragmentDescriptor {
@@ -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()
            }
        }
@@ -139,9 +139,7 @@ object GenerationUtils {
        ).build()

        generationState.beforeCompile()
-        codegenFactory.generateModuleInFrontendIRMode(
-            generationState, moduleFragment, CompilationErrorHandler.THROW_EXCEPTION, symbolTable, sourceManager
-        )
+        codegenFactory.generateModuleInFrontendIRMode(generationState, moduleFragment, 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
    }
-}
+}
@@ -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
        }
@@ -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)
    }
@@ -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()) }
@@ -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()) {
@@ -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>()
@@ -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.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.collectJavaSourceFiles
-import org.jetbrains.kotlin.kapt3.base.*
+import org.jetbrains.kotlin.kapt3.base.KaptContext
+import org.jetbrains.kotlin.kapt3.base.LoadedProcessors
+import org.jetbrains.kotlin.kapt3.base.ProcessorLoader
+import org.jetbrains.kotlin.kapt3.base.doAnnotationProcessing
 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
@@ -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(
-                generationState,
-                snippetKtFile.script!!.containingKtFile.packageFqName,
-                sourceFiles,
-                CompilationErrorHandler.THROW_EXCEPTION
-            )
+            KotlinCodegenFacade.generatePackage(generationState, snippetKtFile.script!!.containingKtFile.packageFqName, sourceFiles)

            history.push(LineId(codeLine), scriptDescriptor)

@@ -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 {
-    val generationState = GenerationState.Builder(
-        sourceFiles.first().project,
-        ClassBuilderFactories.BINARIES,
-        analysisResult.moduleDescriptor,
-        analysisResult.bindingContext,
-        sourceFiles,
-        kotlinCompilerConfiguration
-    ).build()
-
-    KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION)
-    return generationState
-}
+): GenerationState = GenerationState.Builder(
+    sourceFiles.first().project,
+    ClassBuilderFactories.BINARIES,
+    analysisResult.moduleDescriptor,
+    analysisResult.bindingContext,
+    sourceFiles,
+    kotlinCompilerConfiguration
+).build().also(KotlinCodegenFacade::compileCorrectFiles)
@@ -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),
-                CompilationErrorHandler.THROW_EXCEPTION
+                setOf(psiFile.script!!.containingKtFile)
            )

            compilerState.history.push(LineId(codeLine), scriptDescriptor)