Rename JetCoreEnvironment -> KotlinCoreEnvironemnt

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

@@ -24,7 +24,7 @@ import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.CodegenTestFiles;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
@@ -129,14 +129,14 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase {
         private final boolean isFullJdk;
 
         public List<JetFile> files = new ArrayList<JetFile>();
-        private JetCoreEnvironment environment;
+        private KotlinCoreEnvironment environment;
 
         private FilesWriter(boolean isFullJdk) {
             this.isFullJdk = isFullJdk;
             environment = createEnvironment(isFullJdk);
         }
 
-        private JetCoreEnvironment createEnvironment(boolean isFullJdk) {
+        private KotlinCoreEnvironment createEnvironment(boolean isFullJdk) {
             return isFullJdk
                     ? JetTestUtils.createEnvironmentWithFullJdk(myTestRootDisposable)
                     : JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS);

compiler/builtins-serializer/src/BuiltInsSerializer.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.serialization.builtins
 import java.io.File
 import com.intellij.openapi.util.Disposer
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.serialization.*
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
@@ -83,7 +83,7 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
             configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, path)
         }
 
-        val environment = JetCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+        val environment = KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 
         val files = environment.getSourceFiles()
 

compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java

@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.CompilerJarLocator;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.Services;
@@ -102,8 +102,8 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         }
 
         configuration.addAll(CommonConfigurationKeys.SOURCE_ROOTS_KEY, arguments.freeArgs);
-        JetCoreEnvironment environmentForJS =
-                JetCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES);
+        KotlinCoreEnvironment environmentForJS =
+                KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES);
 
         Project project = environmentForJS.getProject();
         List<JetFile> sourcesFiles = environmentForJS.getSourceFiles();

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.java

@@ -179,13 +179,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, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+                KotlinCoreEnvironment environment =
+                        KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
                 KotlinToJVMBytecodeCompiler.compileAndExecuteScript(configuration, paths, environment, scriptArgs);
             }
             else {
-                JetCoreEnvironment environment =
-                        JetCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+                KotlinCoreEnvironment environment =
+                        KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
                 KotlinToJVMBytecodeCompiler.compileBunchOfSources(environment, jar, outputDir, arguments.includeRuntime);
             }
             return OK;

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java

@@ -109,8 +109,8 @@ public class CompileEnvironmentUtil {
 
         Disposable disposable = Disposer.newDisposable();
         try {
-            JetCoreEnvironment scriptEnvironment =
-                    JetCoreEnvironment.createForProduction(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+            KotlinCoreEnvironment scriptEnvironment =
+                    KotlinCoreEnvironment.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/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -80,7 +80,7 @@ import java.util.ArrayList
 import java.util.Comparator
 import kotlin.platform.platformStatic
 
-public class JetCoreEnvironment private(
+public class KotlinCoreEnvironment private(
         parentDisposable: Disposable, 
         applicationEnvironment: JavaCoreApplicationEnvironment, 
         configuration: CompilerConfiguration
@@ -204,7 +204,7 @@ public class JetCoreEnvironment private(
 
         platformStatic public fun createForProduction(
                 parentDisposable: Disposable, configuration: CompilerConfiguration, configFilePaths: List<String>
-        ): JetCoreEnvironment {
+        ): KotlinCoreEnvironment {
             // JPS may run many instances of the compiler in parallel (there's an option for compiling independent modules in parallel in IntelliJ)
             // All projects share the same ApplicationEnvironment, and when the last project is disposed, the ApplicationEnvironment is disposed as well
             Disposer.register(parentDisposable, object : Disposable {
@@ -216,7 +216,7 @@ public class JetCoreEnvironment private(
                     }
                 }
             })
-            val environment = JetCoreEnvironment(parentDisposable, getOrCreateApplicationEnvironmentForProduction(configuration, configFilePaths), configuration)
+            val environment = KotlinCoreEnvironment(parentDisposable, getOrCreateApplicationEnvironmentForProduction(configuration, configFilePaths), configuration)
 
             synchronized (APPLICATION_LOCK) {
                 ourProjectCount++
@@ -226,9 +226,9 @@ public class JetCoreEnvironment private(
 
         TestOnly platformStatic public fun createForTests(
                 parentDisposable: Disposable, configuration: CompilerConfiguration, extensionConfigs: List<String>
-        ): JetCoreEnvironment {
+        ): KotlinCoreEnvironment {
             // Tests are supposed to create a single project and dispose it right after use
-            return JetCoreEnvironment(parentDisposable, createApplicationEnvironment(parentDisposable, configuration, extensionConfigs), configuration)
+            return KotlinCoreEnvironment(parentDisposable, createApplicationEnvironment(parentDisposable, configuration, extensionConfigs), configuration)
         }
 
         private fun getOrCreateApplicationEnvironmentForProduction(configuration: CompilerConfiguration, configFilePaths: List<String>): JavaCoreApplicationEnvironment {

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

@@ -118,9 +118,9 @@ public class KotlinToJVMBytecodeCompiler {
         CompilerConfiguration compilerConfiguration = createCompilerConfiguration(configuration, chunk, directory);
 
         Disposable parentDisposable = Disposer.newDisposable();
-        JetCoreEnvironment environment = null;
+        KotlinCoreEnvironment environment = null;
         try {
-            environment = JetCoreEnvironment
+            environment = KotlinCoreEnvironment
                     .createForProduction(parentDisposable, compilerConfiguration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
             AnalysisResult result = analyze(environment);
@@ -199,7 +199,7 @@ public class KotlinToJVMBytecodeCompiler {
     }
 
     public static boolean compileBunchOfSources(
-            @NotNull JetCoreEnvironment environment,
+            @NotNull KotlinCoreEnvironment environment,
             @Nullable File jar,
             @Nullable File outputDir,
             boolean includeRuntime
@@ -224,7 +224,7 @@ public class KotlinToJVMBytecodeCompiler {
     public static void compileAndExecuteScript(
             @NotNull CompilerConfiguration configuration,
             @NotNull KotlinPaths paths,
-            @NotNull JetCoreEnvironment environment,
+            @NotNull KotlinCoreEnvironment environment,
             @NotNull List<String> scriptArgs
     ) {
         Class<?> scriptClass = compileScript(configuration, paths, environment);
@@ -245,7 +245,7 @@ public class KotlinToJVMBytecodeCompiler {
     public static Class<?> compileScript(
             @NotNull CompilerConfiguration configuration,
             @NotNull KotlinPaths paths,
-            @NotNull JetCoreEnvironment environment
+            @NotNull KotlinCoreEnvironment environment
     ) {
         List<AnalyzerScriptParameter> scriptParameters = environment.getConfiguration().getList(JVMConfigurationKeys.SCRIPT_PARAMETERS);
         if (!scriptParameters.isEmpty()) {
@@ -278,7 +278,7 @@ public class KotlinToJVMBytecodeCompiler {
     }
 
     @Nullable
-    public static GenerationState analyzeAndGenerate(@NotNull JetCoreEnvironment environment) {
+    public static GenerationState analyzeAndGenerate(@NotNull KotlinCoreEnvironment environment) {
         AnalysisResult result = analyze(environment);
 
         if (result == null) {
@@ -291,7 +291,7 @@ public class KotlinToJVMBytecodeCompiler {
     }
 
     @Nullable
-    private static AnalysisResult analyze(@NotNull final JetCoreEnvironment environment) {
+    private static AnalysisResult analyze(@NotNull final KotlinCoreEnvironment environment) {
         MessageCollector collector = environment.getConfiguration().get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY);
         assert collector != null;
 
@@ -331,7 +331,7 @@ public class KotlinToJVMBytecodeCompiler {
 
     @NotNull
     private static GenerationState generate(
-            @NotNull JetCoreEnvironment environment,
+            @NotNull KotlinCoreEnvironment environment,
             @NotNull AnalysisResult result,
             @NotNull List<JetFile> sourceFiles,
             @Nullable String moduleId,

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

@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollectorToString;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories;
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler;
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade;
@@ -103,8 +103,8 @@ public class ReplInterpreter {
     private final ScriptMutableDeclarationProviderFactory scriptDeclarationFactory;
 
     public ReplInterpreter(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) {
-        JetCoreEnvironment environment =
-                JetCoreEnvironment.createForProduction(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        KotlinCoreEnvironment environment =
+                KotlinCoreEnvironment.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/kotlin/asJava/AbstractKotlinLightClassTest.java

@@ -22,7 +22,7 @@ import com.intellij.psi.impl.compiled.ClsElementImpl;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.checkers.KotlinMultiFileTestWithWithJava;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
 import java.io.File;
@@ -42,7 +42,7 @@ public abstract class AbstractKotlinLightClassTest extends KotlinMultiFileTestWi
     }
 
     @NotNull
-    public static JavaElementFinder createFinder(@NotNull JetCoreEnvironment environment) throws IOException {
+    public static JavaElementFinder createFinder(@NotNull KotlinCoreEnvironment environment) throws IOException {
         // We need to resolve all the files in order too fill in the trace that sits inside LightClassGenerationSupport
         JetTestUtils.resolveAllKotlinFiles(environment);
 

compiler/tests/org/jetbrains/kotlin/asJava/KotlinAsJavaTestBase.java

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.asJava;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
@@ -30,7 +30,7 @@ public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment {
     protected JavaElementFinder finder;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         CompilerConfiguration configuration = new CompilerConfiguration();
 
         for (File root : getKotlinSourceRoots()) {
@@ -39,7 +39,7 @@ public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment {
 
         extraConfiguration(configuration);
 
-        return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     protected void extraConfiguration(@NotNull CompilerConfiguration configuration) {

compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudocodeTest.java

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeUtil;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionImpl;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.LocalFunctionDeclarationInstruction;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
@@ -45,7 +45,7 @@ public abstract class AbstractPseudocodeTest extends KotlinTestWithEnvironment {
     }
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
     }
 

compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java

@@ -20,7 +20,7 @@ import com.intellij.openapi.Disposable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -52,8 +52,8 @@ public abstract class AbstractJetDiagnosticsTestWithJsStdLib extends AbstractJet
 
     @Override
     @NotNull
-    protected JetCoreEnvironment createEnvironment(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) {
-        return JetCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES);
+    protected KotlinCoreEnvironment createEnvironment(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) {
+        return KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES);
     }
 
     @Override

compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithStdLib.java

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.checkers;
 
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
@@ -27,9 +27,9 @@ import java.util.Arrays;
 
 public abstract class AbstractJetDiagnosticsTestWithStdLib extends AbstractJetDiagnosticsTest {
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         File javaFilesDir = createJavaFilesDir();
-        return JetCoreEnvironment.createForTests(getTestRootDisposable(),
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable(),
                                                  JetTestUtils.compilerConfigurationForTests(
                                                          ConfigurationKind.ALL,
                                                          TestJdkKind.MOCK_JDK,

compiler/tests/org/jetbrains/kotlin/checkers/CheckerTestUtilTest.java

@@ -22,7 +22,7 @@ import com.intellij.psi.PsiFile;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.checkers.CheckerTestUtil.DiagnosedRange;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
@@ -41,7 +41,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
     }
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
     }
 

compiler/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithWithJava.java

@@ -22,7 +22,7 @@ import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -63,7 +63,7 @@ public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixtu
     }
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         File javaFilesDir = createJavaFilesDir();
         CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.JDK_AND_ANNOTATIONS,
@@ -79,8 +79,8 @@ public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixtu
     }
 
     @NotNull
-    protected JetCoreEnvironment createEnvironment(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) {
-        return JetCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+    protected KotlinCoreEnvironment createEnvironment(@NotNull Disposable disposable, @NotNull CompilerConfiguration configuration) {
+        return KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     @Nullable

compiler/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java

@@ -25,7 +25,7 @@ import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir;
@@ -46,7 +46,7 @@ import java.util.regex.Pattern;
 public abstract class AbstractCheckLocalVariablesTableTest extends TestCaseWithTmpdir {
 
     private File ktFile;
-    private JetCoreEnvironment jetCoreEnvironment;
+    private KotlinCoreEnvironment jetCoreEnvironment;
 
     public AbstractCheckLocalVariablesTableTest() {
     }

compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.FqName;
@@ -57,8 +57,8 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
     }
 
     @NotNull
-    private JetCoreEnvironment createEnvironment() {
-        return JetCoreEnvironment.createForTests(
+    private KotlinCoreEnvironment createEnvironment() {
+        return KotlinCoreEnvironment.createForTests(
                 myTestRootDisposable,
                 JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK,
                                                            JetTestUtils.getAnnotationsJar(), tmpdir),
@@ -69,7 +69,7 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
     public void setUp() throws Exception {
         super.setUp();
 
-        JetCoreEnvironment environment = createEnvironment();
+        KotlinCoreEnvironment environment = createEnvironment();
         JetFile psiFile = JetTestUtils.createFile(LINE_NUMBER_FUN + ".kt",
                                                "package test;\n\npublic fun " + LINE_NUMBER_FUN + "(): Int = 0\n",
                                                environment.getProject());
@@ -81,7 +81,7 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
     @NotNull
     private JetFile createPsiFile(@NotNull String filename) {
         File file = new File(filename);
-        JetCoreEnvironment environment = createEnvironment();
+        KotlinCoreEnvironment environment = createEnvironment();
 
         String text;
         try {

compiler/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java

@@ -21,7 +21,7 @@ import com.intellij.util.ArrayUtil;
 import com.intellij.util.Processor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.MockLibraryUtil;
@@ -66,7 +66,7 @@ public abstract class AbstractTopLevelMembersInvocationTest extends AbstractByte
         assert !sourceFiles.isEmpty() : getTestName(true) + " should contain at least one .kt file";
         Collections.sort(sourceFiles);
 
-        myEnvironment = JetCoreEnvironment.createForTests(
+        myEnvironment = KotlinCoreEnvironment.createForTests(
                 getTestRootDisposable(),
                 JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK,
                                                            Arrays.asList(JetTestUtils.getAnnotationsJar()), classPath),

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

@@ -23,7 +23,7 @@ import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.name.FqName;
@@ -53,7 +53,7 @@ import static org.jetbrains.kotlin.codegen.CodegenTestUtil.*;
 import static org.jetbrains.kotlin.load.kotlin.PackageClassUtils.getPackageClassFqName;
 
 public abstract class CodegenTestCase extends UsefulTestCase {
-    protected JetCoreEnvironment myEnvironment;
+    protected KotlinCoreEnvironment myEnvironment;
     protected CodegenTestFiles myFiles;
     protected ClassFileFactory classFileFactory;
     protected GeneratedClassLoader initializedClassLoader;

compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java

@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.Progress;
@@ -48,7 +48,7 @@ public class CodegenTestUtil {
     private CodegenTestUtil() {}
 
     @NotNull
-    public static ClassFileFactory generateFiles(@NotNull JetCoreEnvironment environment, @NotNull CodegenTestFiles files) {
+    public static ClassFileFactory generateFiles(@NotNull KotlinCoreEnvironment environment, @NotNull CodegenTestFiles files) {
         AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
                 environment.getProject(),
                 files.getPsiFiles()

compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.FqName;
@@ -54,7 +54,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, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     private void doTestCallAssertions(boolean disableCallAssertions) throws Exception {

compiler/tests/org/jetbrains/kotlin/codegen/JUnitUsageGenTest.java

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen;
 
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
@@ -37,7 +37,7 @@ public class JUnitUsageGenTest extends CodegenTestCase {
             throw new AssertionError("JUnit jar wasn't found");
         }
 
-        myEnvironment = JetCoreEnvironment.createForTests(
+        myEnvironment = KotlinCoreEnvironment.createForTests(
                 getTestRootDisposable(),
                 JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, junitJar),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES);

compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollectorPlainTextToStream;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
@@ -60,7 +60,7 @@ public class TestlibTest extends UsefulTestCase {
     private GeneratedClassLoader classLoader;
     private JetTypeMapper typeMapper;
     private GenerationState generationState;
-    private JetCoreEnvironment myEnvironment;
+    private KotlinCoreEnvironment myEnvironment;
 
     private Test buildTestSuite() {
         suite = new TestSuite("stdlib_test");
@@ -94,7 +94,7 @@ public class TestlibTest extends UsefulTestCase {
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY,
                           new MessageCollectorPlainTextToStream(System.out, MessageCollectorPlainTextToStream.NON_VERBOSE));
 
-        myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         generationState = KotlinToJVMBytecodeCompiler.analyzeAndGenerate(myEnvironment);
         if (generationState == null) {

compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java

@@ -21,7 +21,7 @@ import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -55,7 +55,7 @@ import static org.jetbrains.kotlin.test.InTextDirectivesUtils.findStringWithPref
  */
 public abstract class AbstractWriteFlagsTest extends UsefulTestCase {
 
-    private JetCoreEnvironment jetCoreEnvironment;
+    private KotlinCoreEnvironment jetCoreEnvironment;
 
     @Override
     public void setUp() throws Exception {

compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java

@@ -24,7 +24,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.CodegenTestCase;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
@@ -94,7 +94,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         File javaClassesTempDirectory = compileJava(ktFile.replaceFirst("\\.kt$", ".java"));
 
         myEnvironment =
-                JetCoreEnvironment.createForTests(getTestRootDisposable(),
+                KotlinCoreEnvironment.createForTests(getTestRootDisposable(),
                                                   JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.FULL_JDK,
                                                                                              JetTestUtils.getAnnotationsJar(),
                                                                                              javaClassesTempDirectory),
@@ -127,7 +127,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, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
         loadFiles(ArrayUtil.toStringArray(ktFilePaths));
         classFileFactory =
                 GenerationUtils.compileManyFilesGetGenerationStateForTest(myEnvironment.getProject(), myFiles.getPsiFiles()).getFactory();

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java

@@ -21,10 +21,9 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.ClassFileFactory;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
@@ -84,7 +83,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends TestCaseWit
     }
 
     protected ClassFileFactory compileA(@NotNull File ktAFile) throws IOException {
-        JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(getTestRootDisposable(),
+        KotlinCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(getTestRootDisposable(),
                                                                                                             ConfigurationKind.ALL);
         return compileKotlin(ktAFile, aDir, jetCoreEnvironment, getTestRootDisposable());
     }
@@ -93,14 +92,14 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends TestCaseWit
         CompilerConfiguration configurationWithADirInClasspath = JetTestUtils
                 .compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), aDir);
 
-        JetCoreEnvironment environment =
-                JetCoreEnvironment.createForTests(getTestRootDisposable(), configurationWithADirInClasspath, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        KotlinCoreEnvironment environment =
+                KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configurationWithADirInClasspath, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         return compileKotlin(ktBFile, bDir, environment, getTestRootDisposable());
     }
 
     private static ClassFileFactory compileKotlin(
-            @NotNull File file, @NotNull File outputDir, @NotNull JetCoreEnvironment jetCoreEnvironment,
+            @NotNull File file, @NotNull File outputDir, @NotNull KotlinCoreEnvironment jetCoreEnvironment,
             @NotNull Disposable disposable
     ) throws IOException {
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
@@ -140,8 +140,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, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        KotlinCoreEnvironment environment =
+                KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
@@ -180,7 +180,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                 getTestRootDisposable()
         );
 
-        JetCoreEnvironment environment = JetCoreEnvironment.createForTests(
+        KotlinCoreEnvironment environment = KotlinCoreEnvironment.createForTests(
                 getTestRootDisposable(),
                 compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, getAnnotationsJar(), libraryOut),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES);

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java

@@ -22,7 +22,7 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies;
 import org.jetbrains.kotlin.load.java.JavaBindingContext;
@@ -48,7 +48,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase
 
     private static final int CLASSES_IN_CHUNK = 100;
 
-    protected abstract JetCoreEnvironment createEnvironment(Disposable parentDisposable);
+    protected abstract KotlinCoreEnvironment createEnvironment(Disposable parentDisposable);
 
     protected abstract List<FqName> getClassesToValidate() throws IOException;
 
@@ -73,7 +73,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase
             Disposable parentDisposable = Disposer.newDisposable();
 
             try {
-                JetCoreEnvironment commonEnvironment = createEnvironment(parentDisposable);
+                KotlinCoreEnvironment commonEnvironment = createEnvironment(parentDisposable);
 
                 BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
                 ModuleDescriptor module = LazyResolveTestUtil.resolve(

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.java

@@ -24,7 +24,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.test.JetTestUtils;
@@ -50,7 +50,7 @@ import java.util.regex.Pattern;
  */
 public abstract class AbstractWriteSignatureTest extends TestCaseWithTmpdir {
 
-    private JetCoreEnvironment jetCoreEnvironment;
+    private KotlinCoreEnvironment jetCoreEnvironment;
 
     @Override
     protected void setUp() throws Exception {

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AndroidSdkAnnotationsValidityTest.java

@@ -20,7 +20,7 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.intellij.openapi.Disposable;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -37,10 +37,10 @@ import java.util.jar.JarFile;
 public class AndroidSdkAnnotationsValidityTest extends AbstractSdkAnnotationsValidityTest {
 
     @Override
-    protected JetCoreEnvironment createEnvironment(Disposable parentDisposable) {
+    protected KotlinCoreEnvironment createEnvironment(Disposable parentDisposable) {
         CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.ANDROID_API, JetTestUtils.getAnnotationsJar());
-        return JetCoreEnvironment.createForTests(parentDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        return KotlinCoreEnvironment.createForTests(parentDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     @Override

compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollectorPlainTextToStream;
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
@@ -95,14 +95,14 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
     }
 
     @NotNull
-    private JetCoreEnvironment createEnvironment(@NotNull List<File> extraClassPath) {
+    private KotlinCoreEnvironment createEnvironment(@NotNull List<File> extraClassPath) {
         List<File> extras = new ArrayList<File>();
         extras.addAll(extraClassPath);
         extras.add(JetTestUtils.getAnnotationsJar());
 
         CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, extras.toArray(new File[extras.size()]));
-        return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     @NotNull

compiler/tests/org/jetbrains/kotlin/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java

@@ -26,7 +26,7 @@ import com.intellij.psi.util.PsiFormatUtil;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.CoreExternalAnnotationsManager;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
@@ -41,7 +41,7 @@ public class IdeaJdkAnnotationsReflectedTest extends KotlinTestWithEnvironment {
     private VirtualFile ideaAnnotationsRoot;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return JetTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(
                 myTestRootDisposable, ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK);
     }

compiler/tests/org/jetbrains/kotlin/jvm/compiler/JdkAnnotationsValidityTest.java

@@ -29,7 +29,7 @@ import com.intellij.openapi.vfs.VirtualFileVisitor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -67,15 +67,15 @@ public class JdkAnnotationsValidityTest extends AbstractSdkAnnotationsValidityTe
     // [Incompatible types in superclasses: [Any?, Any, Any], Incompatible projection kinds in type arguments of super methods' return types: [out Any?, Any, Any]]
     private static final Set<String> classesToIgnore = new HashSet<String>(Arrays.asList("javax.management.openmbean.TabularDataSupport"));
 
-    private static JetCoreEnvironment createFullJdkEnvironment(Disposable parentDisposable) {
+    private static KotlinCoreEnvironment createFullJdkEnvironment(Disposable parentDisposable) {
         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, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        return KotlinCoreEnvironment.createForTests(parentDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     @Override
-    protected JetCoreEnvironment createEnvironment(Disposable parentDisposable) {
+    protected KotlinCoreEnvironment createEnvironment(Disposable parentDisposable) {
         return createFullJdkEnvironment(parentDisposable);
     }
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinClassFinderTest.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.jvm.compiler
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironmentManagement
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.io.File
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder
@@ -37,7 +37,7 @@ public class KotlinClassFinderTest : KotlinTestWithEnvironmentManagement() {
                 listOf(), listOf(File("compiler/testData/kotlinClassFinder/nestedClass.kt")), tmpdir, getTestRootDisposable()!!
         )
 
-        val environment = JetCoreEnvironment.createForTests(getTestRootDisposable()!!,
+        val environment = KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!,
                                                             JetTestUtils.compilerConfigurationForTests(
                                                                     ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir),
                                                             EnvironmentConfigFiles.JVM_CONFIG_FILES)

compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
@@ -90,8 +90,8 @@ public final class LoadDescriptorUtil {
                 javaRoot,
                 new File("compiler/tests") // for @ExpectLoadError annotation
         );
-        JetCoreEnvironment environment =
-                JetCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+        KotlinCoreEnvironment environment =
+                KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         ModuleDescriptor module = LazyResolveTestUtil.resolve(environment.getProject(), trace, Collections.<JetFile>emptyList());
@@ -119,7 +119,7 @@ public final class LoadDescriptorUtil {
                 @NotNull Disposable disposable,
                 @NotNull ConfigurationKind configurationKind
         ) {
-            final JetCoreEnvironment jetCoreEnvironment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, configurationKind);
+            final KotlinCoreEnvironment jetCoreEnvironment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, configurationKind);
             List<JetFile> jetFiles = ContainerUtil.map(kotlinFiles, new Function<File, JetFile>() {
                 @Override
                 public JetFile fun(File kotlinFile) {

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.descriptors.*
 import org.junit.Assert
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys
 import com.intellij.psi.search.DelegatingGlobalSearchScope
@@ -69,13 +69,13 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
         performChecks(resolverForProject, modules)
     }
 
-    private fun createEnvironment(moduleDirs: Array<File>): JetCoreEnvironment {
+    private fun createEnvironment(moduleDirs: Array<File>): KotlinCoreEnvironment {
         val configuration = CompilerConfiguration()
         configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, moduleDirs.toList())
-        return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }
 
-    private fun setupModules(environment: JetCoreEnvironment, moduleDirs: Array<File>): List<TestModule> {
+    private fun setupModules(environment: KotlinCoreEnvironment, moduleDirs: Array<File>): List<TestModule> {
         val project = environment.project
         val modules = HashMap<String, TestModule>()
         for (dir in moduleDirs) {

compiler/tests/org/jetbrains/kotlin/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java

@@ -27,7 +27,7 @@ import org.apache.commons.httpclient.params.HttpMethodParams;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
@@ -160,9 +160,9 @@ public class ResolveDescriptorsFromExternalLibraries {
             public void dispose() { }
         };
 
-        JetCoreEnvironment jetCoreEnvironment;
+        KotlinCoreEnvironment jetCoreEnvironment;
         if (jar != null) {
-            jetCoreEnvironment = JetCoreEnvironment.createForTests(
+            jetCoreEnvironment = KotlinCoreEnvironment.createForTests(
                     junk,
                     JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK,
                                                                JetTestUtils.getAnnotationsJar(), jar),
@@ -171,7 +171,7 @@ public class ResolveDescriptorsFromExternalLibraries {
         else {
             CompilerConfiguration configuration =
                     JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK);
-            jetCoreEnvironment = JetCoreEnvironment.createForTests(junk, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+            jetCoreEnvironment = KotlinCoreEnvironment.createForTests(junk, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
             if (!findRtJar().equals(jar)) {
                 throw new RuntimeException("rt.jar mismatch: " + jar + ", " + findRtJar());
             }

compiler/tests/org/jetbrains/kotlin/psi/JetPsiUtilTest.java

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.psi;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
@@ -98,8 +98,8 @@ public class JetPsiUtilTest extends JetLiteFixture {
     }
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
-        return JetCoreEnvironment.createForTests(getTestRootDisposable(), new CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES);
+    protected KotlinCoreEnvironment createEnvironment() {
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable(), new CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES);
     }
 
     private ImportPath getImportPathFromParsed(String text) {

compiler/tests/org/jetbrains/kotlin/psi/JetSimpleNameExpressionTest.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.psi
 
 import org.junit.Assert
 import org.jetbrains.kotlin.test.JetLiteFixture
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
@@ -35,7 +35,7 @@ public class JetSimpleNameExpressionTest : JetLiteFixture() {
         val expression = JetPsiFactory(getProject()).createExpression(exprString) as JetBinaryExpression
         Assert.assertEquals(expected, expression.getOperationReference().getReceiverExpression()!!.getText())
     }
-    override fun createEnvironment(): JetCoreEnvironment {
-        return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES)
+    override fun createEnvironment(): KotlinCoreEnvironment {
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }
 }

compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import com.intellij.openapi.editor.impl.DocumentImpl
 import org.jetbrains.kotlin.test.JetTestUtils
 import java.util.ArrayList
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.test.ConfigurationKind
 import com.intellij.testFramework.UsefulTestCase
 import java.io.File
@@ -132,7 +132,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
         UsefulTestCase.assertSameLines(JetTestUtils.getLastCommentedLines(document), renderedDescriptors.toString())
     }
 
-    override fun createEnvironment(): JetCoreEnvironment {
+    override fun createEnvironment(): KotlinCoreEnvironment {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY)
     }
 }

compiler/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve;
 
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
@@ -32,7 +32,7 @@ public abstract class ExtensibleResolveTestCase extends JetLiteFixture {
     private ExpectedResolveData expectedResolveData;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_AND_ANNOTATIONS);
     }
 

compiler/tests/org/jetbrains/kotlin/resolve/MutableDiagnosticsTest.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve
 
 import org.junit.Assert
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
@@ -27,8 +27,8 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.psi.*
 
 class MutableDiagnosticsTest : KotlinTestWithEnvironment() {
-    override fun createEnvironment(): JetCoreEnvironment? {
-        return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES)
+    override fun createEnvironment(): KotlinCoreEnvironment? {
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, CompilerConfiguration(), EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }
 
     private val BindingTrace.diagnostics: Diagnostics

compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java

@@ -21,7 +21,7 @@ import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
@@ -60,7 +60,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     protected BindingContext context;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(getTestRootDisposable());
     }
 

compiler/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.calls
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.JetLiteFixture
 import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.psi.JetFile
 import com.intellij.psi.PsiElement
 
 public abstract class AbstractResolvedCallsTest : JetLiteFixture() {
-    override fun createEnvironment(): JetCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.ALL)
+    override fun createEnvironment(): KotlinCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.ALL)
 
     public fun doTest(filePath: String) {
         val text = JetTestUtils.doLoadFile(File(filePath))!!

compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.constraintSystem
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.JetLiteFixture
 import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.di.InjectorForTests
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers
@@ -48,7 +48,7 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     private val testDeclarations: ConstraintSystemTestData
         get() = _testDeclarations!!
 
-    override fun createEnvironment(): JetCoreEnvironment {
+    override fun createEnvironment(): KotlinCoreEnvironment {
         return createEnvironmentWithMockJdk(ConfigurationKind.ALL)
     }
 

compiler/tests/org/jetbrains/kotlin/resolve/lazy/KotlinTestWithEnvironment.java

@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.resolve.lazy;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironmentManagement;
 
 public abstract class KotlinTestWithEnvironment extends KotlinTestWithEnvironmentManagement {
-    private JetCoreEnvironment environment;
+    private KotlinCoreEnvironment environment;
 
     @Override
     protected void setUp() throws Exception {
@@ -36,10 +36,10 @@ public abstract class KotlinTestWithEnvironment extends KotlinTestWithEnvironmen
         super.tearDown();
     }
 
-    protected abstract JetCoreEnvironment createEnvironment();
+    protected abstract KotlinCoreEnvironment createEnvironment();
 
     @NotNull
-    public JetCoreEnvironment getEnvironment() {
+    public KotlinCoreEnvironment getEnvironment() {
         return environment;
     }
 

compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java

@@ -20,7 +20,7 @@ import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.GlobalContextImpl;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
@@ -71,17 +71,17 @@ public class LazyResolveTestUtil {
     @NotNull
     public static KotlinCodeAnalyzer resolveLazilyWithSession(
             @NotNull List<JetFile> files,
-            @NotNull JetCoreEnvironment environment,
+            @NotNull KotlinCoreEnvironment environment,
             boolean addBuiltIns
     ) {
         return createResolveSessionForFiles(environment.getProject(), files, addBuiltIns);
     }
 
-    public static ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment) {
+    public static ModuleDescriptor resolveLazily(List<JetFile> files, KotlinCoreEnvironment environment) {
         return resolveLazily(files, environment, true);
     }
 
-    public static ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment, boolean addBuiltIns) {
+    public static ModuleDescriptor resolveLazily(List<JetFile> files, KotlinCoreEnvironment environment, boolean addBuiltIns) {
         return resolveLazilyWithSession(files, environment, addBuiltIns).getModuleDescriptor();
     }
 

compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.resolve.typeApproximation
 
 import org.jetbrains.kotlin.test.JetLiteFixture
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.test.ConfigurationKind
 import java.io.File
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
@@ -40,7 +40,7 @@ public class CapturedTypeApproximationTest() : JetLiteFixture() {
 
     override fun getTestDataPath() = "compiler/testData/capturedTypeApproximation/"
 
-    override fun createEnvironment(): JetCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY)
+    override fun createEnvironment(): KotlinCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY)
 
     public fun doTest(filePath: String, vararg substitutions: String) {
         assert(substitutions.size() in 1..2, "Captured type approximation test requires substitutions for (T) or (T, R)")

compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.java

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.messages.*;
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
 import org.jetbrains.kotlin.codegen.CompilationException;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
@@ -86,8 +86,8 @@ public class ScriptTest {
             configuration.addAll(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, scriptDefinitions);
             configuration.put(JVMConfigurationKeys.SCRIPT_PARAMETERS, scriptParameters);
 
-            JetCoreEnvironment environment =
-                    JetCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
+            KotlinCoreEnvironment environment =
+                    KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
             try {
                 JetScriptDefinitionProvider.getInstance(environment.getProject()).markFileAsScript(environment.getSourceFiles().get(0));

compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt

@@ -20,7 +20,7 @@ import com.google.common.base.Predicates
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm
@@ -50,7 +50,7 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
         val clazz = classLoader.loadClass(classFile.name.substringBeforeLast(".class"))
         assertHasAnnotationData(clazz)
 
-        val environment = JetCoreEnvironment.createForTests(
+        val environment = KotlinCoreEnvironment.createForTests(
                 getTestRootDisposable(),
                 JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES

compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java

@@ -20,7 +20,7 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.kotlin.psi.JetFile;
@@ -40,7 +40,7 @@ import java.util.regex.Pattern;
 
 public class LoadBuiltinsTest extends KotlinTestWithEnvironment {
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithJdk(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK);
     }
 

compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
@@ -68,7 +68,7 @@ public class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
     private fun serialize(configuration: CompilerConfiguration, metaFile: File) {
         val rootDisposable = Disposer.newDisposable()
         try {
-            val environment = JetCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
+            val environment = KotlinCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
             val files = environment.getSourceFiles()
             val config = LibrarySourcesConfigWithCaching(environment.project, MODULE_NAME, EcmaVersion.defaultVersion(), false, true, false)
             val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(files, config)

compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java

@@ -47,7 +47,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
@@ -247,28 +247,28 @@ public class JetTestUtils {
     }
 
     @NotNull
-    public static JetCoreEnvironment createEnvironmentWithFullJdk(Disposable disposable) {
+    public static KotlinCoreEnvironment createEnvironmentWithFullJdk(Disposable disposable) {
         return createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(disposable,
                                                                          ConfigurationKind.ALL, TestJdkKind.FULL_JDK);
     }
 
     @NotNull
-    public static JetCoreEnvironment createEnvironmentWithMockJdkAndIdeaAnnotations(Disposable disposable) {
+    public static KotlinCoreEnvironment createEnvironmentWithMockJdkAndIdeaAnnotations(Disposable disposable) {
         return createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, ConfigurationKind.ALL);
     }
 
     @NotNull
-    public static JetCoreEnvironment createEnvironmentWithMockJdkAndIdeaAnnotations(Disposable disposable, @NotNull ConfigurationKind configurationKind) {
+    public static KotlinCoreEnvironment createEnvironmentWithMockJdkAndIdeaAnnotations(Disposable disposable, @NotNull ConfigurationKind configurationKind) {
         return createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(disposable, configurationKind, TestJdkKind.MOCK_JDK);
     }
 
     @NotNull
-    public static JetCoreEnvironment createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(
+    public static KotlinCoreEnvironment createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(
             @NotNull Disposable disposable,
             @NotNull ConfigurationKind configurationKind,
             @NotNull TestJdkKind jdkKind
     ) {
-        return JetCoreEnvironment.createForTests(
+        return KotlinCoreEnvironment.createForTests(
                 disposable,
                 compilerConfigurationForTests(configurationKind, jdkKind, getAnnotationsJar()),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES);
@@ -439,7 +439,7 @@ public class JetTestUtils {
         return configuration;
     }
 
-    public static void resolveAllKotlinFiles(JetCoreEnvironment environment) throws IOException {
+    public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException {
         List<String> paths = environment.getConfiguration().get(CommonConfigurationKeys.SOURCE_ROOTS_KEY);
         if (paths == null) return;
         List<JetFile> jetFiles = Lists.newArrayList();
@@ -870,7 +870,7 @@ public class JetTestUtils {
     }
 
     @NotNull
-    public static List<JetFile> loadToJetFiles(@NotNull JetCoreEnvironment environment, @NotNull List<File> files) throws IOException {
+    public static List<JetFile> loadToJetFiles(@NotNull KotlinCoreEnvironment environment, @NotNull List<File> files) throws IOException {
         List<JetFile> jetFiles = Lists.newArrayList();
         for (File file : files) {
             jetFiles.add(loadJetFile(environment.getProject(), file));

compiler/tests/org/jetbrains/kotlin/test/KotlinTestWithEnvironmentManagement.java

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.test;
 
 import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 
 public abstract class KotlinTestWithEnvironmentManagement extends UsefulTestCase {
     static {
@@ -26,12 +26,12 @@ public abstract class KotlinTestWithEnvironmentManagement extends UsefulTestCase
     }
 
     @NotNull
-    protected JetCoreEnvironment createEnvironmentWithMockJdk(@NotNull ConfigurationKind configurationKind) {
+    protected KotlinCoreEnvironment createEnvironmentWithMockJdk(@NotNull ConfigurationKind configurationKind) {
         return createEnvironmentWithJdk(configurationKind, TestJdkKind.MOCK_JDK);
     }
 
     @NotNull
-    protected JetCoreEnvironment createEnvironmentWithJdk(@NotNull ConfigurationKind configurationKind, @NotNull TestJdkKind jdkKind) {
+    protected KotlinCoreEnvironment createEnvironmentWithJdk(@NotNull ConfigurationKind configurationKind, @NotNull TestJdkKind jdkKind) {
         return JetTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(getTestRootDisposable(), configurationKind, jdkKind);
     }
 }

compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.test.util;
 import com.google.common.collect.Lists;
 import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
@@ -35,7 +35,7 @@ import java.util.List;
 
 public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment {
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(getTestRootDisposable());
     }
 

compiler/tests/org/jetbrains/kotlin/types/BoundsSubstitutorTest.java

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.types;
 
 import com.intellij.util.containers.ContainerUtil;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.name.FqName;
@@ -35,7 +35,7 @@ import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 
 public class BoundsSubstitutorTest extends KotlinTestWithEnvironment {
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
     }
 

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

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.types;
 
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.GlobalContextImpl;
 import org.jetbrains.kotlin.descriptors.*;
@@ -52,7 +52,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
     private final JetDefaultModalityModifiersTestCase tc = new JetDefaultModalityModifiersTestCase();
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
     }
 

compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.types;
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.di.InjectorForTests;
@@ -37,7 +37,7 @@ public class JetOverloadTest extends JetLiteFixture {
     private FunctionDescriptorResolver functionDescriptorResolver;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
     }
 

compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.types;
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.di.InjectorForTests;
@@ -37,7 +37,7 @@ public class JetOverridingTest extends JetLiteFixture {
     private FunctionDescriptorResolver functionDescriptorResolver;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
     }
 

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

@@ -21,7 +21,7 @@ import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor;
@@ -61,7 +61,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     }
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
     }
 

compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java

@@ -24,7 +24,7 @@ import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
@@ -59,7 +59,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
     private InjectorForTests injector;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
     }
 

compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java

@@ -22,7 +22,7 @@ import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
@@ -53,7 +53,7 @@ public class TypeUnifierTest extends JetLiteFixture {
     private TypeParameterDescriptor y;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
     }
 

idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java

@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.idea.PluginTestCaseBase;
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
@@ -37,8 +37,8 @@ import static java.util.Collections.singletonList;
 public abstract class AbstractDiagnosticMessageJsTest extends AbstractDiagnosticMessageTest {
     @NotNull
     @Override
-    protected JetCoreEnvironment createEnvironment() {
-        return JetCoreEnvironment.createForTests(getTestRootDisposable(), new CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES);
+    protected KotlinCoreEnvironment createEnvironment() {
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable(), new CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES);
     }
 
     @NotNull

idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java

@@ -17,20 +17,18 @@
 package org.jetbrains.kotlin.idea.highlighter;
 
 import com.google.common.collect.Sets;
-import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.idea.PluginTestCaseBase;
-import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm;
@@ -66,7 +64,7 @@ public abstract class AbstractDiagnosticMessageTest extends JetLiteFixture {
 
     @NotNull
     @Override
-    protected JetCoreEnvironment createEnvironment() {
+    protected KotlinCoreEnvironment createEnvironment() {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
     }
 

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicTest.java

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.js.test;
 
 import com.google.common.collect.Lists;
-import com.google.dart.compiler.backend.js.ast.JsNode;
 import com.google.dart.compiler.backend.js.ast.JsProgram;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtil;
@@ -27,13 +26,12 @@ import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.openapi.vfs.VirtualFileSystem;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
-import com.intellij.util.Consumer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.js.JavaScript;
 import org.jetbrains.kotlin.js.config.Config;
@@ -92,8 +90,8 @@ public abstract class BasicTest extends KotlinTestWithEnvironment {
     protected abstract void checkFooBoxIsOkByPath(String filePath) throws Exception;
 
     @Override
-    protected JetCoreEnvironment createEnvironment() {
-        return JetCoreEnvironment.createForTests(getTestRootDisposable(), new CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES);
+    protected KotlinCoreEnvironment createEnvironment() {
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable(), new CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES);
     }
 
     protected boolean shouldCreateOut() {

plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/AbstractAndroidXml2KConversionTest.kt

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.lang.resolve.android.test
 
 import com.intellij.testFramework.UsefulTestCase
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import java.io.File
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.test.ConfigurationKind
@@ -55,8 +55,8 @@ public abstract class AbstractAndroidXml2KConversionTest : UsefulTestCase() {
         }
     }
 
-    private fun getEnvironment(testPath: String): JetCoreEnvironment {
+    private fun getEnvironment(testPath: String): KotlinCoreEnvironment {
         val configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK)
-        return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }
 }

plugins/android-compiler-plugin/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt

@@ -27,7 +27,7 @@ import com.intellij.testFramework.UsefulTestCase
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.lang.resolve.android.CliAndroidUIXmlProcessor
 
@@ -45,11 +45,11 @@ private class AndroidTestExternalDeclarationsProvider(
 fun UsefulTestCase.createAndroidTestEnvironment(
         configuration: CompilerConfiguration,
         resPath: String,
-        manifestPath: String): JetCoreEnvironment
+        manifestPath: String): KotlinCoreEnvironment
 {
     configuration.put(AndroidConfigurationKeys.ANDROID_RES_PATH, resPath)
     configuration.put(AndroidConfigurationKeys.ANDROID_MANIFEST, manifestPath)
-    val myEnvironment = JetCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+    val myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     val project = myEnvironment.project
     ExternalDeclarationsProvider.registerExtension(project, AndroidTestExternalDeclarationsProvider(project, resPath, manifestPath))
     ExpressionCodegenExtension.registerExtension(project, AndroidExpressionCodegenExtension())

plugins/android-idea-plugin/tests/org/jetbrains/kotlin/android/AbstractParserResultEqualityTest.kt

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.android
 
-import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.plugin.android.TestConst
 import org.jetbrains.kotlin.lang.resolve.android.CliAndroidUIXmlProcessor
 import com.intellij.openapi.module.ModuleManager
@@ -41,11 +41,11 @@ public abstract class AbstractParserResultEqualityTest : KotlinAndroidTestCase()
         assertEquals(cliResult, ideResult)
     }
 
-    private fun getEnvironment(testPath: String): JetCoreEnvironment {
+    private fun getEnvironment(testPath: String): KotlinCoreEnvironment {
         val configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK)
                 configuration.put<String>(AndroidConfigurationKeys.ANDROID_RES_PATH, testPath + "/layout")
                 configuration.put<String>(AndroidConfigurationKeys.ANDROID_MANIFEST, testPath + "/AndroidManifest.xml")
-        return JetCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
+        return KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }
 
     override fun getTestDataPath(): String? {