Got rid of storing CompilerDependencies in JetCoreEnvironment (storing CompilerSpecialMode instead).

compiler/android-tests/tests/org/jetbrains/jet/compiler/android/CodegenTestsOnAndroidGenerator.java

@@ -159,7 +159,7 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase {
         JetFile psiFile = JetPsiFactory.createFile(jetEnvironment.getProject(), text);
         ClassFileFactory factory;
         try {
-            factory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetEnvironment.getCompilerDependencies().getCompilerSpecialMode());
+            factory = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetEnvironment.getCompilerSpecialMode());
         }
         catch (Throwable e) {
             throw new RuntimeException("Cannot compile: " + filePath + "\n" + text, e);

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java

@@ -65,12 +65,12 @@ public class JetCoreEnvironment extends JavaCoreEnvironment {
     }
 
     @NotNull
-    private final CompilerDependencies compilerDependencies;
+    private final CompilerSpecialMode compilerSpecialMode;
 
     public JetCoreEnvironment(Disposable parentDisposable, @NotNull CompilerDependencies compilerDependencies) {
         super(parentDisposable);
 
-        this.compilerDependencies = compilerDependencies;
+        this.compilerSpecialMode = compilerDependencies.getCompilerSpecialMode();
 
         registerFileType(JetFileType.INSTANCE, "kt");
         registerFileType(JetFileType.INSTANCE, "kts");
@@ -189,8 +189,8 @@ public class JetCoreEnvironment extends JavaCoreEnvironment {
     }
 
     @NotNull
-    public CompilerDependencies getCompilerDependencies() {
+    public CompilerSpecialMode getCompilerSpecialMode() {
-        return compilerDependencies;
+        return compilerSpecialMode;
     }
 
     public void configure(@NotNull CompilerConfiguration compilerConfiguration) {

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -19,7 +19,6 @@ package org.jetbrains.jet.cli.jvm.compiler;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.PsiFile;
 import com.intellij.testFramework.LightVirtualFile;
 import com.intellij.util.LocalTimeCounter;
@@ -37,7 +36,6 @@ import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation;
 import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
-import org.jetbrains.jet.lang.resolve.java.CompilerDependencies;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
@@ -260,7 +258,7 @@ public class KotlinToJVMBytecodeCompiler {
 
     @Nullable
     public static GenerationState analyzeAndGenerate(K2JVMCompileEnvironmentConfiguration configuration) {
-        return analyzeAndGenerate(configuration, configuration.getEnvironment().getCompilerDependencies().getCompilerSpecialMode().isStubs());
+        return analyzeAndGenerate(configuration, configuration.getEnvironment().getCompilerSpecialMode().isStubs());
     }
 
     @Nullable
@@ -299,7 +297,7 @@ public class KotlinToJVMBytecodeCompiler {
                                 environment.getSourceFiles(),
                                 scriptParameters,
                                 filesToAnalyzeCompletely,
-                                configuration.getEnvironment().getCompilerDependencies().getCompilerSpecialMode());
+                                configuration.getEnvironment().getCompilerSpecialMode());
                     }
                 }, environment.getSourceFiles()
         );
@@ -322,7 +320,7 @@ public class KotlinToJVMBytecodeCompiler {
         };
         GenerationState generationState = new GenerationState(project, ClassBuilderFactories.binaries(stubs), backendProgress,
                                                               exhaust, environment.getSourceFiles(),
-                                                              configuration.getEnvironment().getCompilerDependencies().getCompilerSpecialMode());
+                                                              configuration.getEnvironment().getCompilerSpecialMode());
         generationState.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
 
         List<CompilerPlugin> plugins = configuration.getCompilerPlugins();

compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java

@@ -247,7 +247,7 @@ public class ReplInterpreter {
 
         GenerationState generationState = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false), backendProgress,
                 AnalyzeExhaust.success(trace.getBindingContext()), Collections.singletonList(psiFile),
-                jetCoreEnvironment.getCompilerDependencies().getCompilerSpecialMode());
+                jetCoreEnvironment.getCompilerSpecialMode());
         generationState.compileScript(psiFile.getScript(), scriptClassName, earierScripts, CompilationErrorHandler.THROW_EXCEPTION);
 
         for (String file : generationState.getFactory().files()) {

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java

@@ -176,7 +176,7 @@ public class JetDiagnosticsTest extends JetLiteFixture {
         BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
                 getProject(), jetFiles, Collections.<AnalyzerScriptParameter>emptyList(),
                 Predicates.<PsiFile>alwaysTrue(),
-                myEnvironment.getCompilerDependencies().getCompilerSpecialMode())
+                myEnvironment.getCompilerSpecialMode())
                     .getBindingContext();
 
         boolean ok = true;

compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java

@@ -259,7 +259,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
                 myFiles.getPsiFiles(),
                 myFiles.getScriptParameterTypes(),
                 Predicates.<PsiFile>alwaysTrue(),
-                myEnvironment.getCompilerDependencies().getCompilerSpecialMode());
+                myEnvironment.getCompilerSpecialMode());
         analyzeExhaust.throwIfError();
         AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
         GenerationState state = new GenerationState(myEnvironment.getProject(), classBuilderFactory, analyzeExhaust, myFiles.getPsiFiles());

compiler/tests/org/jetbrains/jet/jvm/compiler/ReadJavaBinaryClassTest.java

@@ -90,7 +90,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir {
 
         BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
                 psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
-                jetCoreEnvironment.getCompilerDependencies().getCompilerSpecialMode())
+                jetCoreEnvironment.getCompilerSpecialMode())
                     .getBindingContext();
         return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel(Name.identifier("test")));
     }

compiler/tests/org/jetbrains/jet/jvm/compiler/ReadKotlinBinaryClassTest.java

@@ -93,7 +93,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
         jetCoreEnvironment.addToClasspath(new File("out/production/runtime"));
 
         InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(
-                jetCoreEnvironment.getCompilerDependencies().getCompilerSpecialMode(), jetCoreEnvironment.getProject());
+                jetCoreEnvironment.getCompilerSpecialMode(), jetCoreEnvironment.getProject());
         JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
         NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
         

compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java

@@ -92,7 +92,7 @@ public class DescriptorRendererTest extends JetLiteFixture {
         AnalyzeExhaust analyzeExhaust =
                 AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(
                         (JetFile) psiFile, Collections.<AnalyzerScriptParameter>emptyList(),
-                        myEnvironment.getCompilerDependencies().getCompilerSpecialMode());
+                        myEnvironment.getCompilerSpecialMode());
         final BindingContext bindingContext = analyzeExhaust.getBindingContext();
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
         psiFile.acceptChildren(new JetVisitorVoid() {

compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java

@@ -156,7 +156,7 @@ public abstract class ExpectedResolveData {
 
         AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, Collections.<AnalyzerScriptParameter>emptyList(),
                 Predicates.<PsiFile>alwaysTrue(),
-                jetCoreEnvironment.getCompilerDependencies().getCompilerSpecialMode());
+                jetCoreEnvironment.getCompilerSpecialMode());
         BindingContext bindingContext = analyzeExhaust.getBindingContext();
         for (Diagnostic diagnostic : bindingContext.getDiagnostics()) {
             if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) {

compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java

@@ -125,7 +125,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
     private PsiClass findClass(String qualifiedName) {
         Project project = getProject();
         InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(
-                myEnvironment.getCompilerDependencies().getCompilerSpecialMode(), project);
+                myEnvironment.getCompilerSpecialMode(), project);
         return injector.getPsiClassFinder().findPsiClass(new FqName(qualifiedName), PsiClassFinder.RuntimeClassesHandleMode.THROW);
     }
 

compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java

@@ -68,7 +68,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
             assert aClass instanceof JetClass;
             AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file,
                     Collections.<AnalyzerScriptParameter>emptyList(),
-                    myEnvironment.getCompilerDependencies().getCompilerSpecialMode());
+                    myEnvironment.getCompilerSpecialMode());
             DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
             WritableScopeImpl scope = new WritableScopeImpl(
                     libraryScope, root, RedeclarationHandler.DO_NOTHING, "JetDefaultModalityModifiersTest");

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -594,7 +594,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
                 scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports");
         writableScope.importScope(library.getLibraryScope());
         InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(
-                myEnvironment.getCompilerDependencies().getCompilerSpecialMode(), getProject());
+                myEnvironment.getCompilerSpecialMode(), getProject());
         JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
         writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT,
                 DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope());