From 1492c71e88cc08ffaed84d8383f5ab4c09deb405 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 20 May 2016 11:45:11 +0300 Subject: [PATCH] Refactor old test utility in LoadDescriptorUtil Also make USE_TYPE_TABLE a flag in CompilerConfiguration instead of an extra boolean parameter in numerous methods --- .../kotlin/config/JVMConfigurationKeys.java | 2 + .../kotlin/codegen/GenerationUtils.java | 18 +---- .../jvm/compiler/AbstractLoadJavaTest.java | 23 ++++-- .../jvm/compiler/LoadDescriptorUtil.java | 81 +++++-------------- .../kotlin/test/KotlinTestUtils.java | 6 +- .../kotlin/cli/WrongBytecodeVersionTest.kt | 7 +- .../AbstractLocalClassProtoTest.kt | 5 +- 7 files changed, 52 insertions(+), 90 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java b/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java index 16a3518ce45..0d0f66cc329 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java +++ b/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 INHERIT_MULTIFILE_PARTS = CompilerConfigurationKey.create("compile multifile classes to a hierarchy of parts and facade"); + public static final CompilerConfigurationKey USE_TYPE_TABLE = + CompilerConfigurationKey.create("use type table in serializer"); public static final CompilerConfigurationKey INCREMENTAL_COMPILATION_COMPONENTS = CompilerConfigurationKey.create("incremental cache provider"); diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/GenerationUtils.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/GenerationUtils.java index 9e911eda16d..6d10ea805ae 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/GenerationUtils.java +++ b/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); - 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 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.emptySet(), Collections.emptySet(), diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index 7065b42ce48..e1beeabf3b1 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/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 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 javaSources = FileUtil.findFilesByMask(Pattern.compile(".+\\.java"), sourcesDir); Pair 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 { diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java index 351ed5c674d..be0e505560b 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java +++ b/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 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 kotlinFiles, - @NotNull File outDir, - @NotNull Disposable disposable, - @NotNull ConfigurationKind configurationKind, - boolean useTypeTableInSerializer + public static ModuleDescriptor compileKotlinToDirAndGetModule( + @NotNull List 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 kotlinFiles, - @NotNull Disposable disposable, - @NotNull ConfigurationKind configurationKind - ) { - final KotlinCoreEnvironment environment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, configurationKind); - List ktFiles = ContainerUtil.map(kotlinFiles, new Function() { - @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 createKtFiles(@NotNull List kotlinFiles, @NotNull final KotlinCoreEnvironment environment) { + return CollectionsKt.map(kotlinFiles, new Function1() { + @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 ktFiles; - private final AnalysisResult result; - - private KtFilesAndAnalysisResult(@NotNull List ktFiles, @NotNull AnalysisResult result) { - this.ktFiles = ktFiles; - this.result = result; - } - - @NotNull - public List getKtFiles() { - return ktFiles; - } - - @NotNull - public AnalysisResult getAnalysisResult() { - return result; - } + catch (IOException e) { + throw ExceptionUtilsKt.rethrow(e); + } + } + }); } } diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java index cec6dd54a37..2a87a43fb47 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java +++ b/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(); diff --git a/compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt b/compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt index a63d007c8e9..55c23ae1a57 100644 --- a/compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt +++ b/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) diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt index 0b7bcad5e5b..17b352fe898 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt +++ b/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")