Refactor old test utility in LoadDescriptorUtil

Also make USE_TYPE_TABLE a flag in CompilerConfiguration instead of an extra boolean parameter in numerous methods
2016-05-20 11:45:11 +03:00
parent 76d78ba666
commit 1492c71e88
7 changed files with 52 additions and 90 deletions
@@ -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");
@@ -48,9 +48,7 @@ public class GenerationUtils {

    @NotNull
    public static ClassFileFactory compileFile(@NotNull KtFile ktFile, @NotNull KotlinCoreEnvironment environment) {
-        AnalysisResult analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(ktFile, environment);
-        GenerationState state = compileFiles(analysisResult, Collections.singletonList(ktFile), false, environment.getConfiguration());
-        return state.getFactory();
+        return compileFiles(Collections.singletonList(ktFile), environment).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(),
@@ -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 {
@@ -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 com.intellij.util.containers.ContainerUtil;
+import kotlin.collections.CollectionsKt;
+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 final class LoadDescriptorUtil {
-
+public 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(
-            @NotNull List<File> kotlinFiles,
-            @NotNull File outDir,
-            @NotNull Disposable disposable,
-            @NotNull ConfigurationKind configurationKind,
-            boolean useTypeTableInSerializer
+    public static ModuleDescriptor compileKotlinToDirAndGetModule(
+            @NotNull List<File> kotlinFiles, @NotNull File outDir, @NotNull KotlinCoreEnvironment environment
    ) {
-        KtFilesAndAnalysisResult filesAndResult =
-                KtFilesAndAnalysisResult.createJetFilesAndAnalyze(kotlinFiles, disposable, configurationKind);
-        AnalysisResult result = filesAndResult.getAnalysisResult();
-        GenerationState state = GenerationUtils.compileFiles(
-                result, filesAndResult.getKtFiles(), useTypeTableInSerializer, CompilerConfiguration.EMPTY
-        );
+        GenerationState state = GenerationUtils.compileFiles(createKtFiles(kotlinFiles, environment), environment);
        OutputUtilsKt.writeAllTo(state.getFactory(), outDir);
-        return result;
+        return state.getModule();
    }

    @NotNull
@@ -119,47 +109,18 @@ public final class LoadDescriptorUtil {
        ));
    }

-    private static class KtFilesAndAnalysisResult {
-        @NotNull
-        public static KtFilesAndAnalysisResult createJetFilesAndAnalyze(
-                @NotNull List<File> kotlinFiles,
-                @NotNull Disposable disposable,
-                @NotNull ConfigurationKind configurationKind
-        ) {
-            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);
-                    }
+    @NotNull
+    private static List<KtFile> createKtFiles(@NotNull List<File> kotlinFiles, @NotNull final KotlinCoreEnvironment environment) {
+        return CollectionsKt.map(kotlinFiles, new Function1<File, KtFile>() {
+            @Override
+            public KtFile invoke(File kotlinFile) {
+                try {
+                    return KotlinTestUtils.createFile(kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), environment.getProject());
                }
-            });
-            AnalysisResult result = JvmResolveUtil.analyzeAndCheckForErrors(ktFiles, environment);
-            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;
-        }
+                catch (IOException e) {
+                    throw ExceptionUtilsKt.rethrow(e);
+                }
+            }
+        });
    }
 }
@@ -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();
@@ -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)
@@ -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")