Refactor codegen test utilities

Use GenerationUtils.compileFiles instead of
CodegenTestUtil.generateFiles

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

@@ -75,7 +75,8 @@ abstract class AbstractBytecodeListingTest : CodegenTestCase() {
             val environment = KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
             setupEnvironment(environment)
 
-            return CodegenTestUtil.generateFiles(environment, loadMultiFiles(files, environment.project), classBuilderFactory)
+            val testFiles = loadMultiFiles(files, environment.project)
+            return GenerationUtils.compileFiles(testFiles.psiFiles, environment, classBuilderFactory).factory
         }
     }
 }

compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java

@@ -19,13 +19,8 @@ package org.jetbrains.kotlin.codegen;
 import kotlin.collections.CollectionsKt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
-import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.config.CompilerConfiguration;
-import org.jetbrains.kotlin.resolve.AnalyzingUtils;
-import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 import org.jetbrains.kotlin.utils.StringsKt;
@@ -45,35 +40,7 @@ public class CodegenTestUtil {
 
     @NotNull
     public static ClassFileFactory generateFiles(@NotNull KotlinCoreEnvironment environment, @NotNull CodegenTestFiles files) {
-        return generateFiles(environment, files, ClassBuilderFactories.TEST);
+        return GenerationUtils.compileFiles(files.getPsiFiles(), environment).getFactory();
-    }
-    
-    @NotNull
-    public static ClassFileFactory generateFiles(
-            @NotNull KotlinCoreEnvironment environment, 
-            @NotNull CodegenTestFiles files,
-            @NotNull ClassBuilderFactory classBuilderFactory) {
-        AnalysisResult analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(files.getPsiFiles(), environment);
-        analysisResult.throwIfError();
-        AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext());
-        CompilerConfiguration configuration = environment.getConfiguration();
-        GenerationState state = new GenerationState(
-                environment.getProject(),
-                classBuilderFactory,
-                analysisResult.getModuleDescriptor(),
-                analysisResult.getBindingContext(),
-                files.getPsiFiles(),
-                configuration
-        );
-
-        if (analysisResult.getShouldGenerateCode()) {
-            KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
-        }
-
-        // For JVM-specific errors
-        AnalyzingUtils.throwExceptionOnErrors(state.getCollectedExtraJvmDiagnostics());
-
-        return state.getFactory();
     }
 
     public static void assertThrows(@NotNull Method foo, @NotNull Class<? extends Throwable> exceptionClass,

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

@@ -40,23 +40,35 @@ object GenerationUtils {
             compileFiles(listOf(ktFile), environment).factory
 
     @JvmStatic
-    fun compileFiles(files: List<KtFile>, environment: KotlinCoreEnvironment): GenerationState =
+    @JvmOverloads
-            compileFiles(files, environment.configuration) { scope -> JvmPackagePartProvider(environment, scope) }
+    fun compileFiles(
+            files: List<KtFile>,
+            environment: KotlinCoreEnvironment,
+            classBuilderFactory: ClassBuilderFactory = ClassBuilderFactories.TEST
+    ): GenerationState =
+            compileFiles(files, environment.configuration, classBuilderFactory) { scope ->
+                JvmPackagePartProvider(environment, scope)
+            }
+
+
 
     @JvmStatic
     fun compileFiles(
             files: List<KtFile>,
             configuration: CompilerConfiguration,
+            classBuilderFactory: ClassBuilderFactory,
             packagePartProvider: (GlobalSearchScope) -> PackagePartProvider
     ): GenerationState {
         val analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(files.first().project, files, configuration, packagePartProvider)
         analysisResult.throwIfError()
 
         val state = GenerationState(
-                files.first().project, ClassBuilderFactories.TEST, analysisResult.moduleDescriptor, analysisResult.bindingContext,
+                files.first().project, classBuilderFactory, analysisResult.moduleDescriptor, analysisResult.bindingContext,
                 files, configuration
         )
-        KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)
+        if (analysisResult.shouldGenerateCode) {
+            KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)
+        }
 
         // For JVM-specific errors
         AnalyzingUtils.throwExceptionOnErrors(state.collectedExtraJvmDiagnostics)

idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractPositionManagerTest.java

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.idea.debugger;
 
 import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
 import com.intellij.debugger.NoDataException;
 import com.intellij.debugger.PositionManager;
 import com.intellij.debugger.SourcePosition;
@@ -39,8 +38,8 @@ import kotlin.jvm.functions.Function1;
 import kotlin.sequences.SequencesKt;
 import kotlin.text.StringsKt;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
+import org.jetbrains.kotlin.codegen.ClassBuilderFactories;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
@@ -147,16 +146,8 @@ public abstract class AbstractPositionManagerTest extends KotlinLightCodeInsight
         // TODO: delete this once IDEVirtualFileFinder supports loading .kotlin_builtins files
         configuration.put(JVMConfigurationKeys.ADD_BUILT_INS_FROM_COMPILER_TO_DEPENDENCIES, true);
 
-        GenerationState state = GenerationUtils.compileFiles(
+        GenerationState state =
-                files,
+                GenerationUtils.compileFiles(files, configuration, ClassBuilderFactories.TEST, scope -> PackagePartProvider.Empty.INSTANCE);
-                configuration,
-                new Function1<GlobalSearchScope, PackagePartProvider>() {
-                    @Override
-                    public PackagePartProvider invoke(GlobalSearchScope scope) {
-                        return PackagePartProvider.Empty.INSTANCE;
-                    }
-                }
-        );
 
         Map<String, ReferenceType> referencesByName = getReferenceMap(state.getFactory());
 

plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3IntegrationTest.kt

@@ -20,10 +20,8 @@ import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.util.text.StringUtil
 import com.sun.tools.javac.tree.JCTree
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
-import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.codegen.CodegenTestCase
-import org.jetbrains.kotlin.codegen.CodegenTestUtil
+import org.jetbrains.kotlin.codegen.GenerationUtils
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.kapt3.AbstractKapt3Extension
@@ -134,8 +132,7 @@ abstract class AbstractKotlinKapt3IntegrationTest : CodegenTestCase() {
         try {
             loadMultiFiles(files)
 
-            val classBuilderFactory = Kapt3BuilderFactory()
+            GenerationUtils.compileFiles(myFiles.psiFiles, myEnvironment, Kapt3BuilderFactory()).factory
-            CodegenTestUtil.generateFiles(myEnvironment, myFiles, classBuilderFactory)
 
             val actualRaw = kapt3Extension.savedStubs ?: error("Stubs were not saved")
             val actual = StringUtil.convertLineSeparators(actualRaw.trim({ it <= ' ' })).trimTrailingWhitespacesAndAddNewlineAtEOF()

plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt

@@ -23,7 +23,7 @@ import com.sun.tools.javac.util.Log
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.codegen.CodegenTestCase
-import org.jetbrains.kotlin.codegen.CodegenTestUtil
+import org.jetbrains.kotlin.codegen.GenerationUtils
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.kapt3.Kapt3BuilderFactory
 import org.jetbrains.kotlin.kapt3.KaptContext
@@ -58,15 +58,15 @@ abstract class AbstractKotlinKapt3Test : CodegenTestCase() {
 
         val txtFile = File(wholeFile.parentFile, wholeFile.nameWithoutExtension + ".txt")
         val classBuilderFactory = Kapt3BuilderFactory()
-        val factory = CodegenTestUtil.generateFiles(myEnvironment, myFiles, classBuilderFactory)
+        val state = GenerationUtils.compileFiles(myFiles.psiFiles, myEnvironment, classBuilderFactory)
-        val typeMapper = factory.generationState.typeMapper
 
         val logger = KaptLogger(isVerbose = true, messageCollector = messageCollector)
-        val kaptContext = KaptContext(logger, factory.generationState.bindingContext, classBuilderFactory.compiledClasses,
+        val kaptContext = KaptContext(logger, state.bindingContext, classBuilderFactory.compiledClasses,
                                       classBuilderFactory.origins, processorOptions = emptyMap())
         try {
-            check(kaptContext, typeMapper, txtFile, wholeFile)
+            check(kaptContext, state.typeMapper, txtFile, wholeFile)
-        } finally {
+        }
+        finally {
             kaptContext.close()
         }
     }