From 0124cb64f0f81fdec5af3b16cc55dd0e714ad31e Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 19 May 2016 17:43:09 +0300 Subject: [PATCH] Cleanup test utilities in JvmResolveUtil and GenerationUtils Simplify usages and fix some warnings along the way. Rename: - analyzeFilesWithJavaIntegration, analyzeOneFileWithJavaIntegration -> analyze - analyzeFilesWithJavaIntegrationAndCheckForErrors, analyzeOneFileWithJavaIntegrationAndCheckForErrors -> analyzeAndCheckForErrors - compileFilesGetGenerationState, compileManyFilesGetGenerationStateForTest -> compileFiles - compileFileGetGenerationStateForTest -> compileFile - compileFileGetClassFileFactoryForTest -> compileFileTo --- .../tests/CodegenTestsOnAndroidGenerator.java | 8 +- .../codegen/AbstractBlackBoxCodegenTest.java | 6 +- .../AbstractCheckLocalVariablesTableTest.java | 11 ++- ...bstractCompileKotlinAgainstKotlinTest.java | 15 ++-- .../codegen/AbstractDumpDeclarationsTest.kt | 9 +- .../codegen/AbstractLineNumberTest.java | 34 +++---- .../kotlin/codegen/CodegenTestUtil.java | 7 +- .../kotlin/codegen/GenerationUtils.java | 90 +++++++------------ .../codegen/flags/AbstractWriteFlagsTest.java | 19 ++-- .../jvm/compiler/AbstractLoadJavaTest.java | 9 +- .../jvm/compiler/LoadDescriptorUtil.java | 22 +++-- .../AbstractJvmRuntimeDescriptorLoaderTest.kt | 5 +- .../kotlin/resolve/ExpectedResolveData.java | 6 +- .../calls/AbstractResolvedCallsTest.kt | 6 +- .../AbstractConstraintSystemTest.kt | 2 +- .../kotlin/resolve/lazy/JvmResolveUtil.java | 63 +++++-------- .../kotlin/test/KotlinTestUtils.java | 4 +- .../kotlin/checkers/CheckerTestUtilTest.java | 14 +-- .../AbstractCompileJavaAgainstKotlinTest.java | 2 +- .../compiler/AbstractWriteSignatureTest.kt | 18 ++-- ...ompileKotlinAgainstCustomBinariesTest.java | 15 ++-- ...ctionDescriptorInExpressionRendererTest.kt | 2 +- .../CapturedTypeApproximationTest.kt | 2 +- .../kotlin/types/AbstractTypeBindingTest.kt | 2 +- .../types/DefaultModalityModifiersTest.java | 9 +- .../debugger/AbstractPositionManagerTest.java | 3 +- .../AbstractDiagnosticMessageTest.java | 2 +- ...tAndroidSyntheticPropertyDescriptorTest.kt | 7 +- 28 files changed, 147 insertions(+), 245 deletions(-) diff --git a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java index 9a6a64273fa..0621efcdb75 100644 --- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java +++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.java @@ -25,7 +25,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.backend.common.output.OutputFileCollection; import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; -import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.codegen.CodegenTestFiles; import org.jetbrains.kotlin.codegen.GenerationUtils; @@ -200,12 +199,7 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase { : isFullJdkAndRuntime ? " (full jdk and runtime)" : "") + "..."); OutputFileCollection outputFiles; try { - outputFiles = GenerationUtils.compileManyFilesGetGenerationStateForTest( - filesToCompile.iterator().next().getProject(), - filesToCompile, - new JvmPackagePartProvider(environment), - environment.getConfiguration() - ).getFactory(); + outputFiles = GenerationUtils.compileFiles(filesToCompile, environment).getFactory(); } catch (Throwable e) { throw new RuntimeException(e); diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java index 89648d057bf..12bd5b6b61e 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java @@ -25,7 +25,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; -import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt; import org.jetbrains.kotlin.config.CompilerConfiguration; @@ -97,10 +96,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase { loadMultiFiles(files); - classFileFactory = GenerationUtils.compileManyFilesGetGenerationStateForTest( - myEnvironment.getProject(), myFiles.getPsiFiles(), new JvmPackagePartProvider(myEnvironment), - myEnvironment.getConfiguration() - ).getFactory(); + classFileFactory = GenerationUtils.compileFiles(myFiles.getPsiFiles(), myEnvironment).getFactory(); if (javaSourceDir != null) { // If there are Java files, they should be compiled against the class files produced by Kotlin, so we dump them to the disk diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java index ff2e73a39c2..e0360084246 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java @@ -44,9 +44,8 @@ import java.util.regex.Pattern; */ public abstract class AbstractCheckLocalVariablesTableTest extends TestCaseWithTmpdir { - private File ktFile; - private KotlinCoreEnvironment jetCoreEnvironment; + private KotlinCoreEnvironment environment; public AbstractCheckLocalVariablesTableTest() { } @@ -54,12 +53,12 @@ public abstract class AbstractCheckLocalVariablesTableTest extends TestCaseWithT @Override protected void setUp() throws Exception { super.setUp(); - jetCoreEnvironment = KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable); + environment = KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable); } @Override protected void tearDown() throws Exception { - jetCoreEnvironment = null; + environment = null; super.tearDown(); } @@ -67,9 +66,9 @@ public abstract class AbstractCheckLocalVariablesTableTest extends TestCaseWithT ktFile = new File(ktFileName); String text = FileUtil.loadFile(ktFile, true); - KtFile psiFile = KotlinTestUtils.createFile(ktFile.getName(), text, jetCoreEnvironment.getProject()); + KtFile psiFile = KotlinTestUtils.createFile(ktFile.getName(), text, environment.getProject()); - OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment); + OutputFileCollection outputFiles = GenerationUtils.compileFile(psiFile, environment); String classAndMethod = parseClassAndMethodSignature(); String[] split = classAndMethod.split("\\."); diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java index 3f62ae4386f..a9d498f4064 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java @@ -22,7 +22,6 @@ import kotlin.Pair; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.cli.common.modules.ModuleBuilder; -import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; @@ -85,7 +84,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest return new Pair(factoryA, factoryB); } - protected void invokeBox(@NotNull String className) throws Exception { + private void invokeBox(@NotNull String className) throws Exception { Method box = createGeneratedClassLoader().loadClass(className).getMethod("box"); String result = (String) box.invoke(null); assertEquals("OK", result); @@ -100,7 +99,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest } @NotNull - protected ClassFileFactory compileA(@NotNull String fileName, @NotNull String content, List files) throws IOException { + private ClassFileFactory compileA(@NotNull String fileName, @NotNull String content, List files) throws IOException { Disposable compileDisposable = createDisposable("compileA"); KotlinCoreEnvironment environment = KotlinTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(compileDisposable, ConfigurationKind.ALL, getJdkKind(files)); @@ -108,7 +107,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest } @NotNull - protected ClassFileFactory compileB(@NotNull String fileName, @NotNull String content, List files) throws IOException { + private ClassFileFactory compileB(@NotNull String fileName, @NotNull String content, List files) throws IOException { CompilerConfiguration configurationWithADirInClasspath = KotlinTestUtils .compilerConfigurationForTests(ConfigurationKind.ALL, getJdkKind(files), KotlinTestUtils.getAnnotationsJar(), aDir); @@ -132,11 +131,11 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest ) throws IOException { KtFile psiFile = KotlinTestUtils.createFile(fileName, content, environment.getProject()); - ModuleVisibilityManager.SERVICE.getInstance(environment.getProject()).addModule(new ModuleBuilder("module for test", tmpdir.getAbsolutePath(), "test")); + ModuleVisibilityManager.SERVICE.getInstance(environment.getProject()).addModule( + new ModuleBuilder("module for test", tmpdir.getAbsolutePath(), "test") + ); - ClassFileFactory outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, environment); - - OutputUtilsKt.writeAllTo(outputFiles, outputDir); + ClassFileFactory outputFiles = GenerationUtils.compileFileTo(psiFile, environment, outputDir); Disposer.dispose(disposable); return outputFiles; diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractDumpDeclarationsTest.kt b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractDumpDeclarationsTest.kt index 0330278b473..353389b1c81 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractDumpDeclarationsTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractDumpDeclarationsTest.kt @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.codegen import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles -import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.psi.KtFile @@ -51,18 +50,14 @@ abstract class AbstractDumpDeclarationsTest : CodegenTestCase() { } private fun compileManyFilesGetDeclarationsDump(files: List): File { - val project = myEnvironment.project - val packagePartProvider = JvmPackagePartProvider(myEnvironment) - - val analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( - project, files, packagePartProvider) + val analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(files, myEnvironment) analysisResult.throwIfError() val dumpToFile = KotlinTestUtils.tmpDirForTest(this).resolve(this.name + ".json") val state = GenerationState( - project, ClassBuilderFactories.TEST, + myEnvironment.project, ClassBuilderFactories.TEST, analysisResult.moduleDescriptor, analysisResult.bindingContext, files, disableCallAssertions = false, diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java index 0599361bddf..1476ae5a3ab 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java @@ -25,11 +25,8 @@ import kotlin.collections.CollectionsKt; import kotlin.jvm.functions.Function1; 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.cli.common.output.outputUtils.OutputUtilsKt; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; -import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.KotlinTestUtils; @@ -47,15 +44,9 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir { - private static final String LINE_NUMBER_FUN = "lineNumber"; private static final Pattern TEST_LINE_NUMBER_PATTERN = Pattern.compile("^.*test." + LINE_NUMBER_FUN + "\\(\\).*$"); - @NotNull - private static String getTestDataPath() { - return KotlinTestUtils.getTestDataPathBase() + "/lineNumber"; - } - @NotNull private KotlinCoreEnvironment createEnvironment() { return KotlinCoreEnvironment.createForTests( @@ -70,13 +61,13 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir { super.setUp(); KotlinCoreEnvironment environment = createEnvironment(); - KtFile psiFile = KotlinTestUtils.createFile(LINE_NUMBER_FUN + ".kt", - "package test;\n\npublic fun " + LINE_NUMBER_FUN + "(): Int = 0\n", - environment.getProject()); + KtFile psiFile = KotlinTestUtils.createFile( + LINE_NUMBER_FUN + ".kt", + "package test;\n\npublic fun " + LINE_NUMBER_FUN + "(): Int = 0\n", + environment.getProject() + ); - OutputFileCollection outputFiles = - GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, environment); - OutputUtilsKt.writeAllTo(outputFiles, tmpdir); + GenerationUtils.compileFileTo(psiFile, environment, tmpdir); } @NotNull @@ -92,7 +83,9 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir { throw ExceptionUtilsKt.rethrow(e); } - return new Pair(KotlinTestUtils.createFile(file.getName(), text, environment.getProject()), environment); + return new Pair( + KotlinTestUtils.createFile(file.getName(), text, environment.getProject()), environment + ); } private void doTest(@NotNull String filename, boolean custom) { @@ -100,17 +93,17 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir { KtFile psiFile = fileAndEnv.getFirst(); KotlinCoreEnvironment environment = fileAndEnv.getSecond(); - GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile, environment); + ClassFileFactory classFileFactory = GenerationUtils.compileFile(psiFile, environment); if (custom) { - List actualLineNumbers = extractActualLineNumbersFromBytecode(state, false); + List actualLineNumbers = extractActualLineNumbersFromBytecode(classFileFactory, false); String text = psiFile.getText(); String newFileText = text.substring(0, text.indexOf("// ")) + getActualLineNumbersAsString(actualLineNumbers); KotlinTestUtils.assertEqualsToFile(new File(filename), newFileText); } else { List expectedLineNumbers = extractSelectedLineNumbersFromSource(psiFile); - List actualLineNumbers = extractActualLineNumbersFromBytecode(state, true); + List actualLineNumbers = extractActualLineNumbersFromBytecode(classFileFactory, true); assertSameElements(actualLineNumbers, expectedLineNumbers); } @@ -126,8 +119,7 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir { } @NotNull - private static List extractActualLineNumbersFromBytecode(@NotNull GenerationState state, boolean testFunInvoke) { - ClassFileFactory factory = state.getFactory(); + private static List extractActualLineNumbersFromBytecode(@NotNull ClassFileFactory factory, boolean testFunInvoke) { List actualLineNumbers = Lists.newArrayList(); for (OutputFile outputFile : ClassFileUtilsKt.getClassFiles(factory)) { ClassReader cr = new ClassReader(outputFile.asByteArray()); diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java index 5d517a10d83..9d37c5fd275 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestUtil.java @@ -21,7 +21,6 @@ import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.analyzer.AnalysisResult; -import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.kotlin.codegen.state.GenerationState; @@ -48,11 +47,7 @@ public class CodegenTestUtil { @NotNull public static ClassFileFactory generateFiles(@NotNull KotlinCoreEnvironment environment, @NotNull CodegenTestFiles files) { - AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( - environment.getProject(), - files.getPsiFiles(), - new JvmPackagePartProvider(environment) - ); + AnalysisResult analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(files.getPsiFiles(), environment); analysisResult.throwIfError(); AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext()); CompilerConfiguration configuration = environment.getConfiguration(); diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/GenerationUtils.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/GenerationUtils.java index cd570e4f7ff..9e911eda16d 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/GenerationUtils.java +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/GenerationUtils.java @@ -16,109 +16,79 @@ package org.jetbrains.kotlin.codegen; -import com.intellij.openapi.project.Project; +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.common.output.outputUtils.OutputUtilsKt; import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.config.CompilerConfiguration; -import org.jetbrains.kotlin.config.CompilerConfigurationKey; import org.jetbrains.kotlin.config.JVMConfigurationKeys; import org.jetbrains.kotlin.descriptors.PackagePartProvider; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil; +import java.io.File; import java.util.Collections; import java.util.List; public class GenerationUtils { - private GenerationUtils() { } @NotNull - public static ClassFileFactory compileFileGetClassFileFactoryForTest( - @NotNull KtFile psiFile, - @NotNull KotlinCoreEnvironment environment - ) { - return compileFileGetGenerationStateForTest(psiFile, environment).getFactory(); + public static ClassFileFactory compileFileTo(@NotNull KtFile ktFile, @NotNull KotlinCoreEnvironment environment, @NotNull File output) { + ClassFileFactory factory = compileFile(ktFile, environment); + OutputUtilsKt.writeAllTo(factory, output); + return factory; } @NotNull - public static GenerationState compileFileGetGenerationStateForTest( - @NotNull KtFile psiFile, - @NotNull KotlinCoreEnvironment environment - ) { + 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(); + } + + @NotNull + public static GenerationState compileFiles(@NotNull List files, @Nullable KotlinCoreEnvironment environment) { + PackagePartProvider packagePartProvider = + environment == null ? PackagePartProvider.Companion.getEMPTY() : new JvmPackagePartProvider(environment); + CompilerConfiguration configuration = + environment == null ? CompilerConfiguration.EMPTY : environment.getConfiguration(); AnalysisResult analysisResult = - JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile, new JvmPackagePartProvider(environment)); - return compileFilesGetGenerationState(psiFile.getProject(), analysisResult, Collections.singletonList(psiFile), false, null); + JvmResolveUtil.analyzeAndCheckForErrors(CollectionsKt.first(files).getProject(), files, configuration, packagePartProvider); + return compileFiles(analysisResult, files, false, configuration); } @NotNull - public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List files) { - return compileManyFilesGetGenerationStateForTest(project, files, PackagePartProvider.Companion.getEMPTY(), null); - } - - @NotNull - public static GenerationState compileManyFilesGetGenerationStateForTest( - @NotNull Project project, - @NotNull List files, - @NotNull PackagePartProvider packagePartProvider, - @Nullable CompilerConfiguration configuration - ) { - AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( - project, files, packagePartProvider); - return compileFilesGetGenerationState(project, analysisResult, files, false, configuration); - } - - @NotNull - public static GenerationState compileFilesGetGenerationState( - @NotNull Project project, - @NotNull AnalysisResult analysisResult, - @NotNull List files, - boolean useTypeTableInSerializer - ) { - return compileFilesGetGenerationState(project, analysisResult, files, useTypeTableInSerializer, null); - } - - @NotNull - public static GenerationState compileFilesGetGenerationState( - @NotNull Project project, + public static GenerationState compileFiles( @NotNull AnalysisResult analysisResult, @NotNull List files, boolean useTypeTableInSerializer, - @Nullable CompilerConfiguration configuration + @NotNull CompilerConfiguration configuration ) { analysisResult.throwIfError(); GenerationState state = new GenerationState( - project, ClassBuilderFactories.TEST, + CollectionsKt.first(files).getProject(), ClassBuilderFactories.TEST, analysisResult.getModuleDescriptor(), analysisResult.getBindingContext(), files, - getConfigurationValueOrDefault(configuration, JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, false), - getConfigurationValueOrDefault(configuration, JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, false), + configuration.get(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, false), + configuration.get(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, false), GenerationState.GenerateClassFilter.GENERATE_ALL, - getConfigurationValueOrDefault(configuration, JVMConfigurationKeys.DISABLE_INLINE, false), - getConfigurationValueOrDefault(configuration, JVMConfigurationKeys.DISABLE_OPTIMIZATION, false), + configuration.get(JVMConfigurationKeys.DISABLE_INLINE, false), + configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false), useTypeTableInSerializer, - getConfigurationValueOrDefault(configuration, JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS, false), + configuration.get(JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS, false), Collections.emptySet(), Collections.emptySet(), null, - configuration == null ? null : configuration.get(JVMConfigurationKeys.MODULE_NAME) + configuration.get(JVMConfigurationKeys.MODULE_NAME) ); KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION); return state; } - - private static T getConfigurationValueOrDefault( - @Nullable CompilerConfiguration configuration, - @NotNull CompilerConfigurationKey key, - T defaultValue - ) { - if (configuration == null) return defaultValue; - return configuration.get(key, defaultValue); - } } diff --git a/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java index 65c70d085c5..2a5218f1306 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java @@ -54,18 +54,17 @@ import static org.jetbrains.kotlin.test.InTextDirectivesUtils.findStringWithPref * FLAGS: ACC_STATIC, ACC_FINAL, ACC_PRIVATE */ public abstract class AbstractWriteFlagsTest extends KtUsefulTestCase { - - private KotlinCoreEnvironment jetCoreEnvironment; + private KotlinCoreEnvironment environment; @Override public void setUp() throws Exception { super.setUp(); - jetCoreEnvironment = KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY); + environment = KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY); } @Override protected void tearDown() throws Exception { - jetCoreEnvironment = null; + environment = null; super.tearDown(); } @@ -75,19 +74,17 @@ public abstract class AbstractWriteFlagsTest extends KtUsefulTestCase { String fileText = FileUtil.loadFile(ktFile, true); - KtFile psiFile = KotlinTestUtils.createFile(ktFile.getName(), fileText, jetCoreEnvironment.getProject()); + KtFile psiFile = KotlinTestUtils.createFile(ktFile.getName(), fileText, environment.getProject()); - OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment); + OutputFileCollection outputFiles = GenerationUtils.compileFile(psiFile, environment); List testedObjects = parseExpectedTestedObject(fileText); for (TestedObject testedObject : testedObjects) { String className = null; for (OutputFile outputFile : outputFiles.asList()) { String filePath = outputFile.getRelativePath(); - if (testedObject.isFullContainingClassName && filePath.equals(testedObject.containingClass + ".class")) { - className = filePath; - } - else if (!testedObject.isFullContainingClassName && filePath.startsWith(testedObject.containingClass)) { + if (testedObject.isFullContainingClassName && filePath.equals(testedObject.containingClass + ".class") || + !testedObject.isFullContainingClassName && filePath.startsWith(testedObject.containingClass)) { className = filePath; } } @@ -118,7 +115,7 @@ public abstract class AbstractWriteFlagsTest extends KtUsefulTestCase { private static List parseExpectedTestedObject(String testDescription) { String[] testObjectData = testDescription.substring(testDescription.indexOf("// TESTED_OBJECT_KIND")).split("\n\n"); - ArrayList objects = new ArrayList(); + List objects = new ArrayList(); for (String testData : testObjectData) { if (testData.isEmpty()) continue; 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 085e0574fc5..cc70808ebba 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -32,6 +32,7 @@ import org.jetbrains.kotlin.config.ContentRootsKt; import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.descriptors.ClassDescriptor; import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; +import org.jetbrains.kotlin.descriptors.ModuleDescriptor; import org.jetbrains.kotlin.descriptors.PackageViewDescriptor; import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.resolve.BindingContext; @@ -189,12 +190,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, getJdkKind(), getAnnotationsJar(), libraryOut), EnvironmentConfigFiles.JVM_CONFIG_FILES); - KtFile jetFile = KotlinTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject()); + KtFile ktFile = KotlinTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject()); - AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( - environment.getProject(), Collections.singleton(jetFile) - ); - PackageViewDescriptor packageView = result.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); + ModuleDescriptor module = JvmResolveUtil.analyzeAndCheckForErrors(Collections.singleton(ktFile), environment).getModuleDescriptor(); + PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); assertFalse(packageView.isEmpty()); validateAndCompareDescriptorWithFile(packageView, DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy( 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 5db6e580303..bdde7c513e4 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java @@ -26,7 +26,6 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult; import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt; import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; -import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.codegen.GenerationUtils; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; @@ -67,12 +66,11 @@ public final class LoadDescriptorUtil { @NotNull ConfigurationKind configurationKind, boolean useTypeTableInSerializer ) { - KtFilesAndAnalysisResult - filesAndResult = KtFilesAndAnalysisResult.createJetFilesAndAnalyze(kotlinFiles, disposable, configurationKind); + KtFilesAndAnalysisResult filesAndResult = + KtFilesAndAnalysisResult.createJetFilesAndAnalyze(kotlinFiles, disposable, configurationKind); AnalysisResult result = filesAndResult.getAnalysisResult(); - List files = filesAndResult.getKtFiles(); - GenerationState state = GenerationUtils.compileFilesGetGenerationState( - files.get(0).getProject(), result, files, useTypeTableInSerializer + GenerationState state = GenerationUtils.compileFiles( + result, filesAndResult.getKtFiles(), useTypeTableInSerializer, CompilerConfiguration.EMPTY ); OutputUtilsKt.writeAllTo(state.getFactory(), outDir); return result; @@ -131,22 +129,22 @@ public final class LoadDescriptorUtil { @NotNull Disposable disposable, @NotNull ConfigurationKind configurationKind ) { - final KotlinCoreEnvironment jetCoreEnvironment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, configurationKind); - List jetFiles = ContainerUtil.map(kotlinFiles, new Function() { + 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), jetCoreEnvironment.getProject()); + kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), environment.getProject() + ); } catch (IOException e) { throw new AssertionError(e); } } }); - AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( - jetCoreEnvironment.getProject(), jetFiles, new JvmPackagePartProvider(jetCoreEnvironment)); - return new KtFilesAndAnalysisResult(jetFiles, result); + AnalysisResult result = JvmResolveUtil.analyzeAndCheckForErrors(ktFiles, environment); + return new KtFilesAndAnalysisResult(ktFiles, result); } private final List ktFiles; diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt index d2f9b9391bc..0afc14d17b1 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.jvm.runtime import com.intellij.openapi.util.io.FileUtil -import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAllTo import org.jetbrains.kotlin.codegen.GenerationUtils import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime import org.jetbrains.kotlin.descriptors.* @@ -138,8 +137,8 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { val environment = KotlinTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea( myTestRootDisposable, ConfigurationKind.ALL, jdkKind ) - val jetFile = KotlinTestUtils.createFile(file.path, text, environment.project) - GenerationUtils.compileFileGetClassFileFactoryForTest(jetFile, environment).writeAllTo(tmpdir) + val ktFile = KotlinTestUtils.createFile(file.path, text, environment.project) + GenerationUtils.compileFileTo(ktFile, environment, tmpdir) } } } diff --git a/compiler/tests-common/org/jetbrains/kotlin/resolve/ExpectedResolveData.java b/compiler/tests-common/org/jetbrains/kotlin/resolve/ExpectedResolveData.java index 4563c5a9f8d..d1b31f90a56 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/resolve/ExpectedResolveData.java +++ b/compiler/tests-common/org/jetbrains/kotlin/resolve/ExpectedResolveData.java @@ -18,13 +18,11 @@ package org.jetbrains.kotlin.resolve; import com.google.common.collect.Maps; import com.google.common.collect.Sets; -import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiQualifiedNamedElement; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.analyzer.AnalysisResult; import org.jetbrains.kotlin.builtins.DefaultBuiltIns; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.descriptors.*; @@ -139,9 +137,7 @@ public abstract class ExpectedResolveData { return BindingContext.EMPTY; } - Project project = files.iterator().next().getProject(); - AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(project, files, environment); - return analysisResult.getBindingContext(); + return JvmResolveUtil.analyze(files, environment).getBindingContext(); } public final void checkResult(BindingContext bindingContext) { diff --git a/compiler/tests-common/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt b/compiler/tests-common/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt index c748487b7a9..fe842fc8631 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt @@ -50,10 +50,10 @@ abstract class AbstractResolvedCallsTest : KotlinTestWithEnvironment() { fun doTest(filePath: String) { val text = KotlinTestUtils.doLoadFile(File(filePath))!! - val jetFile = KtPsiFactory(project).createFile(text.replace("", "")) - val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(jetFile, environment).bindingContext + val ktFile = KtPsiFactory(project).createFile(text.replace("", "")) + val bindingContext = JvmResolveUtil.analyze(ktFile, environment).bindingContext - val (element, cachedCall) = buildCachedCall(bindingContext, jetFile, text) + val (element, cachedCall) = buildCachedCall(bindingContext, ktFile, text) val resolvedCall = if (cachedCall !is VariableAsFunctionResolvedCall) cachedCall else if ("(" == element?.text) cachedCall.functionCall diff --git a/compiler/tests-common/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt b/compiler/tests-common/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt index 01d50e7ae2c..7e390ef547b 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt @@ -67,7 +67,7 @@ abstract class AbstractConstraintSystemTest : KotlinTestWithEnvironment() { val fileName = "declarations.kt" val psiFile = KotlinTestUtils.createFile(fileName, KotlinTestUtils.doLoadFile(testDataPath, fileName), project) - val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile).bindingContext + val bindingContext = JvmResolveUtil.analyzeAndCheckForErrors(psiFile, environment).bindingContext return ConstraintSystemTestData(bindingContext, project, typeResolver) } diff --git a/compiler/tests-common/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java b/compiler/tests-common/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java index 3590e85038b..43e6335e060 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java +++ b/compiler/tests-common/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java @@ -35,55 +35,32 @@ public class JvmResolveUtil { public static String TEST_MODULE_NAME = "java-integration-test"; @NotNull - public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull KtFile file) { - return analyzeOneFileWithJavaIntegrationAndCheckForErrors(file, PackagePartProvider.Companion.getEMPTY()); + public static AnalysisResult analyzeAndCheckForErrors(@NotNull KtFile file, @NotNull KotlinCoreEnvironment environment) { + return analyzeAndCheckForErrors(Collections.singleton(file), environment); } @NotNull - public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull KtFile file, @NotNull PackagePartProvider provider) { - AnalyzingUtils.checkForSyntacticErrors(file); - - AnalysisResult analysisResult = analyzeOneFileWithJavaIntegration(file, provider); - - AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext()); - - return analysisResult; - } - - @NotNull - public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull KtFile file, @NotNull KotlinCoreEnvironment environment) { - return analyzeOneFileWithJavaIntegration(file, new JvmPackagePartProvider(environment)); - } - - @NotNull - private static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull KtFile file, @NotNull PackagePartProvider provider) { - return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), provider); - } - - @NotNull - public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull KtFile file) { - return analyzeOneFileWithJavaIntegration(file, PackagePartProvider.Companion.getEMPTY()); - } - - @NotNull - public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors( - @NotNull Project project, - @NotNull Collection files + public static AnalysisResult analyzeAndCheckForErrors( + @NotNull Collection files, + @NotNull KotlinCoreEnvironment environment ) { - return analyzeFilesWithJavaIntegrationAndCheckForErrors(project, files, PackagePartProvider.Companion.getEMPTY()); + return analyzeAndCheckForErrors( + environment.getProject(), files, environment.getConfiguration(), new JvmPackagePartProvider(environment) + ); } @NotNull - public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors( + public static AnalysisResult analyzeAndCheckForErrors( @NotNull Project project, @NotNull Collection files, + @NotNull CompilerConfiguration configuration, @NotNull PackagePartProvider packagePartProvider ) { for (KtFile file : files) { AnalyzingUtils.checkForSyntacticErrors(file); } - AnalysisResult analysisResult = analyzeFilesWithJavaIntegration(project, files, packagePartProvider); + AnalysisResult analysisResult = analyze(project, files, configuration, packagePartProvider); AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext()); @@ -91,23 +68,25 @@ public class JvmResolveUtil { } @NotNull - public static AnalysisResult analyzeFilesWithJavaIntegration( - @NotNull Project project, - @NotNull Collection files, - @NotNull KotlinCoreEnvironment environment - ) { - return analyzeFilesWithJavaIntegration(project, files, new JvmPackagePartProvider(environment)); + public static AnalysisResult analyze(@NotNull KtFile file, @NotNull KotlinCoreEnvironment environment) { + return analyze(Collections.singleton(file), environment); } @NotNull - private static AnalysisResult analyzeFilesWithJavaIntegration( + public static AnalysisResult analyze(@NotNull Collection files, @NotNull KotlinCoreEnvironment environment) { + return analyze(environment.getProject(), files, environment.getConfiguration(), new JvmPackagePartProvider(environment)); + } + + @NotNull + private static AnalysisResult analyze( @NotNull Project project, @NotNull Collection files, + @NotNull CompilerConfiguration configuration, @NotNull PackagePartProvider packagePartProvider ) { return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext( TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, TEST_MODULE_NAME), - files, new CliLightClassGenerationSupport.CliBindingTrace(), CompilerConfiguration.EMPTY, packagePartProvider + files, new CliLightClassGenerationSupport.CliBindingTrace(), configuration, packagePartProvider ); } } diff --git a/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java index b57b433f13e..c4be8165045 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java +++ b/compiler/tests-common/org/jetbrains/kotlin/test/KotlinTestUtils.java @@ -290,7 +290,7 @@ public class KotlinTestUtils { @NotNull public static AnalysisResult analyzeFile(@NotNull KtFile file, @NotNull KotlinCoreEnvironment environment) { - return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file, environment); + return JvmResolveUtil.analyze(file, environment); } @NotNull @@ -467,7 +467,7 @@ public class KotlinTestUtils { JvmContentRootsKt.addJvmClasspathRoots(configuration, classpath); - configuration.put(MODULE_NAME, "compilerConfigurationForTests"); + configuration.put(MODULE_NAME, JvmResolveUtil.TEST_MODULE_NAME); return configuration; } diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/CheckerTestUtilTest.java b/compiler/tests/org/jetbrains/kotlin/checkers/CheckerTestUtilTest.java index 6acf00bc2d9..9a7fa5f33e0 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/CheckerTestUtilTest.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/CheckerTestUtilTest.java @@ -48,7 +48,7 @@ public class CheckerTestUtilTest extends KotlinTestWithEnvironment { protected void doTest(TheTest theTest) throws Exception { String text = KotlinTestUtils.doLoadFile(getTestDataPath(), "test.kt"); - theTest.test(TestCheckerUtil.createCheckAndReturnPsiFile("test.kt", text, getProject())); + theTest.test(TestCheckerUtil.createCheckAndReturnPsiFile("test.kt", text, getProject()), getEnvironment()); } public void testEquals() throws Exception { @@ -142,12 +142,14 @@ public class CheckerTestUtilTest extends KotlinTestWithEnvironment { this.expected = expectedMessages; } - public void test(@NotNull PsiFile psiFile) { - BindingContext bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration( - (KtFile) psiFile) - .getBindingContext(); + public void test(@NotNull PsiFile psiFile, @NotNull KotlinCoreEnvironment environment) { + BindingContext bindingContext = + JvmResolveUtil.analyze((KtFile) psiFile, environment).getBindingContext(); - String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile, false, null)).toString(); + String expectedText = CheckerTestUtil.addDiagnosticMarkersToText( + psiFile, + CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile, false, null) + ).toString(); List diagnosedRanges = Lists.newArrayList(); CheckerTestUtil.parseDiagnosedRanges(expectedText, diagnosedRanges); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java index 54330cb5b8b..62e785ef84f 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java @@ -81,7 +81,7 @@ public abstract class AbstractCompileJavaAgainstKotlinTest extends TestCaseWithT EnvironmentConfigFiles.JVM_CONFIG_FILES ); - AnalysisResult exhaust = JvmResolveUtil.analyzeFilesWithJavaIntegration(environment.getProject(), Collections.emptySet(), environment); + AnalysisResult exhaust = JvmResolveUtil.analyze(Collections.emptySet(), environment); PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME); assertFalse("Nothing found in package " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, packageView.isEmpty()); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt index 4a29f05901a..4450e1a137e 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt @@ -20,7 +20,6 @@ import com.google.common.io.Closeables import com.google.common.io.Files import com.intellij.openapi.util.Disposer import com.intellij.openapi.util.io.FileUtil -import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAllTo import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.codegen.GenerationUtils import org.jetbrains.kotlin.test.ConfigurationKind @@ -36,22 +35,21 @@ import java.nio.charset.Charset import java.util.* import java.util.regex.MatchResult - abstract class AbstractWriteSignatureTest : TestCaseWithTmpdir() { - private var jetCoreEnvironment: KotlinCoreEnvironment? = null + private var environment: KotlinCoreEnvironment? = null override fun setUp() { super.setUp() - jetCoreEnvironment = - KotlinTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea( - myTestRootDisposable, ConfigurationKind.ALL, jdkKind) + environment = KotlinTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea( + myTestRootDisposable, ConfigurationKind.ALL, jdkKind + ) } protected open val jdkKind: TestJdkKind get() = TestJdkKind.MOCK_JDK override fun tearDown() { - jetCoreEnvironment = null + environment = null super.tearDown() } @@ -59,11 +57,9 @@ abstract class AbstractWriteSignatureTest : TestCaseWithTmpdir() { val ktFile = File(ktFileName) val text = FileUtil.loadFile(ktFile, true) - val psiFile = KotlinTestUtils.createFile(ktFile.name, text, jetCoreEnvironment!!.project) + val psiFile = KotlinTestUtils.createFile(ktFile.name, text, environment!!.project) - val outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment!!) - - outputFiles.writeAllTo(tmpdir) + GenerationUtils.compileFileTo(psiFile, environment!!, tmpdir) Disposer.dispose(myTestRootDisposable) diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java index 777406eeb7e..285b0415244 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.jvm.compiler; import com.google.common.collect.Iterables; -import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.io.FileUtil; import kotlin.Pair; @@ -68,7 +67,7 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject; import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile; public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { - public static final String TEST_DATA_PATH = "compiler/testData/compileKotlinAgainstCustomBinaries/"; + private static final String TEST_DATA_PATH = "compiler/testData/compileKotlinAgainstCustomBinaries/"; private static final Pattern JAVA_FILES = Pattern.compile(".*\\.java$"); @NotNull @@ -107,10 +106,10 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { @NotNull private PackageViewDescriptor analyzeFileToPackageView(@NotNull File... extraClassPath) throws IOException { - Project project = createEnvironment(Arrays.asList(extraClassPath)).getProject(); + KotlinCoreEnvironment environment = createEnvironment(Arrays.asList(extraClassPath)); - AnalysisResult result = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors( - KotlinTestUtils.loadJetFile(project, getTestDataFileWithExtension("kt")) + AnalysisResult result = JvmResolveUtil.analyzeAndCheckForErrors( + KotlinTestUtils.loadJetFile(environment.getProject(), getTestDataFileWithExtension("kt")), environment ); PackageViewDescriptor packageView = result.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME); @@ -271,10 +270,10 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { Arrays.asList("-d", tmpdir.getPath()) ); - Project project = createEnvironment(Collections.singletonList(tmpdir)).getProject(); + KotlinCoreEnvironment environment = createEnvironment(Collections.singletonList(tmpdir)); - AnalysisResult result = JvmResolveUtil.analyzeOneFileWithJavaIntegration( - KotlinTestUtils.loadJetFile(project, getTestDataFileWithExtension("kt")) + AnalysisResult result = JvmResolveUtil.analyze( + KotlinTestUtils.loadJetFile(environment.getProject(), getTestDataFileWithExtension("kt")), environment ); result.throwIfError(); diff --git a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt index cb39eaf02db..9490d6d5d39 100644 --- a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt @@ -38,7 +38,7 @@ abstract class AbstractFunctionDescriptorInExpressionRendererTest : KotlinTestWi fun doTest(path: String) { val fileText = FileUtil.loadFile(File(path), true) val file = KtPsiFactory(project).createFile(fileText) - val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(file).bindingContext + val bindingContext = JvmResolveUtil.analyze(file, environment).bindingContext val descriptors = arrayListOf() diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt index b7dd86be717..389c74f5b2a 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt @@ -51,7 +51,7 @@ class CapturedTypeApproximationTest : KotlinTestWithEnvironment() { fun analyzeTestFile(testType: String) = run { val test = declarationsText.replace("#TestType#", testType) val testFile = KtPsiFactory(project).createFile(test) - val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(testFile).bindingContext + val bindingContext = JvmResolveUtil.analyze(testFile, environment).bindingContext val functions = bindingContext.getSliceContents(BindingContext.FUNCTION) val functionFoo = functions.values.firstOrNull { it.name.asString() == "foo" } ?: throw AssertionError("Function 'foo' is not declared") diff --git a/compiler/tests/org/jetbrains/kotlin/types/AbstractTypeBindingTest.kt b/compiler/tests/org/jetbrains/kotlin/types/AbstractTypeBindingTest.kt index 76396173bc7..c125b8ce480 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/AbstractTypeBindingTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/types/AbstractTypeBindingTest.kt @@ -38,7 +38,7 @@ abstract class AbstractTypeBindingTest : KotlinTestWithEnvironment() { val testFile = File(path) val testKtFile = loadJetFile(project, testFile) - val analyzeResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(project, listOf(testKtFile), environment) + val analyzeResult = JvmResolveUtil.analyze(testKtFile, environment) val testDeclaration = testKtFile.declarations.last()!! as KtCallableDeclaration diff --git a/compiler/tests/org/jetbrains/kotlin/types/DefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/kotlin/types/DefaultModalityModifiersTest.java index 7b93e8684c1..5e960e235b7 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/DefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/DefaultModalityModifiersTest.java @@ -85,12 +85,11 @@ public class DefaultModalityModifiersTest extends KotlinTestWithEnvironment { @NotNull private LexicalScope createScope(@NotNull MemberScope libraryScope) { - KtFile file = KtPsiFactoryKt - .KtPsiFactory(getProject()).createFile("abstract class C { abstract fun foo(); abstract val a: Int }"); - List declarations = file.getDeclarations(); - KtDeclaration aClass = declarations.get(0); + KtFile file = + KtPsiFactoryKt.KtPsiFactory(getProject()).createFile("abstract class C { abstract fun foo(); abstract val a: Int }"); + KtDeclaration aClass = file.getDeclarations().get(0); assert aClass instanceof KtClass; - AnalysisResult bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(file); + AnalysisResult bindingContext = JvmResolveUtil.analyzeAndCheckForErrors(file, getEnvironment()); final DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass); return new LexicalScopeImpl(ScopeUtilsKt.memberScopeAsImportingScope(libraryScope), root, false, null, LexicalScopeKind.SYNTHETIC, LocalRedeclarationChecker.DO_NOTHING.INSTANCE, diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractPositionManagerTest.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractPositionManagerTest.java index c135d05885d..d0a883cdc70 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractPositionManagerTest.java +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/AbstractPositionManagerTest.java @@ -129,13 +129,14 @@ public abstract class AbstractPositionManagerTest extends KotlinLightCodeInsight private void performTest() { Project project = getProject(); List files = new ArrayList(PluginJetFilesProvider.allFilesInProject(project)); + if (files.isEmpty()) return; final List breakpoints = Lists.newArrayList(); for (KtFile file : files) { breakpoints.addAll(extractBreakpointsInfo(file, file.getText())); } - GenerationState state = GenerationUtils.compileManyFilesGetGenerationStateForTest(project, files); + GenerationState state = GenerationUtils.compileFiles(files, null); Map referencesByName = getReferenceMap(state.getFactory()); diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java index a441246cf9b..3ebf5a59499 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java @@ -74,7 +74,7 @@ public abstract class AbstractDiagnosticMessageTest extends KotlinTestWithEnviro @NotNull protected AnalysisResult analyze(@NotNull KtFile file) { - return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file); + return JvmResolveUtil.analyze(file, getEnvironment()); } public void doTest(String filePath) throws Exception { diff --git a/plugins/plugins-tests/tests/org/jetbrains/kotlin/lang/resolve/android/test/AbstractAndroidSyntheticPropertyDescriptorTest.kt b/plugins/plugins-tests/tests/org/jetbrains/kotlin/lang/resolve/android/test/AbstractAndroidSyntheticPropertyDescriptorTest.kt index 26202d53e1a..1d1952b761d 100644 --- a/plugins/plugins-tests/tests/org/jetbrains/kotlin/lang/resolve/android/test/AbstractAndroidSyntheticPropertyDescriptorTest.kt +++ b/plugins/plugins-tests/tests/org/jetbrains/kotlin/lang/resolve/android/test/AbstractAndroidSyntheticPropertyDescriptorTest.kt @@ -16,10 +16,8 @@ package org.jetbrains.kotlin.lang.resolve.android.test -import com.intellij.testFramework.UsefulTestCase import org.jetbrains.kotlin.android.synthetic.res.AndroidPackageFragmentProviderExtension import org.jetbrains.kotlin.android.synthetic.res.AndroidSyntheticPackageFragmentProvider -import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider import org.jetbrains.kotlin.renderer.DescriptorRenderer import org.jetbrains.kotlin.resolve.MemberComparator import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension @@ -32,7 +30,6 @@ import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase import java.io.File abstract class AbstractAndroidSyntheticPropertyDescriptorTest : KtUsefulTestCase() { - fun doTest(path: String) { val config = KotlinTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.ANDROID_API) val env = createAndroidTestEnvironment(config, getResPaths(path)) @@ -40,7 +37,7 @@ abstract class AbstractAndroidSyntheticPropertyDescriptorTest : KtUsefulTestCase val ext = PackageFragmentProviderExtension.getInstances(project).first { it is AndroidPackageFragmentProviderExtension } - val analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(project, listOf(), JvmPackagePartProvider(env)) + val analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(listOf(), env) val fragmentProvider = ext.getPackageFragmentProvider(project, analysisResult.moduleDescriptor, LockBasedStorageManager.NO_LOCKS, KotlinTestUtils.DUMMY_EXCEPTION_ON_ERROR_TRACE, null) as AndroidSyntheticPackageFragmentProvider @@ -55,4 +52,4 @@ abstract class AbstractAndroidSyntheticPropertyDescriptorTest : KtUsefulTestCase KotlinTestUtils.assertEqualsToFile(File(path, "result.txt"), expected) } -} \ No newline at end of file +}