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(
-            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()
     }
 }

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 {
-    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);
+    }
 }

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,
-            @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() {}

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