Minor: fix JetCoreEnvironment#(createForProduction, createForTests) call sites for JVM.

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()
 

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.*;
-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.repl.ReplFromTerminal;
 import org.jetbrains.jet.codegen.CompilationException;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
@@ -73,7 +70,7 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
         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<K2JVMCompilerArguments> {
             }
             else if (arguments.script) {
                 List<String> 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;

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" +

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(

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) {

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();

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(
+        return JetCoreEnvironment.createForTests(
-                configurationKind, jdkKind, getAnnotationsJar()));
+                disposable,
+                compilerConfigurationForTests(configurationKind, jdkKind, getAnnotationsJar()),
+                EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     public static File findMockJdkRtJar() {

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));

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) {

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(
+        return JetCoreEnvironment.createForTests(getTestRootDisposable(),
-                ConfigurationKind.ALL,
+                                                 JetTestUtils.compilerConfigurationForTests(
-                TestJdkKind.MOCK_JDK,
+                                                         ConfigurationKind.ALL,
-                Arrays.asList(JetTestUtils.getAnnotationsJar()),
+                                                         TestJdkKind.MOCK_JDK,
-                Arrays.asList(javaFilesDir)
+                                                         Arrays.asList(JetTestUtils.getAnnotationsJar()),
-        ));
+                                                         Arrays.asList(javaFilesDir)
+                                                 ),
+                                                 EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 }

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<M, F> 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

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(
+        myEnvironment = JetCoreEnvironment.createForTests(
-                ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, Arrays.asList(JetTestUtils.getAnnotationsJar()), classPath));
+                getTestRootDisposable(),
+                JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK,
+                                                           Arrays.asList(JetTestUtils.getAnnotationsJar()), classPath),
+                EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         loadFiles(ArrayUtil.toStringArray(sourceFiles));
 

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(
+        myEnvironment = JetCoreEnvironment.createForTests(
-                ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), javaClassesTempDirectory));
+                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);

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 {

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(
+        myEnvironment = JetCoreEnvironment.createForTests(
-                ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, junitJar));
+                getTestRootDisposable(),
+                JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, junitJar),
+                EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     public void testKt2344() throws Exception {

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
+        return JetCoreEnvironment.createForTests(
-                .compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir));
+                myTestRootDisposable,
+                JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK,
+                                                           JetTestUtils.getAnnotationsJar(), tmpdir),
+                EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     @Override

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) {

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(
+        myEnvironment =
-                ConfigurationKind.ALL, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar(), javaClassesTempDirectory
+                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();

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),
+        JetCoreEnvironment environment =
-                      getTestRootDisposable());
+                JetCoreEnvironment.createForTests(getTestRootDisposable(), configurationWithADirInClasspath, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+
+        return compileKotlin(ktBFile, bDir, environment, getTestRootDisposable());
     }
 
     private static OutputFileCollection compileKotlin(

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,
+                getTestRootDisposable(),
-                                                                       getAnnotationsJar(), libraryOut)
+                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(

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

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

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

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"

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);

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<File>): 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<File>): List<TestModule> {

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(
+            jetCoreEnvironment = JetCoreEnvironment.createForTests(
-                    ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), jar));
+                    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());
             }

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) {

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)
     }
 }

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

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 for validating std lib>")
             module.addDependencyOnModule(module)

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]