From e6b69e48d9cea39b238b0c24f210d838b3156509 Mon Sep 17 00:00:00 2001 From: Zalim Bashorov Date: Wed, 26 Nov 2014 14:49:30 +0300 Subject: [PATCH] Minor: fix JetCoreEnvironment#(createForProduction, createForTests) call sites for JVM. --- .../src/BuiltInsSerializer.kt | 3 ++- .../jetbrains/jet/cli/jvm/K2JVMCompiler.java | 13 ++++++------- .../jvm/compiler/CompileEnvironmentUtil.java | 3 ++- .../cli/jvm/compiler/JetCoreEnvironment.java | 17 ----------------- .../compiler/KotlinToJVMBytecodeCompiler.java | 3 ++- .../jet/cli/jvm/repl/ReplInterpreter.java | 4 +++- .../tests/org/jetbrains/jet/JetTestUtils.java | 7 +++++-- .../tests/org/jetbrains/jet/ScriptTest.java | 4 +++- .../jet/asJava/KotlinAsJavaTestBase.java | 3 ++- .../AbstractJetDiagnosticsTestWithStdLib.java | 15 +++++++++------ .../KotlinMultiFileTestWithWithJava.java | 3 ++- .../AbstractTopLevelMembersInvocationTest.java | 8 ++++++-- .../ClassPathInParentClassLoaderTest.java | 8 ++++++-- .../codegen/GenerateNotNullAssertionsTest.java | 3 ++- .../jet/codegen/JUnitUsageGenTest.java | 7 +++++-- .../jetbrains/jet/codegen/LineNumberTest.java | 8 ++++++-- .../org/jetbrains/jet/codegen/TestlibTest.java | 3 ++- .../generated/AbstractBlackBoxCodegenTest.java | 12 ++++++++---- .../AbstractCompileKotlinAgainstKotlinTest.java | 8 +++++--- .../jet/jvm/compiler/AbstractLoadJavaTest.java | 11 +++++++---- .../AndroidSdkAnnotationsValidityTest.java | 3 ++- .../CompileKotlinAgainstCustomBinariesTest.java | 3 ++- .../compiler/JdkAnnotationsValidityTest.java | 3 ++- .../jet/jvm/compiler/KotlinClassFinderTest.kt | 4 +++- .../jet/jvm/compiler/LoadDescriptorUtil.java | 4 +++- .../MultiModuleJavaAnalysisCustomTest.kt | 3 ++- ...ResolveDescriptorsFromExternalLibraries.java | 10 +++++++--- .../jetbrains/jet/lang/psi/JetPsiUtilTest.java | 3 ++- .../jet/lang/psi/JetSimpleNameExpressionTest.kt | 3 ++- .../jet/resolve/MutableDiagnosticsTest.kt | 3 ++- .../kotlin/NoInternalVisibilityInStdLibTest.kt | 3 ++- .../src/test/kotlin/test/kotlin/psiUtilsTest.kt | 3 ++- 32 files changed, 114 insertions(+), 74 deletions(-) diff --git a/compiler/builtins-serializer/src/BuiltInsSerializer.kt b/compiler/builtins-serializer/src/BuiltInsSerializer.kt index f0fbb18c3b6..7a335d9aa7f 100644 --- a/compiler/builtins-serializer/src/BuiltInsSerializer.kt +++ b/compiler/builtins-serializer/src/BuiltInsSerializer.kt @@ -43,6 +43,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmPlatformParameters import org.jetbrains.jet.analyzer.ModuleContent import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) { private var totalSize = 0 @@ -73,7 +74,7 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) { val sourceRoots = srcDirs map { it.path } configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, sourceRoots) - val environment = JetCoreEnvironment.createForTests(disposable, configuration) + val environment = JetCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) val files = environment.getSourceFiles() diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java index 156a30a441b..803878d6b98 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java @@ -26,10 +26,7 @@ import org.jetbrains.jet.cli.common.ExitCode; import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments; import org.jetbrains.jet.cli.common.messages.*; import org.jetbrains.jet.cli.common.modules.ModuleScriptData; -import org.jetbrains.jet.cli.jvm.compiler.CommandLineScriptUtils; -import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil; -import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; +import org.jetbrains.jet.cli.jvm.compiler.*; import org.jetbrains.jet.cli.jvm.repl.ReplFromTerminal; import org.jetbrains.jet.codegen.CompilationException; import org.jetbrains.jet.config.CommonConfigurationKeys; @@ -73,7 +70,7 @@ public class K2JVMCompiler extends CLICompiler { CompilerConfiguration configuration = new CompilerConfiguration(); configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector); - IncrementalCacheProvider incrementalCacheProvider = (IncrementalCacheProvider) services.get(IncrementalCacheProvider.class); + IncrementalCacheProvider incrementalCacheProvider = services.get(IncrementalCacheProvider.class); if (incrementalCacheProvider != null) { configuration.put(JVMConfigurationKeys.INCREMENTAL_CACHE_PROVIDER, incrementalCacheProvider); } @@ -152,11 +149,13 @@ public class K2JVMCompiler extends CLICompiler { } else if (arguments.script) { List scriptArgs = arguments.freeArgs.subList(1, arguments.freeArgs.size()); - JetCoreEnvironment environment = JetCoreEnvironment.createForProduction(rootDisposable, configuration); + JetCoreEnvironment environment = + JetCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); KotlinToJVMBytecodeCompiler.compileAndExecuteScript(paths, environment, scriptArgs); } else { - JetCoreEnvironment environment = JetCoreEnvironment.createForProduction(rootDisposable, configuration); + JetCoreEnvironment environment = + JetCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); KotlinToJVMBytecodeCompiler.compileBunchOfSources(environment, jar, outputDir, arguments.includeRuntime); } return OK; diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java index be7cd4c1104..aa9dbce95d2 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java @@ -116,7 +116,8 @@ public class CompileEnvironmentUtil { Disposable disposable = Disposer.newDisposable(); try { - JetCoreEnvironment scriptEnvironment = JetCoreEnvironment.createForProduction(disposable, configuration); + JetCoreEnvironment scriptEnvironment = + JetCoreEnvironment.createForProduction(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); GenerationState generationState = KotlinToJVMBytecodeCompiler.analyzeAndGenerate(scriptEnvironment); if (generationState == null) { throw new CompileEnvironmentException("Module script " + moduleScriptFile + " analyze failed:\n" + diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java index 7b082f2550a..3fa4e5979b4 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java @@ -78,14 +78,6 @@ public class JetCoreEnvironment { private static JavaCoreApplicationEnvironment ourApplicationEnvironment; private static int ourProjectCount = 0; - @NotNull - public static JetCoreEnvironment createForProduction( - @NotNull Disposable parentDisposable, - @NotNull CompilerConfiguration configuration - ) { - return createForProduction(parentDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); - } - @NotNull public static JetCoreEnvironment createForProduction( @NotNull Disposable parentDisposable, @@ -113,15 +105,6 @@ public class JetCoreEnvironment { return environment; } - @TestOnly - @NotNull - public static JetCoreEnvironment createForTests( - @NotNull Disposable parentDisposable, - @NotNull CompilerConfiguration configuration - ) { - return createForTests(parentDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); - } - @TestOnly @NotNull public static JetCoreEnvironment createForTests( diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 5c5b1f1d7bc..112919054a2 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -117,7 +117,8 @@ public class KotlinToJVMBytecodeCompiler { Disposable parentDisposable = Disposer.newDisposable(); JetCoreEnvironment environment = null; try { - environment = JetCoreEnvironment.createForProduction(parentDisposable, compilerConfiguration); + environment = JetCoreEnvironment + .createForProduction(parentDisposable, compilerConfiguration, EnvironmentConfigFiles.JVM_CONFIG_FILES); AnalysisResult result = analyze(environment); if (result == null) { diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index de391eb28a5..87a49093af1 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -37,6 +37,7 @@ import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport; import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.cli.common.messages.MessageCollectorToString; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.ClassBuilderFactories; @@ -101,7 +102,8 @@ public class ReplInterpreter { private final ScriptMutableDeclarationProviderFactory scriptDeclarationFactory; public ReplInterpreter(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) { - JetCoreEnvironment environment = JetCoreEnvironment.createForProduction(disposable, configuration); + JetCoreEnvironment environment = + JetCoreEnvironment.createForProduction(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); Project project = environment.getProject(); this.psiFileFactory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project); this.trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(); diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index a987ed71b7d..a5cbabb65a7 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -49,6 +49,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.jet.config.CommonConfigurationKeys; @@ -277,8 +278,10 @@ public class JetTestUtils { @NotNull ConfigurationKind configurationKind, @NotNull TestJdkKind jdkKind ) { - return JetCoreEnvironment.createForTests(disposable, compilerConfigurationForTests( - configurationKind, jdkKind, getAnnotationsJar())); + return JetCoreEnvironment.createForTests( + disposable, + compilerConfigurationForTests(configurationKind, jdkKind, getAnnotationsJar()), + EnvironmentConfigFiles.JVM_CONFIG_FILES); } public static File findMockJdkRtJar() { diff --git a/compiler/tests/org/jetbrains/jet/ScriptTest.java b/compiler/tests/org/jetbrains/jet/ScriptTest.java index 14db31964c5..e5aa24136f7 100644 --- a/compiler/tests/org/jetbrains/jet/ScriptTest.java +++ b/compiler/tests/org/jetbrains/jet/ScriptTest.java @@ -23,6 +23,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.cli.common.CLIConfigurationKeys; import org.jetbrains.jet.cli.common.messages.*; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; import org.jetbrains.jet.codegen.CompilationException; @@ -82,7 +83,8 @@ public class ScriptTest { configuration.addAll(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, scriptDefinitions); configuration.put(JVMConfigurationKeys.SCRIPT_PARAMETERS, scriptParameters); - JetCoreEnvironment environment = JetCoreEnvironment.createForProduction(rootDisposable, configuration); + JetCoreEnvironment environment = + JetCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); try { JetScriptDefinitionProvider.getInstance(environment.getProject()).markFileAsScript(environment.getSourceFiles().get(0)); diff --git a/compiler/tests/org/jetbrains/jet/asJava/KotlinAsJavaTestBase.java b/compiler/tests/org/jetbrains/jet/asJava/KotlinAsJavaTestBase.java index 5ae214dfd90..05a4cda75db 100644 --- a/compiler/tests/org/jetbrains/jet/asJava/KotlinAsJavaTestBase.java +++ b/compiler/tests/org/jetbrains/jet/asJava/KotlinAsJavaTestBase.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.asJava; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CommonConfigurationKeys; import org.jetbrains.jet.config.CompilerConfiguration; @@ -38,7 +39,7 @@ public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment { extraConfiguration(configuration); - return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); + return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); } protected void extraConfiguration(@NotNull CompilerConfiguration configuration) { diff --git a/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTestWithStdLib.java b/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTestWithStdLib.java index 413227be3de..64597d07230 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTestWithStdLib.java +++ b/compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTestWithStdLib.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.checkers; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import java.io.File; @@ -28,11 +29,13 @@ public abstract class AbstractJetDiagnosticsTestWithStdLib extends AbstractJetDi @Override protected JetCoreEnvironment createEnvironment() { File javaFilesDir = createJavaFilesDir(); - return JetCoreEnvironment.createForTests(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests( - ConfigurationKind.ALL, - TestJdkKind.MOCK_JDK, - Arrays.asList(JetTestUtils.getAnnotationsJar()), - Arrays.asList(javaFilesDir) - )); + return JetCoreEnvironment.createForTests(getTestRootDisposable(), + JetTestUtils.compilerConfigurationForTests( + ConfigurationKind.ALL, + TestJdkKind.MOCK_JDK, + Arrays.asList(JetTestUtils.getAnnotationsJar()), + Arrays.asList(javaFilesDir) + ), + EnvironmentConfigFiles.JVM_CONFIG_FILES); } } diff --git a/compiler/tests/org/jetbrains/jet/checkers/KotlinMultiFileTestWithWithJava.java b/compiler/tests/org/jetbrains/jet/checkers/KotlinMultiFileTestWithWithJava.java index 5dbd6420d26..41b5f513509 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/KotlinMultiFileTestWithWithJava.java +++ b/compiler/tests/org/jetbrains/jet/checkers/KotlinMultiFileTestWithWithJava.java @@ -24,6 +24,7 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CommonConfigurationKeys; import org.jetbrains.jet.config.CompilerConfiguration; @@ -73,7 +74,7 @@ public abstract class KotlinMultiFileTestWithWithJava extends JetLiteFixtu if (kotlinSourceRoot != null) { configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, kotlinSourceRoot.getPath()); } - return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); + return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); } @Nullable diff --git a/compiler/tests/org/jetbrains/jet/codegen/AbstractTopLevelMembersInvocationTest.java b/compiler/tests/org/jetbrains/jet/codegen/AbstractTopLevelMembersInvocationTest.java index 1fcd967995e..4176a08d2c5 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/AbstractTopLevelMembersInvocationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/AbstractTopLevelMembersInvocationTest.java @@ -21,6 +21,7 @@ import com.intellij.util.ArrayUtil; import com.intellij.util.Processor; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.*; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import java.io.File; @@ -62,8 +63,11 @@ public abstract class AbstractTopLevelMembersInvocationTest extends AbstractByte assert !sourceFiles.isEmpty() : getTestName(true) + " should contain at least one .kt file"; Collections.sort(sourceFiles); - myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests( - ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, Arrays.asList(JetTestUtils.getAnnotationsJar()), classPath)); + myEnvironment = JetCoreEnvironment.createForTests( + getTestRootDisposable(), + JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, + Arrays.asList(JetTestUtils.getAnnotationsJar()), classPath), + EnvironmentConfigFiles.JVM_CONFIG_FILES); loadFiles(ArrayUtil.toStringArray(sourceFiles)); diff --git a/compiler/tests/org/jetbrains/jet/codegen/ClassPathInParentClassLoaderTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClassPathInParentClassLoaderTest.java index d72d6a2ca48..ec242705842 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ClassPathInParentClassLoaderTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ClassPathInParentClassLoaderTest.java @@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import java.io.File; @@ -40,8 +41,11 @@ public class ClassPathInParentClassLoaderTest extends CodegenTestCase { public void testKt2781() throws Exception { File javaClassesTempDirectory = compileJava("classPathInParentClassLoader/kt2781.java"); - myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests( - ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), javaClassesTempDirectory)); + myEnvironment = JetCoreEnvironment.createForTests( + getTestRootDisposable(), + JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, + JetTestUtils.getAnnotationsJar(), javaClassesTempDirectory), + EnvironmentConfigFiles.JVM_CONFIG_FILES); loadFile("classPathInParentClassLoader/kt2781.kt"); assertThrows(generateFunction(), IllegalAccessError.class, null); diff --git a/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java b/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java index c46db0b03b4..266e1a78f18 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/GenerateNotNullAssertionsTest.java @@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.*; import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.resolve.java.PackageClassUtils; @@ -48,7 +49,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase { configuration.put(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, disableCallAssertions); configuration.put(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, disableParamAssertions); - myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); + myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); } private void doTestCallAssertions(boolean disableCallAssertions) throws Exception { diff --git a/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java index 5b1b558272d..1cb7cf2f8c0 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.codegen; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.junit.Test; @@ -36,8 +37,10 @@ public class JUnitUsageGenTest extends CodegenTestCase { throw new AssertionError("JUnit jar wasn't found"); } - myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests( - ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, junitJar)); + myEnvironment = JetCoreEnvironment.createForTests( + getTestRootDisposable(), + JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, junitJar), + EnvironmentConfigFiles.JVM_CONFIG_FILES); } public void testKt2344() throws Exception { diff --git a/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java b/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java index 9a352703e34..ece2338e3dc 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/LineNumberTest.java @@ -21,6 +21,7 @@ import com.google.common.collect.Maps; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.org.objectweb.asm.*; import org.jetbrains.jet.*; import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; @@ -53,8 +54,11 @@ public class LineNumberTest extends TestCaseWithTmpdir { @NotNull private JetCoreEnvironment createEnvironment() { - return JetCoreEnvironment.createForTests(myTestRootDisposable, JetTestUtils - .compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir)); + return JetCoreEnvironment.createForTests( + myTestRootDisposable, + JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, + JetTestUtils.getAnnotationsJar(), tmpdir), + EnvironmentConfigFiles.JVM_CONFIG_FILES); } @Override diff --git a/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java b/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java index 44533c6bd9c..e4079b23455 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.cli.common.CLIConfigurationKeys; import org.jetbrains.jet.cli.common.messages.MessageCollectorPlainTextToStream; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; @@ -95,7 +96,7 @@ public class TestlibTest extends UsefulTestCase { configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, new MessageCollectorPlainTextToStream(System.out, MessageCollectorPlainTextToStream.NON_VERBOSE)); - myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); + myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); generationState = KotlinToJVMBytecodeCompiler.analyzeAndGenerate(myEnvironment); if (generationState == null) { diff --git a/compiler/tests/org/jetbrains/jet/codegen/generated/AbstractBlackBoxCodegenTest.java b/compiler/tests/org/jetbrains/jet/codegen/generated/AbstractBlackBoxCodegenTest.java index 9f90f558bea..4eb5158c1f6 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/generated/AbstractBlackBoxCodegenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/generated/AbstractBlackBoxCodegenTest.java @@ -26,6 +26,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.CodegenTestCase; import org.jetbrains.jet.codegen.GenerationUtils; @@ -109,9 +110,12 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase { String ktFile = relativePath(new File(ktFileFullPath)); File javaClassesTempDirectory = compileJava(ktFile.replaceFirst("\\.kt$", ".java")); - myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests( - ConfigurationKind.ALL, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar(), javaClassesTempDirectory - )); + myEnvironment = + JetCoreEnvironment.createForTests(getTestRootDisposable(), + JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.FULL_JDK, + JetTestUtils.getAnnotationsJar(), + javaClassesTempDirectory), + EnvironmentConfigFiles.JVM_CONFIG_FILES); loadFile(ktFile); blackBox(); @@ -140,7 +144,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase { ConfigurationKind.ALL, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar() ); configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, dirFile); - myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); + myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); loadFiles(ArrayUtil.toStringArray(ktFilePaths)); classFileFactory = GenerationUtils.compileManyFilesGetGenerationStateForTest(myEnvironment.getProject(), myFiles.getPsiFiles()).getFactory(); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java index 46e25fd432d..2d7517cdf91 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java @@ -20,10 +20,10 @@ import com.intellij.openapi.Disposable; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.io.FileUtil; import com.intellij.util.ArrayUtil; -import com.intellij.util.Processor; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.*; import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationUtils; @@ -131,8 +131,10 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends TestCaseWit CompilerConfiguration configurationWithADirInClasspath = JetTestUtils .compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), aDir); - return compileKotlin(ktBFile, bDir, JetCoreEnvironment.createForTests(getTestRootDisposable(), configurationWithADirInClasspath), - getTestRootDisposable()); + JetCoreEnvironment environment = + JetCoreEnvironment.createForTests(getTestRootDisposable(), configurationWithADirInClasspath, EnvironmentConfigFiles.JVM_CONFIG_FILES); + + return compileKotlin(ktBFile, bDir, environment, getTestRootDisposable()); } private static OutputFileCollection compileKotlin( diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index 365921555be..e5f45b5d791 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CommonConfigurationKeys; import org.jetbrains.jet.config.CompilerConfiguration; @@ -143,7 +144,8 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, tmpdir); configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, Arrays.asList(sourcesDir.getAbsolutePath())); configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File("compiler/tests")); // for @ExpectLoadError annotation - JetCoreEnvironment environment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); + JetCoreEnvironment environment = + JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(); ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule(); @@ -184,9 +186,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { ); JetCoreEnvironment environment = JetCoreEnvironment.createForTests( - getTestRootDisposable(), compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, - getAnnotationsJar(), libraryOut) - ); + getTestRootDisposable(), + compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, getAnnotationsJar(), libraryOut), + EnvironmentConfigFiles.JVM_CONFIG_FILES); + JetFile jetFile = JetTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject()); AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AndroidSdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AndroidSdkAnnotationsValidityTest.java index 33ae4367c58..fd483f8af96 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AndroidSdkAnnotationsValidityTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AndroidSdkAnnotationsValidityTest.java @@ -22,6 +22,7 @@ import com.intellij.openapi.Disposable; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -39,7 +40,7 @@ public class AndroidSdkAnnotationsValidityTest extends AbstractSdkAnnotationsVal protected JetCoreEnvironment createEnvironment(Disposable parentDisposable) { CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests( ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.ANDROID_API, JetTestUtils.getAnnotationsJar()); - return JetCoreEnvironment.createForTests(parentDisposable, configuration); + return JetCoreEnvironment.createForTests(parentDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); } @Override diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java index 02db3bd8102..bebeac557a3 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java @@ -27,6 +27,7 @@ import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport; import org.jetbrains.jet.cli.common.messages.MessageCollectorPlainTextToStream; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -99,7 +100,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests( ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, extras.toArray(new File[extras.size()])); - return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration); + return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java index 51c2d31707e..aa5ab5d52e5 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/JdkAnnotationsValidityTest.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -70,7 +71,7 @@ public class JdkAnnotationsValidityTest extends AbstractSdkAnnotationsValidityTe CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests( ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar()); configuration.add(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY, new File("ideaSDK/lib/jdkAnnotations.jar")); - return JetCoreEnvironment.createForTests(parentDisposable, configuration); + return JetCoreEnvironment.createForTests(parentDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); } @Override diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/KotlinClassFinderTest.kt b/compiler/tests/org/jetbrains/jet/jvm/compiler/KotlinClassFinderTest.kt index 0ee70054139..c1a7c56549a 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/KotlinClassFinderTest.kt +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/KotlinClassFinderTest.kt @@ -28,6 +28,7 @@ import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaClassImpl import kotlin.test.assertEquals import kotlin.test.assertNotNull +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles public class KotlinClassFinderTest : KotlinTestWithEnvironmentManagement() { fun testNestedClass() { @@ -38,7 +39,8 @@ public class KotlinClassFinderTest : KotlinTestWithEnvironmentManagement() { val environment = JetCoreEnvironment.createForTests(getTestRootDisposable()!!, JetTestUtils.compilerConfigurationForTests( - ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir)) + ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir), + EnvironmentConfigFiles.JVM_CONFIG_FILES) val project = environment.getProject() val className = "test.A.B.C" diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index ef1ec9e2624..988fb115ad5 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.GenerationUtils; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; @@ -89,7 +90,8 @@ public final class LoadDescriptorUtil { javaRoot, new File("compiler/tests") // for @ExpectLoadError annotation ); - JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration); + JetCoreEnvironment jetCoreEnvironment = + JetCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(); InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace, true); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt b/compiler/tests/org/jetbrains/jet/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt index 722e970199b..d07c03360d3 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt @@ -41,6 +41,7 @@ import java.util.HashMap import org.jetbrains.jet.analyzer.ModuleContent import org.jetbrains.jet.lang.types.ErrorUtils import org.jetbrains.jet.lang.resolve.descriptorUtil.module +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() { @@ -71,7 +72,7 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() { private fun createEnvironment(moduleDirs: Array): JetCoreEnvironment { val configuration = CompilerConfiguration() configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, moduleDirs.toList()) - return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration) + return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) } private fun setupModules(environment: JetCoreEnvironment, moduleDirs: Array): List { diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java index 84a433b369a..031e99af216 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.TimeUtils; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; @@ -156,13 +157,16 @@ public class ResolveDescriptorsFromExternalLibraries { JetCoreEnvironment jetCoreEnvironment; if (jar != null) { - jetCoreEnvironment = JetCoreEnvironment.createForTests(junk, JetTestUtils.compilerConfigurationForTests( - ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), jar)); + jetCoreEnvironment = JetCoreEnvironment.createForTests( + junk, + JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK, + JetTestUtils.getAnnotationsJar(), jar), + EnvironmentConfigFiles.JVM_CONFIG_FILES); } else { CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK); - jetCoreEnvironment = JetCoreEnvironment.createForTests(junk, configuration); + jetCoreEnvironment = JetCoreEnvironment.createForTests(junk, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); if (!findRtJar().equals(jar)) { throw new RuntimeException("rt.jar mismatch: " + jar + ", " + findRtJar()); } diff --git a/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java b/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java index 9e370cc62cf..3f4c679e4a1 100644 --- a/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/psi/JetPsiUtilTest.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.psi; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.jet.JetLiteFixture; +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.resolve.ImportPath; @@ -98,7 +99,7 @@ public class JetPsiUtilTest extends JetLiteFixture { @Override protected JetCoreEnvironment createEnvironment() { - return JetCoreEnvironment.createForTests(getTestRootDisposable(), new CompilerConfiguration()); + return JetCoreEnvironment.createForTests(getTestRootDisposable(), new CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES); } private ImportPath getImportPathFromParsed(String text) { diff --git a/compiler/tests/org/jetbrains/jet/lang/psi/JetSimpleNameExpressionTest.kt b/compiler/tests/org/jetbrains/jet/lang/psi/JetSimpleNameExpressionTest.kt index be97e73f010..744c0075d01 100644 --- a/compiler/tests/org/jetbrains/jet/lang/psi/JetSimpleNameExpressionTest.kt +++ b/compiler/tests/org/jetbrains/jet/lang/psi/JetSimpleNameExpressionTest.kt @@ -21,6 +21,7 @@ import org.jetbrains.jet.JetLiteFixture import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment import org.jetbrains.jet.config.CompilerConfiguration import org.jetbrains.jet.lang.psi.psiUtil.getReceiverExpression +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles public class JetSimpleNameExpressionTest() : JetLiteFixture() { public fun testGetReceiverExpressionIdentifier() { @@ -35,6 +36,6 @@ public class JetSimpleNameExpressionTest() : JetLiteFixture() { Assert.assertEquals(expected, expression.getOperationReference().getReceiverExpression()!!.getText()) } override fun createEnvironment(): JetCoreEnvironment { - return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, CompilerConfiguration()) + return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES) } } diff --git a/compiler/tests/org/jetbrains/jet/resolve/MutableDiagnosticsTest.kt b/compiler/tests/org/jetbrains/jet/resolve/MutableDiagnosticsTest.kt index a366136552e..0110ed6bbe5 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/MutableDiagnosticsTest.kt +++ b/compiler/tests/org/jetbrains/jet/resolve/MutableDiagnosticsTest.kt @@ -27,10 +27,11 @@ import org.jetbrains.jet.config.CompilerConfiguration import org.jetbrains.jet.lang.resolve.BindingTrace import org.jetbrains.jet.lang.resolve.Diagnostics import org.jetbrains.jet.lang.resolve.MutableDiagnosticsWithSuppression +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles class MutableDiagnosticsTest : KotlinTestWithEnvironment() { override fun createEnvironment(): JetCoreEnvironment? { - return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, CompilerConfiguration()) + return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES) } private val BindingTrace.diagnostics: Diagnostics diff --git a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt index 53ffa62860c..8bbce5c7c64 100644 --- a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt +++ b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt @@ -16,6 +16,7 @@ import org.junit.Test import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles import com.intellij.openapi.util.Disposer import org.jetbrains.jet.config.CompilerConfiguration import org.jetbrains.jet.lang.resolve.name.FqName @@ -113,7 +114,7 @@ class NoInternalVisibilityInStdLibTest { configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "../src/generated") configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots()) - val environment = JetCoreEnvironment.createForProduction(it, configuration) + val environment = JetCoreEnvironment.createForProduction(it, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) val module = TopDownAnalyzerFacadeForJVM.createJavaModule("") module.addDependencyOnModule(module) diff --git a/libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt b/libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt index cc074b0a911..8fe634725c9 100644 --- a/libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt +++ b/libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt @@ -2,6 +2,7 @@ package test.kotlin import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment +import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.jet.config.CompilerConfiguration import com.intellij.openapi.Disposable import com.intellij.openapi.util.Disposer @@ -33,7 +34,7 @@ class PsiUtilsTest { val configuration = CompilerConfiguration() configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots()) - environment = JetCoreEnvironment.createForTests(rootDisposable, configuration) + environment = JetCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) } [After]