Refactor old test utility in LoadDescriptorUtil

Also make USE_TYPE_TABLE a flag in CompilerConfiguration instead of an extra
boolean parameter in numerous methods

compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java

@@ -35,6 +35,8 @@ public class JVMConfigurationKeys {
             CompilerConfigurationKey.create("disable optimization");
     public static final CompilerConfigurationKey<Boolean> INHERIT_MULTIFILE_PARTS =
             CompilerConfigurationKey.create("compile multifile classes to a hierarchy of parts and facade");
+    public static final CompilerConfigurationKey<Boolean> USE_TYPE_TABLE =
+            CompilerConfigurationKey.create("use type table in serializer");
 
     public static final CompilerConfigurationKey<IncrementalCompilationComponents> INCREMENTAL_COMPILATION_COMPONENTS =
             CompilerConfigurationKey.create("incremental cache provider");

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

@@ -48,9 +48,7 @@ public class GenerationUtils {
 
     @NotNull
     public static ClassFileFactory compileFile(@NotNull KtFile ktFile, @NotNull KotlinCoreEnvironment environment) {
-        AnalysisResult analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(ktFile, environment);
+        return compileFiles(Collections.singletonList(ktFile), environment).getFactory();
-        GenerationState state = compileFiles(analysisResult, Collections.singletonList(ktFile), false, environment.getConfiguration());
-        return state.getFactory();
     }
 
     @NotNull
@@ -59,19 +57,11 @@ public class GenerationUtils {
                 environment == null ? PackagePartProvider.Companion.getEMPTY() : new JvmPackagePartProvider(environment);
         CompilerConfiguration configuration =
                 environment == null ? CompilerConfiguration.EMPTY : environment.getConfiguration();
+
         AnalysisResult analysisResult =
                 JvmResolveUtil.analyzeAndCheckForErrors(CollectionsKt.first(files).getProject(), files, configuration, packagePartProvider);
-        return compileFiles(analysisResult, files, false, configuration);
-    }
-
-    @NotNull
-    public static GenerationState compileFiles(
-            @NotNull AnalysisResult analysisResult,
-            @NotNull List<KtFile> files,
-            boolean useTypeTableInSerializer,
-            @NotNull CompilerConfiguration configuration
-    ) {
         analysisResult.throwIfError();
+
         GenerationState state = new GenerationState(
                 CollectionsKt.first(files).getProject(), ClassBuilderFactories.TEST,
                 analysisResult.getModuleDescriptor(), analysisResult.getBindingContext(),
@@ -81,7 +71,7 @@ public class GenerationUtils {
                 GenerationState.GenerateClassFilter.GENERATE_ALL,
                 configuration.get(JVMConfigurationKeys.DISABLE_INLINE, false),
                 configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false),
-                useTypeTableInSerializer,
+                configuration.get(JVMConfigurationKeys.USE_TYPE_TABLE, false),
                 configuration.get(JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS, false),
                 Collections.<FqName>emptySet(),
                 Collections.<FqName>emptySet(),

compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -20,7 +20,6 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.io.FileUtil;
 import junit.framework.ComparisonFailure;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
@@ -29,6 +28,7 @@ import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
 import org.jetbrains.kotlin.cli.jvm.config.ModuleNameKt;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.ContentRootsKt;
+import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
@@ -78,7 +78,9 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         File sourcesDir = new File(expectedFileName.replaceFirst("\\.txt$", ""));
 
         List<File> kotlinSources = FileUtil.findFilesByMask(Pattern.compile(".+\\.kt"), sourcesDir);
-        compileKotlinToDirAndGetAnalysisResult(kotlinSources, tmpdir, myTestRootDisposable, ConfigurationKind.JDK_ONLY, false);
+        KotlinCoreEnvironment environment =
+                KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY);
+        compileKotlinToDirAndGetModule(kotlinSources, tmpdir, environment);
 
         List<File> javaSources = FileUtil.findFilesByMask(Pattern.compile(".+\\.java"), sourcesDir);
         Pair<PackageViewDescriptor, BindingContext> binaryPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary(
@@ -109,11 +111,16 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
     ) throws Exception {
         File ktFile = new File(ktFileName);
         File txtFile = new File(ktFileName.replaceFirst("\\.kt$", ".txt"));
-        AnalysisResult result = compileKotlinToDirAndGetAnalysisResult(
-                Collections.singletonList(ktFile), tmpdir, getTestRootDisposable(), configurationKind, useTypeTableInSerializer
-        );
 
-        PackageViewDescriptor packageFromSource = result.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);
+        CompilerConfiguration configuration = compilerConfigurationForTests(configurationKind, TestJdkKind.MOCK_JDK, getAnnotationsJar());
+        if (useTypeTableInSerializer) {
+            configuration.put(JVMConfigurationKeys.USE_TYPE_TABLE, true);
+        }
+        KotlinCoreEnvironment environment =
+                KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        ModuleDescriptor module = compileKotlinToDirAndGetModule(Collections.singletonList(ktFile), tmpdir, environment);
+
+        PackageViewDescriptor packageFromSource = module.getPackage(TEST_PACKAGE_FQNAME);
         Assert.assertEquals("test", packageFromSource.getName().asString());
 
         PackageViewDescriptor packageFromBinary = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot(
@@ -128,10 +135,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
 
         DescriptorValidator.validate(errorTypesForbidden(), packageFromSource);
         DescriptorValidator.validate(new DeserializedScopeValidationVisitor(), packageFromBinary);
-        Configuration configuration = RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT
+        Configuration comparatorConfiguration = RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT
                 .checkPrimaryConstructors(true)
                 .checkPropertyAccessors(true);
-        compareDescriptors(packageFromSource, packageFromBinary, configuration, txtFile);
+        compareDescriptors(packageFromSource, packageFromBinary, comparatorConfiguration, txtFile);
     }
 
     protected void doTestJavaAgainstKotlin(String expectedFileName) throws Exception {

compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java

@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.jvm.compiler;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.util.Function;
+import kotlin.collections.CollectionsKt;
-import com.intellij.util.containers.ContainerUtil;
+import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
@@ -39,6 +40,7 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
+import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
 
 import java.io.File;
 import java.io.IOException;
@@ -47,10 +49,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
-import static org.jetbrains.kotlin.test.KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations;
+public class LoadDescriptorUtil {
-
-public final class LoadDescriptorUtil {
-
     @NotNull
     public static final FqName TEST_PACKAGE_FQNAME = FqName.topLevel(Name.identifier("test"));
 
@@ -58,21 +57,12 @@ public final class LoadDescriptorUtil {
     }
 
     @NotNull
-    public static AnalysisResult compileKotlinToDirAndGetAnalysisResult(
+    public static ModuleDescriptor compileKotlinToDirAndGetModule(
-            @NotNull List<File> kotlinFiles,
+            @NotNull List<File> kotlinFiles, @NotNull File outDir, @NotNull KotlinCoreEnvironment environment
-            @NotNull File outDir,
-            @NotNull Disposable disposable,
-            @NotNull ConfigurationKind configurationKind,
-            boolean useTypeTableInSerializer
     ) {
-        KtFilesAndAnalysisResult filesAndResult =
+        GenerationState state = GenerationUtils.compileFiles(createKtFiles(kotlinFiles, environment), environment);
-                KtFilesAndAnalysisResult.createJetFilesAndAnalyze(kotlinFiles, disposable, configurationKind);
-        AnalysisResult result = filesAndResult.getAnalysisResult();
-        GenerationState state = GenerationUtils.compileFiles(
-                result, filesAndResult.getKtFiles(), useTypeTableInSerializer, CompilerConfiguration.EMPTY
-        );
         OutputUtilsKt.writeAllTo(state.getFactory(), outDir);
-        return result;
+        return state.getModule();
     }
 
     @NotNull
@@ -119,47 +109,18 @@ public final class LoadDescriptorUtil {
         ));
     }
 
-    private static class KtFilesAndAnalysisResult {
+    @NotNull
-        @NotNull
+    private static List<KtFile> createKtFiles(@NotNull List<File> kotlinFiles, @NotNull final KotlinCoreEnvironment environment) {
-        public static KtFilesAndAnalysisResult createJetFilesAndAnalyze(
+        return CollectionsKt.map(kotlinFiles, new Function1<File, KtFile>() {
-                @NotNull List<File> kotlinFiles,
+            @Override
-                @NotNull Disposable disposable,
+            public KtFile invoke(File kotlinFile) {
-                @NotNull ConfigurationKind configurationKind
+                try {
-        ) {
+                    return KotlinTestUtils.createFile(kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), environment.getProject());
-            final KotlinCoreEnvironment environment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, configurationKind);
-            List<KtFile> ktFiles = ContainerUtil.map(kotlinFiles, new Function<File, KtFile>() {
-                @Override
-                public KtFile fun(File kotlinFile) {
-                    try {
-                        return KotlinTestUtils.createFile(
-                                kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), environment.getProject()
-                        );
-                    }
-                    catch (IOException e) {
-                        throw new AssertionError(e);
-                    }
                 }
-            });
+                catch (IOException e) {
-            AnalysisResult result = JvmResolveUtil.analyzeAndCheckForErrors(ktFiles, environment);
+                    throw ExceptionUtilsKt.rethrow(e);
-            return new KtFilesAndAnalysisResult(ktFiles, result);
+                }
-        }
+            }
-
+        });
-        private final List<KtFile> ktFiles;
-        private final AnalysisResult result;
-
-        private KtFilesAndAnalysisResult(@NotNull List<KtFile> ktFiles, @NotNull AnalysisResult result) {
-            this.ktFiles = ktFiles;
-            this.result = result;
-        }
-
-        @NotNull
-        public List<KtFile> getKtFiles() {
-            return ktFiles;
-        }
-
-        @NotNull
-        public AnalysisResult getAnalysisResult() {
-            return result;
-        }
     }
 }

compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java

@@ -63,6 +63,7 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.diagnostics.Severity;
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
+import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.KtExpression;
@@ -95,8 +96,6 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static org.jetbrains.kotlin.config.JVMConfigurationKeys.MODULE_NAME;
-import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalysisResult;
-import static org.jetbrains.kotlin.test.ConfigurationKind.ALL;
 
 public class KotlinTestUtils {
     public static final String TEST_GENERATOR_NAME = "org.jetbrains.kotlin.generators.tests.TestsPackage";
@@ -541,7 +540,8 @@ public class KotlinTestUtils {
             @Nullable File javaErrorFile
     ) throws IOException {
         if (!ktFiles.isEmpty()) {
-            compileKotlinToDirAndGetAnalysisResult(ktFiles, outDir, disposable, ALL, false);
+            KotlinCoreEnvironment environment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable);
+            LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment);
         }
         else {
             boolean mkdirs = outDir.mkdirs();

compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.JvmBytecodeBinaryVersion
-import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
 import org.jetbrains.org.objectweb.asm.*
@@ -37,9 +36,9 @@ class WrongBytecodeVersionTest : KtUsefulTestCase() {
         val usageSource = File(directory, "B.kt")
 
         val tmpdir = KotlinTestUtils.tmpDir(javaClass.simpleName)
-        LoadDescriptorUtil.compileKotlinToDirAndGetAnalysisResult(
+
-                listOf(librarySource), tmpdir, testRootDisposable, ConfigurationKind.ALL, false
+        val environment = KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(testRootDisposable)
-        )
+        LoadDescriptorUtil.compileKotlinToDirAndGetModule(listOf(librarySource), tmpdir, environment)
 
         for (classFile in File(tmpdir, "library").listFiles { file -> file.extension == JavaClassFileType.INSTANCE.defaultExtension }) {
             changeVersionInBytecode(classFile)

compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt

@@ -38,7 +38,10 @@ import java.net.URLClassLoader
 abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
     protected fun doTest(filename: String) {
         val source = File(filename)
-        LoadDescriptorUtil.compileKotlinToDirAndGetAnalysisResult(listOf(source), tmpdir, testRootDisposable, ConfigurationKind.ALL, false)
+
+        KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(testRootDisposable).let { environment ->
+            LoadDescriptorUtil.compileKotlinToDirAndGetModule(listOf(source), tmpdir, environment)
+        }
 
         val classNameSuffix = InTextDirectivesUtils.findStringWithPrefixes(source.readText(), "// CLASS_NAME_SUFFIX: ")
                               ?: error("CLASS_NAME_SUFFIX directive not found in test data")