rename Jet* classes to Kt*

compiler/tests/org/jetbrains/kotlin/cfg/AbstractPseudoValueTest.kt

@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeImpl
 import org.jetbrains.kotlin.cfg.pseudocode.TypePredicate
 import org.jetbrains.kotlin.cfg.pseudocode.getExpectedTypePredicate
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.InstructionWithValue
-import org.jetbrains.kotlin.psi.JetElement
-import org.jetbrains.kotlin.psi.JetTreeVisitorVoid
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import java.util.*
@@ -32,10 +32,10 @@ public abstract class AbstractPseudoValueTest : AbstractPseudocodeTest() {
     override fun dumpInstructions(pseudocode: PseudocodeImpl, out: StringBuilder, bindingContext: BindingContext) {
         val expectedTypePredicateMap = HashMap<PseudoValue, TypePredicate>()
 
-        fun getElementToValueMap(pseudocode: PseudocodeImpl): Map<JetElement, PseudoValue> {
-            val elementToValues = LinkedHashMap<JetElement, PseudoValue>()
-            pseudocode.getCorrespondingElement().accept(object : JetTreeVisitorVoid() {
-                override fun visitJetElement(element: JetElement) {
+        fun getElementToValueMap(pseudocode: PseudocodeImpl): Map<KtElement, PseudoValue> {
+            val elementToValues = LinkedHashMap<KtElement, PseudoValue>()
+            pseudocode.getCorrespondingElement().accept(object : KtTreeVisitorVoid() {
+                override fun visitJetElement(element: KtElement) {
                     super.visitJetElement(element)
 
                     val value = pseudocode.getElementValue(element)
@@ -47,7 +47,7 @@ public abstract class AbstractPseudoValueTest : AbstractPseudocodeTest() {
             return elementToValues
         }
 
-        fun elementText(element: JetElement?): String =
+        fun elementText(element: KtElement?): String =
                 element?.getText()?.replace("\\s+".toRegex(), " ") ?: ""
 
         fun valueDecl(value: PseudoValue): String {
@@ -57,7 +57,7 @@ public abstract class AbstractPseudoValueTest : AbstractPseudocodeTest() {
             return "${value.debugName}: $typePredicate"
         }
 
-        fun valueDescription(element: JetElement?, value: PseudoValue): String {
+        fun valueDescription(element: KtElement?, value: PseudoValue): String {
             return when {
                 value.element != element -> "COPY"
                 else -> value.createdAt?.let { "NEW: $it" } ?: ""
@@ -73,7 +73,7 @@ public abstract class AbstractPseudoValueTest : AbstractPseudocodeTest() {
         val allValues = elementToValues.values() + unboundValues
         if (allValues.isEmpty()) return
 
-        val valueDescriptions = LinkedHashMap<Pair<PseudoValue, JetElement?>, String>()
+        val valueDescriptions = LinkedHashMap<Pair<PseudoValue, KtElement?>, String>()
         for (value in unboundValues) {
             valueDescriptions[value to null] = valueDescription(null, value)
         }

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

@@ -51,19 +51,19 @@ public abstract class AbstractPseudocodeTest extends KotlinTestWithEnvironment {
 
     protected void doTest(String fileName) throws Exception {
         File file = new File(fileName);
-        JetFile jetFile = JetTestUtils.loadJetFile(getProject(), file);
+        KtFile jetFile = JetTestUtils.loadJetFile(getProject(), file);
 
-        Map<JetElement, Pseudocode> data = new LinkedHashMap<JetElement, Pseudocode>();
+        Map<KtElement, Pseudocode> data = new LinkedHashMap<KtElement, Pseudocode>();
         AnalysisResult analysisResult = JetTestUtils.analyzeFile(jetFile, getEnvironment());
-        List<JetDeclaration> declarations = jetFile.getDeclarations();
+        List<KtDeclaration> declarations = jetFile.getDeclarations();
         BindingContext bindingContext = analysisResult.getBindingContext();
-        for (JetDeclaration declaration : declarations) {
+        for (KtDeclaration declaration : declarations) {
             addDeclaration(data, bindingContext, declaration);
 
-            if (declaration instanceof JetDeclarationContainer) {
-                for (JetDeclaration member : ((JetDeclarationContainer) declaration).getDeclarations()) {
+            if (declaration instanceof KtDeclarationContainer) {
+                for (KtDeclaration member : ((KtDeclarationContainer) declaration).getDeclarations()) {
                     // Properties and initializers are processed elsewhere
-                    if (member instanceof JetNamedFunction || member instanceof JetSecondaryConstructor) {
+                    if (member instanceof KtNamedFunction || member instanceof KtSecondaryConstructor) {
                         addDeclaration(data, bindingContext, member);
                     }
                 }
@@ -83,7 +83,7 @@ public abstract class AbstractPseudocodeTest extends KotlinTestWithEnvironment {
         }
     }
 
-    private static void addDeclaration(Map<JetElement, Pseudocode> data, BindingContext bindingContext, JetDeclaration declaration) {
+    private static void addDeclaration(Map<KtElement, Pseudocode> data, BindingContext bindingContext, KtDeclaration declaration) {
         Pseudocode pseudocode = PseudocodeUtil.generatePseudocode(declaration, bindingContext);
         data.put(declaration, pseudocode);
         for (LocalFunctionDeclarationInstruction instruction : pseudocode.getLocalDeclarations()) {
@@ -92,29 +92,29 @@ public abstract class AbstractPseudocodeTest extends KotlinTestWithEnvironment {
         }
     }
 
-    private void processCFData(File file, Map<JetElement, Pseudocode> data, BindingContext bindingContext) throws IOException {
+    private void processCFData(File file, Map<KtElement, Pseudocode> data, BindingContext bindingContext) throws IOException {
         Collection<Pseudocode> pseudocodes = data.values();
 
         StringBuilder instructionDump = new StringBuilder();
         int i = 0;
         for (Pseudocode pseudocode : pseudocodes) {
-            JetElement correspondingElement = pseudocode.getCorrespondingElement();
+            KtElement correspondingElement = pseudocode.getCorrespondingElement();
             String label;
-            assert (correspondingElement instanceof JetNamedDeclaration || correspondingElement instanceof JetPropertyAccessor) :
+            assert (correspondingElement instanceof KtNamedDeclaration || correspondingElement instanceof KtPropertyAccessor) :
                     "Unexpected element class is pseudocode: " + correspondingElement.getClass();
             boolean isAnonymousFunction =
-                    correspondingElement instanceof JetFunctionLiteral
-                    || (correspondingElement instanceof JetNamedFunction && correspondingElement.getName() == null);
+                    correspondingElement instanceof KtFunctionLiteral
+                    || (correspondingElement instanceof KtNamedFunction && correspondingElement.getName() == null);
             if (isAnonymousFunction) {
                 label = "anonymous_" + i++;
             }
-            else if (correspondingElement instanceof JetNamedDeclaration) {
-                JetNamedDeclaration namedDeclaration = (JetNamedDeclaration) correspondingElement;
+            else if (correspondingElement instanceof KtNamedDeclaration) {
+                KtNamedDeclaration namedDeclaration = (KtNamedDeclaration) correspondingElement;
                 label = namedDeclaration.getName();
             }
             else {
-                String propertyName = ((JetProperty) correspondingElement.getParent()).getName();
-                label = (((JetPropertyAccessor) correspondingElement).isGetter() ? "get" : "set") + "_" + propertyName;
+                String propertyName = ((KtProperty) correspondingElement.getParent()).getName();
+                label = (((KtPropertyAccessor) correspondingElement).isGetter() ? "get" : "set") + "_" + propertyName;
             }
 
             instructionDump.append("== ").append(label).append(" ==\n");

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

@@ -30,8 +30,8 @@ import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.LocalFunctionDec
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.SubroutineEnterInstruction;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.SubroutineExitInstruction;
 import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.SubroutineSinkInstruction;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetNamedDeclaration;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtNamedDeclaration;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
 import java.io.File;
@@ -55,9 +55,9 @@ public class CFGraphToDotFilePrinter {
         int i = 0;
         for (Pseudocode pseudocode : pseudocodes) {
             String label;
-            JetElement correspondingElement = pseudocode.getCorrespondingElement();
-            if (correspondingElement instanceof JetNamedDeclaration) {
-                JetNamedDeclaration namedDeclaration = (JetNamedDeclaration) correspondingElement;
+            KtElement correspondingElement = pseudocode.getCorrespondingElement();
+            if (correspondingElement instanceof KtNamedDeclaration) {
+                KtNamedDeclaration namedDeclaration = (KtNamedDeclaration) correspondingElement;
                 label = namedDeclaration.getName();
             }
             else {

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

@@ -39,9 +39,9 @@ import org.jetbrains.kotlin.diagnostics.*;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.Call;
-import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtElement;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -119,7 +119,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
             TestModule testModule = entry.getKey();
             List<? extends TestFile> testFilesInModule = entry.getValue();
 
-            List<JetFile> jetFiles = getJetFiles(testFilesInModule, true);
+            List<KtFile> jetFiles = getJetFiles(testFilesInModule, true);
 
             ModuleDescriptorImpl module = modules.get(testModule);
             BindingTrace moduleTrace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
@@ -234,7 +234,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
 
     protected void analyzeModuleContents(
             @NotNull ModuleContext moduleContext,
-            @NotNull List<JetFile> jetFiles,
+            @NotNull List<KtFile> jetFiles,
             @NotNull BindingTrace moduleTrace
     ) {
         // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
@@ -366,8 +366,8 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
         return moduleDescriptor;
     }
 
-    private static void checkAllResolvedCallsAreCompleted(@NotNull List<JetFile> jetFiles, @NotNull BindingContext bindingContext) {
-        for (JetFile file : jetFiles) {
+    private static void checkAllResolvedCallsAreCompleted(@NotNull List<KtFile> jetFiles, @NotNull BindingContext bindingContext) {
+        for (KtFile file : jetFiles) {
             if (!AnalyzingUtils.getSyntaxErrorRanges(file).isEmpty()) {
                 return;
             }
@@ -375,7 +375,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
 
         ImmutableMap<Call, ResolvedCall<?>> resolvedCallsEntries = bindingContext.getSliceContents(BindingContext.RESOLVED_CALL);
         for (Map.Entry<Call, ResolvedCall<?>> entry : resolvedCallsEntries.entrySet()) {
-            JetElement element = entry.getKey().getCallElement();
+            KtElement element = entry.getKey().getCallElement();
             ResolvedCall<?> resolvedCall = entry.getValue();
 
             DiagnosticUtils.LineAndColumn lineAndColumn =
@@ -393,7 +393,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
         Set<DiagnosticFactory1<PsiElement, Collection<? extends ResolvedCall<?>>>> diagnosticsStoringResolvedCalls1 = Sets.newHashSet(
                 OVERLOAD_RESOLUTION_AMBIGUITY, NONE_APPLICABLE, CANNOT_COMPLETE_RESOLVE, UNRESOLVED_REFERENCE_WRONG_RECEIVER,
                 ASSIGN_OPERATOR_AMBIGUITY, ITERATOR_AMBIGUITY);
-        Set<DiagnosticFactory2<JetExpression, ? extends Comparable<? extends Comparable<?>>, Collection<? extends ResolvedCall<?>>>>
+        Set<DiagnosticFactory2<KtExpression, ? extends Comparable<? extends Comparable<?>>, Collection<? extends ResolvedCall<?>>>>
                 diagnosticsStoringResolvedCalls2 = Sets.newHashSet(
                 COMPONENT_FUNCTION_AMBIGUITY, DELEGATE_SPECIAL_FUNCTION_AMBIGUITY, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE);
         Diagnostics diagnostics = bindingContext.getDiagnostics();

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

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.js.config.Config;
 import org.jetbrains.kotlin.js.config.LibrarySourcesConfig;
 import org.jetbrains.kotlin.js.resolve.JsPlatform;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.TargetPlatform;
 import org.jetbrains.kotlin.resolve.TargetPlatformKt;
@@ -62,7 +62,7 @@ public abstract class AbstractJetDiagnosticsTestWithJsStdLib extends AbstractJet
     @Override
     protected void analyzeModuleContents(
             @NotNull ModuleContext moduleContext,
-            @NotNull List<JetFile> jetFiles,
+            @NotNull List<KtFile> jetFiles,
             @NotNull BindingTrace moduleTrace
     ) {
         TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, moduleContext, config);

compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation.kt

@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticUtils.hasError
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.facade.K2JSTranslator
 import org.jetbrains.kotlin.js.facade.MainCallParameters
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingTrace
 
 public abstract class AbstractJetDiagnosticsTestWithJsStdLibAndBackendCompilation : AbstractJetDiagnosticsTestWithJsStdLib() {
     override fun analyzeModuleContents(
             moduleContext: ModuleContext,
-            jetFiles: MutableList<JetFile>,
+            jetFiles: MutableList<KtFile>,
             moduleTrace: BindingTrace
     ) {
         val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, moduleContext, getConfig())

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

@@ -35,8 +35,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.asJava.DuplicateJvmSignatureUtilKt;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.diagnostics.*;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.types.Flexibility;
@@ -121,10 +121,10 @@ public abstract class BaseDiagnosticsTest extends
             List<TestFile> files
     );
 
-    protected List<JetFile> getJetFiles(List<? extends TestFile> testFiles, boolean includeExtras) {
+    protected List<KtFile> getJetFiles(List<? extends TestFile> testFiles, boolean includeExtras) {
         boolean declareFlexibleType = false;
         boolean declareCheckType = false;
-        List<JetFile> jetFiles = Lists.newArrayList();
+        List<KtFile> jetFiles = Lists.newArrayList();
         for (TestFile testFile : testFiles) {
             if (testFile.getJetFile() != null) {
                 jetFiles.add(testFile.getJetFile());
@@ -240,7 +240,7 @@ public abstract class BaseDiagnosticsTest extends
         public final String expectedText;
         private final TestModule module;
         private final String clearText;
-        private final JetFile jetFile;
+        private final KtFile jetFile;
         private final Condition<Diagnostic> whatDiagnosticsToConsider;
         private final boolean declareCheckType;
         private final boolean declareFlexibleType;
@@ -325,7 +325,7 @@ public abstract class BaseDiagnosticsTest extends
         }
 
         @Nullable
-        public JetFile getJetFile() {
+        public KtFile getJetFile() {
             return jetFile;
         }
 
@@ -398,8 +398,8 @@ public abstract class BaseDiagnosticsTest extends
 
         private Set<Diagnostic> computeJvmSignatureDiagnostics(BindingContext bindingContext) {
             Set<Diagnostic> jvmSignatureDiagnostics = new HashSet<Diagnostic>();
-            Collection<JetDeclaration> declarations = PsiTreeUtil.findChildrenOfType(jetFile, JetDeclaration.class);
-            for (JetDeclaration declaration : declarations) {
+            Collection<KtDeclaration> declarations = PsiTreeUtil.findChildrenOfType(jetFile, KtDeclaration.class);
+            for (KtDeclaration declaration : declarations) {
                 Diagnostics diagnostics = DuplicateJvmSignatureUtilKt.getJvmSignatureDiagnostics(declaration, bindingContext.getDiagnostics(),
                                                                                                  GlobalSearchScope.allScope(getProject()));
                 if (diagnostics == null) continue;

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

@@ -24,7 +24,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.checkers.CheckerTestUtil.DiagnosedRange;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -144,7 +144,7 @@ public class CheckerTestUtilTest extends JetLiteFixture {
 
         public void test(@NotNull PsiFile psiFile) {
             BindingContext bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(
-                    (JetFile) psiFile)
+                    (KtFile) psiFile)
                     .getBindingContext();
 
             String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile, false, null)).toString();

compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt

@@ -28,12 +28,12 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate
 import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionTaskHolder
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationContext
 import org.jetbrains.kotlin.serialization.deserialization.TypeDeserializer
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.JetTypeImpl
+import org.jetbrains.kotlin.types.KtType
+import org.jetbrains.kotlin.types.KtTypeImpl
 import org.jetbrains.kotlin.utils.Printer
 import java.lang.reflect.Constructor
 import java.lang.reflect.GenericDeclaration
@@ -62,7 +62,7 @@ class LazyOperationsLog(
     public fun getText(): String {
         val groupedByOwner = records.groupByTo(IdentityHashMap()) {
             val owner = it.data.fieldOwner
-            if (owner is JetScope) owner.getContainingDeclaration() else owner
+            if (owner is KtScope) owner.getContainingDeclaration() else owner
         }.map { Pair(it.getKey(), it.getValue()) }
 
         return groupedByOwner.map {
@@ -118,7 +118,7 @@ class LazyOperationsLog(
 
         sb.append(" = ${render(data.result)}")
 
-        if (data.fieldOwner is JetScope) {
+        if (data.fieldOwner is KtScope) {
             sb.append(" // through ${render(data.fieldOwner)}")
         }
 
@@ -159,7 +159,7 @@ class LazyOperationsLog(
                 val text = when {
                     typeProto.hasClassName() -> context.nameResolver.getClassId(typeProto.className).asSingleFqName().asString()
                     typeProto.hasTypeParameter() -> {
-                        val classifier = (o as JetType).constructor.declarationDescriptor!!
+                        val classifier = (o as KtType).constructor.declarationDescriptor!!
                         "" + classifier.name + " in " + DescriptorUtils.getFqName(classifier.containingDeclaration)
                     }
                     else -> "???"
@@ -183,7 +183,7 @@ class LazyOperationsLog(
                     sb.append(" }")
                 }
             }
-            o is JetTypeImpl -> {
+            o is KtTypeImpl -> {
                 StringBuilder {
                     append(o.getConstructor())
                     if (!o.getArguments().isEmpty()) {

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

@@ -26,7 +26,7 @@ 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.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir;
 import org.jetbrains.org.objectweb.asm.*;
@@ -67,7 +67,7 @@ public abstract class AbstractCheckLocalVariablesTableTest extends TestCaseWithT
         ktFile = new File(ktFileName);
         String text = FileUtil.loadFile(ktFile, true);
 
-        JetFile psiFile = JetTestUtils.createFile(ktFile.getName(), text, jetCoreEnvironment.getProject());
+        KtFile psiFile = JetTestUtils.createFile(ktFile.getName(), text, jetCoreEnvironment.getProject());
 
         OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment);
 

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

@@ -28,9 +28,7 @@ import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsKt;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
-import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir;
@@ -41,7 +39,6 @@ import org.jetbrains.org.objectweb.asm.*;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Matcher;
@@ -71,9 +68,9 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir {
         super.setUp();
 
         KotlinCoreEnvironment environment = createEnvironment();
-        JetFile psiFile = JetTestUtils.createFile(LINE_NUMBER_FUN + ".kt",
+        KtFile psiFile = JetTestUtils.createFile(LINE_NUMBER_FUN + ".kt",
                                                "package test;\n\npublic fun " + LINE_NUMBER_FUN + "(): Int = 0\n",
-                                               environment.getProject());
+                                                 environment.getProject());
 
         OutputFileCollection outputFiles =
                 GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, environment);
@@ -81,7 +78,7 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir {
     }
 
     @NotNull
-    private Pair<JetFile, KotlinCoreEnvironment> createPsiFile(@NotNull String filename) {
+    private Pair<KtFile, KotlinCoreEnvironment> createPsiFile(@NotNull String filename) {
         File file = new File(filename);
         KotlinCoreEnvironment environment = createEnvironment();
 
@@ -97,8 +94,8 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir {
     }
 
     private void doTest(@NotNull String filename, boolean custom) {
-        Pair<JetFile, KotlinCoreEnvironment> fileAndEnv = createPsiFile(filename);
-        JetFile psiFile = fileAndEnv.getFirst();
+        Pair<KtFile, KotlinCoreEnvironment> fileAndEnv = createPsiFile(filename);
+        KtFile psiFile = fileAndEnv.getFirst();
         KotlinCoreEnvironment environment = fileAndEnv.getSecond();
 
         GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile, environment);
@@ -146,7 +143,7 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir {
     }
 
     @NotNull
-    private static List<Integer> extractCustomLineNumbersFromSource(@NotNull JetFile file) {
+    private static List<Integer> extractCustomLineNumbersFromSource(@NotNull KtFile file) {
         String fileContent = file.getText();
         List<Integer> lineNumbers = Lists.newArrayList();
         String[] lines = StringUtil.convertLineSeparators(fileContent).split("\n");
@@ -164,7 +161,7 @@ public abstract class AbstractLineNumberTest extends TestCaseWithTmpdir {
     }
 
     @NotNull
-    private static List<Integer> extractSelectedLineNumbersFromSource(@NotNull JetFile file) {
+    private static List<Integer> extractSelectedLineNumbersFromSource(@NotNull KtFile file) {
         String fileContent = file.getText();
         List<Integer> lineNumbers = Lists.newArrayList();
         String[] lines = StringUtil.convertLineSeparators(fileContent).split("\n");

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

@@ -26,12 +26,12 @@ import org.jetbrains.kotlin.checkers.CheckerTestUtil;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.parsing.JetScriptDefinition;
 import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.AnalyzerScriptParameter;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 import org.jetbrains.kotlin.test.JetTestUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.Variance;
 
 import java.io.IOException;
@@ -44,14 +44,14 @@ import java.util.regex.Pattern;
 public class CodegenTestFiles {
 
     @NotNull
-    private final List<JetFile> psiFiles;
+    private final List<KtFile> psiFiles;
     @NotNull
     private final List<Pair<String, String>> expectedValues;
     @NotNull
     private final List<Object> scriptParameterValues;
 
     private CodegenTestFiles(
-            @NotNull List<JetFile> psiFiles,
+            @NotNull List<KtFile> psiFiles,
             @NotNull List<Pair<String, String>> expectedValues,
             @NotNull List<Object> scriptParameterValues
     ) {
@@ -61,7 +61,7 @@ public class CodegenTestFiles {
     }
 
     @NotNull
-    public JetFile getPsiFile() {
+    public KtFile getPsiFile() {
         assert psiFiles.size() == 1;
         return psiFiles.get(0);
     }
@@ -77,7 +77,7 @@ public class CodegenTestFiles {
     }
 
     @NotNull
-    public List<JetFile> getPsiFiles() {
+    public List<KtFile> getPsiFiles() {
         return psiFiles;
     }
 
@@ -86,13 +86,13 @@ public class CodegenTestFiles {
     }
 
     public static CodegenTestFiles create(Project project, String[] names, String testDataPath) {
-        ArrayList<JetFile> files = new ArrayList<JetFile>();
+        ArrayList<KtFile> files = new ArrayList<KtFile>();
         for (String name : names) {
             try {
                 String content = JetTestUtils.doLoadFile(testDataPath + "/codegen/", name);
                 int i = name.lastIndexOf('/');
                 //name = name.substring(i+1);
-                JetFile file = JetTestUtils.createFile(name, content, project);
+                KtFile file = JetTestUtils.createFile(name, content, project);
                 files.add(file);
             } catch (IOException e) {
                 throw new RuntimeException(e);
@@ -104,7 +104,7 @@ public class CodegenTestFiles {
     @NotNull
     public static CodegenTestFiles create(@NotNull String fileName, @NotNull String contentWithDiagnosticMarkup, @NotNull Project project) {
         String content = CheckerTestUtil.parseDiagnosedRanges(contentWithDiagnosticMarkup, new ArrayList<CheckerTestUtil.DiagnosedRange>());
-        JetFile file = JetTestUtils.createFile(fileName, content, project);
+        KtFile file = JetTestUtils.createFile(fileName, content, project);
         List<PsiErrorElement> ranges = AnalyzingUtils.getSyntaxErrorRanges(file);
         assert ranges.isEmpty() : "Syntax errors found in " + file + ": " + ranges;
 
@@ -131,7 +131,7 @@ public class CodegenTestFiles {
                 String valueString = scriptParametersMatcher.group(3);
                 Object value;
 
-                JetType jetType;
+                KtType jetType;
                 KotlinBuiltIns builtIns = JvmPlatform.INSTANCE$.getBuiltIns();
                 if (type.equals("kotlin.String")) {
                     value = valueString;

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

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
@@ -185,7 +185,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase {
     }
 
     private void assertNoIntrinsicsMethodIsCalledInMyClasses(boolean noClassFileIsAnError) {
-        for (JetFile jetFile : myFiles.getPsiFiles()) {
+        for (KtFile jetFile : myFiles.getPsiFiles()) {
             String fileClassName = JvmFileClassUtil.getFileClassInfoNoResolve(jetFile).getFileClassFqName().asString();
             assertNoIntrinsicsMethodIsCalled(fileClassName, noClassFileIsAnError);
         }

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

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.descriptors.PackagePartProvider;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 
 import java.util.Collections;
@@ -36,7 +36,7 @@ public class GenerationUtils {
 
     @NotNull
     public static ClassFileFactory compileFileGetClassFileFactoryForTest(
-            @NotNull JetFile psiFile,
+            @NotNull KtFile psiFile,
             @NotNull KotlinCoreEnvironment environment
     ) {
         return compileFileGetGenerationStateForTest(psiFile, environment).getFactory();
@@ -44,7 +44,7 @@ public class GenerationUtils {
 
     @NotNull
     public static GenerationState compileFileGetGenerationStateForTest(
-            @NotNull JetFile psiFile,
+            @NotNull KtFile psiFile,
             @NotNull KotlinCoreEnvironment environment
     ) {
         AnalysisResult analysisResult =
@@ -53,12 +53,12 @@ public class GenerationUtils {
     }
 
     @NotNull
-    public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<JetFile> files) {
+    public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<KtFile> files) {
         return compileManyFilesGetGenerationStateForTest(project, files, PackagePartProvider.Companion.getEMPTY());
     }
 
     @NotNull
-    public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<JetFile> files,
+    public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<KtFile> files,
             @NotNull PackagePartProvider packagePartProvider
     ) {
         AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
@@ -70,7 +70,7 @@ public class GenerationUtils {
     public static GenerationState compileFilesGetGenerationState(
             @NotNull Project project,
             @NotNull AnalysisResult analysisResult,
-            @NotNull List<JetFile> files,
+            @NotNull List<KtFile> files,
             boolean useTypeTableInSerializer
     ) {
         analysisResult.throwIfError();

compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.kotlin.FileBasedKotlinClass
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.org.objectweb.asm.*
@@ -35,7 +35,7 @@ public object InlineTestUtil {
     private val KOTLIN_PACKAGE_DESC = "L" + AsmUtil.internalNameByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_PACKAGE) + ";"
     private val KOTLIN_MULTIFILE_CLASS_DESC = "L" + AsmUtil.internalNameByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_MULTIFILE_CLASS) + ";"
 
-    public fun checkNoCallsToInline(files: Iterable<OutputFile>, sourceFiles: List<JetFile>) {
+    public fun checkNoCallsToInline(files: Iterable<OutputFile>, sourceFiles: List<KtFile>) {
         val inlineInfo = obtainInlineInfo(files)
         val inlineMethods = inlineInfo.inlineMethods
         assert(!inlineMethods.isEmpty()) { "There are no inline methods" }

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

@@ -34,15 +34,15 @@ import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.ContentRootsKt;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.psi.JetClass;
-import org.jetbrains.kotlin.psi.JetDeclaration;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtClass;
+import org.jetbrains.kotlin.psi.KtDeclaration;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestJdkKind;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 
 import java.io.File;
 import java.lang.reflect.Modifier;
@@ -113,15 +113,15 @@ public class TestlibTest extends UsefulTestCase {
 
         typeMapper = generationState.getTypeMapper();
 
-        for (JetFile jetFile : myEnvironment.getSourceFiles()) {
-            for (JetDeclaration declaration : jetFile.getDeclarations()) {
-                if (!(declaration instanceof JetClass)) continue;
+        for (KtFile jetFile : myEnvironment.getSourceFiles()) {
+            for (KtDeclaration declaration : jetFile.getDeclarations()) {
+                if (!(declaration instanceof KtClass)) continue;
 
                 ClassDescriptor descriptor = (ClassDescriptor) BindingContextUtils.getNotNull(generationState.getBindingContext(),
                                                                                               BindingContext.DECLARATION_TO_DESCRIPTOR,
                                                                                               declaration);
 
-                for (JetType superType : getAllSupertypes(descriptor.getDefaultType())) {
+                for (KtType superType : getAllSupertypes(descriptor.getDefaultType())) {
                     if (!"junit/framework/Test".equals(typeMapper.mapType(superType).getInternalName())) continue;
 
                     String name = typeMapper.mapClass(descriptor).getInternalName();

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

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.org.objectweb.asm.*;
@@ -75,7 +75,7 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase {
 
         String fileText = FileUtil.loadFile(ktFile, true);
 
-        JetFile psiFile = JetTestUtils.createFile(ktFile.getName(), fileText, jetCoreEnvironment.getProject());
+        KtFile psiFile = JetTestUtils.createFile(ktFile.getName(), fileText, jetCoreEnvironment.getProject());
 
         OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment);
 

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

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.codegen.GeneratedClassLoader;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
@@ -160,7 +160,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         OutputUtilsKt.writeAllTo(classFileFactory, kotlinOut);
 
         List<String> javacOptions = new ArrayList<String>(0);
-        for (JetFile jetFile : myFiles.getPsiFiles()) {
+        for (KtFile jetFile : myFiles.getPsiFiles()) {
             javacOptions.addAll(InTextDirectivesUtils.findListWithPrefixes(jetFile.getText(), "// JAVAC_OPTIONS:"));
         }
 
@@ -179,7 +179,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
     protected void blackBox() {
         // If there are many files, the first 'box(): String' function will be executed.
         GeneratedClassLoader generatedClassLoader = generateAndCreateClassLoader();
-        for (JetFile firstFile : myFiles.getPsiFiles()) {
+        for (KtFile firstFile : myFiles.getPsiFiles()) {
             String className = JvmFileClassUtil.getFileClassInfoNoResolve(firstFile).getFacadeClassFqName().asString();
             Class<?> aClass = getGeneratedClass(generatedClassLoader, className);
             try {

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

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier;
 import org.jetbrains.kotlin.renderer.DescriptorRendererOptions;
@@ -81,7 +81,7 @@ public abstract class AbstractCompileJavaAgainstKotlinTest extends TestCaseWithT
                 EnvironmentConfigFiles.JVM_CONFIG_FILES
         );
 
-        AnalysisResult exhaust = JvmResolveUtil.analyzeFilesWithJavaIntegration(environment.getProject(), Collections.<JetFile>emptySet(), environment);
+        AnalysisResult exhaust = JvmResolveUtil.analyzeFilesWithJavaIntegration(environment.getProject(), Collections.<KtFile>emptySet(), environment);
         PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME);
         assertFalse(packageView.isEmpty());
 

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

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir;
@@ -108,7 +108,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends TestCaseWit
 
         String text = FileUtil.loadFile(file, true);
 
-        JetFile psiFile = JetTestUtils.createFile(file.getName(), text, jetCoreEnvironment.getProject());
+        KtFile psiFile = JetTestUtils.createFile(file.getName(), text, jetCoreEnvironment.getProject());
 
         ModuleVisibilityManager.SERVICE.getInstance(jetCoreEnvironment.getProject()).addModule(new ModuleBuilder("module for test", tmpdir.getAbsolutePath(), "test"));
 

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

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
@@ -190,7 +190,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                 compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, getAnnotationsJar(), libraryOut),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
-        JetFile jetFile = JetTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject());
+        KtFile jetFile = JetTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject());
 
         AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
                 environment.getProject(), Collections.singleton(jetFile)

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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.backend.common.output.OutputFile
 import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.org.objectweb.asm.ClassReader
 import org.jetbrains.org.objectweb.asm.ClassVisitor
@@ -44,7 +44,7 @@ public interface AbstractSMAPBaseTest {
         }.filterNotNull()
     }
 
-    private fun extractSmapFromSource(file: JetFile): SMAPAndFile? {
+    private fun extractSmapFromSource(file: KtFile): SMAPAndFile? {
         val fileContent = file.getText()
         val smapPrefix = "//SMAP"
         if (InTextDirectivesUtils.isDirectiveDefined(fileContent, smapPrefix)) {
@@ -58,7 +58,7 @@ public interface AbstractSMAPBaseTest {
         return null;
     }
 
-    fun checkSMAP(inputFiles: List<JetFile>, outputFiles: Iterable<OutputFile>) {
+    fun checkSMAP(inputFiles: List<KtFile>, outputFiles: Iterable<OutputFile>) {
         if (!InlineCodegenUtil.GENERATE_SMAP) {
             return
         }

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

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.load.java.JavaBindingContext;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.TypeTransformingVisitor;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -77,7 +77,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase
 
                 BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
                 ModuleDescriptor module = LazyResolveTestUtil.resolve(
-                        commonEnvironment.getProject(), trace, Collections.<JetFile>emptyList(), commonEnvironment
+                        commonEnvironment.getProject(), trace, Collections.<KtFile>emptyList(), commonEnvironment
                 );
 
                 AlternativeSignatureErrorFindingVisitor visitor =
@@ -155,7 +155,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase
             return null;
         }
 
-        private Void visitDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull JetScope memberScope) {
+        private Void visitDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull KtScope memberScope) {
             for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
                 member.acceptVoid(this);
             }

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

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.jvm.compiler
 
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedMemberScope
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import com.intellij.testFramework.UsefulTestCase
@@ -28,13 +28,13 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.resolve.MemberComparator
 
 class DeserializedScopeValidationVisitor : ValidationVisitor() {
-    override fun validateScope(scope: JetScope, collector: DescriptorValidator.DiagnosticCollector) {
+    override fun validateScope(scope: KtScope, collector: DescriptorValidator.DiagnosticCollector) {
         super.validateScope(scope, collector)
         validateDeserializedScope(scope)
     }
 }
 
-private fun validateDeserializedScope(scope: JetScope) {
+private fun validateDeserializedScope(scope: KtScope) {
     val isPackageViewScope = scope.safeGetContainingDeclaration() is PackageViewDescriptor
     if (scope is DeserializedMemberScope || isPackageViewScope) {
         val relevantDescriptors = scope.getAllDescriptors().filter { member ->
@@ -45,7 +45,7 @@ private fun validateDeserializedScope(scope: JetScope) {
 }
 
 //NOTE: see TypeUtils#IntersectionScope#getContainingDeclaration()
-private fun JetScope.safeGetContainingDeclaration(): DeclarationDescriptor? {
+private fun KtScope.safeGetContainingDeclaration(): DeclarationDescriptor? {
     return try {
         getContainingDeclaration()
     }

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

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 
 import java.util.*;
 
@@ -95,7 +95,7 @@ public class ExpectedLoadErrorsUtil {
                 return null;
             }
 
-            private Void visitDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull JetScope memberScope) {
+            private Void visitDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull KtScope memberScope) {
                 for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
                     member.acceptVoid(this);
                 }

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

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
@@ -69,7 +69,7 @@ public final class LoadDescriptorUtil {
     ) {
         JetFilesAndAnalysisResult filesAndResult = JetFilesAndAnalysisResult.createJetFilesAndAnalyze(kotlinFiles, disposable, configurationKind);
         AnalysisResult result = filesAndResult.getAnalysisResult();
-        List<JetFile> files = filesAndResult.getJetFiles();
+        List<KtFile> files = filesAndResult.getJetFiles();
         GenerationState state = GenerationUtils.compileFilesGetGenerationState(
                 files.get(0).getProject(), result, files, useTypeTableInSerializer
         );
@@ -107,7 +107,7 @@ public final class LoadDescriptorUtil {
 
         BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         ModuleDescriptor module = LazyResolveTestUtil
-                .resolve(environment.getProject(), trace, Collections.<JetFile>emptyList(), environment);
+                .resolve(environment.getProject(), trace, Collections.<KtFile>emptyList(), environment);
 
         PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
         return Pair.create(packageView, trace.getBindingContext());
@@ -131,9 +131,9 @@ public final class LoadDescriptorUtil {
                 @NotNull ConfigurationKind configurationKind
         ) {
             final KotlinCoreEnvironment jetCoreEnvironment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, configurationKind);
-            List<JetFile> jetFiles = ContainerUtil.map(kotlinFiles, new Function<File, JetFile>() {
+            List<KtFile> jetFiles = ContainerUtil.map(kotlinFiles, new Function<File, KtFile>() {
                 @Override
-                public JetFile fun(File kotlinFile) {
+                public KtFile fun(File kotlinFile) {
                     try {
                         return JetTestUtils.createFile(
                                 kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), jetCoreEnvironment.getProject());
@@ -148,16 +148,16 @@ public final class LoadDescriptorUtil {
             return new JetFilesAndAnalysisResult(jetFiles, result);
         }
 
-        private final List<JetFile> jetFiles;
+        private final List<KtFile> jetFiles;
         private final AnalysisResult result;
 
-        private JetFilesAndAnalysisResult(@NotNull List<JetFile> jetFiles, @NotNull AnalysisResult result) {
+        private JetFilesAndAnalysisResult(@NotNull List<KtFile> jetFiles, @NotNull AnalysisResult result) {
             this.jetFiles = jetFiles;
             this.result = result;
         }
 
         @NotNull
-        public List<JetFile> getJetFiles() {
+        public List<KtFile> getJetFiles() {
             return jetFiles;
         }
 

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

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
@@ -47,7 +47,7 @@ import java.util.HashMap
 
 public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
 
-    private class TestModule(val _name: String, val kotlinFiles: List<JetFile>, val javaFilesScope: GlobalSearchScope,
+    private class TestModule(val _name: String, val kotlinFiles: List<KtFile>, val javaFilesScope: GlobalSearchScope,
                              val _dependencies: TestModule.() -> List<TestModule>) :
             ModuleInfo {
         override fun dependencies() = _dependencies()

compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt

@@ -138,7 +138,7 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
         val generatedPackageDir = File(tmpdir, LoadDescriptorUtil.TEST_PACKAGE_FQNAME.pathSegments().single().asString())
         val allClassFiles = FileUtil.findFilesByMask(Pattern.compile(".*\\.class"), generatedPackageDir)
 
-        val packageScopes = arrayListOf<JetScope>()
+        val packageScopes = arrayListOf<KtScope>()
         val classes = arrayListOf<ClassDescriptor>()
         var shouldAddPackageView = false
         for (classFile in allClassFiles) {
@@ -182,12 +182,12 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
     }
 
     private class SyntheticPackageViewForTest(override val module: ModuleDescriptor,
-                                              packageScopes: List<JetScope>,
+                                              packageScopes: List<KtScope>,
                                               classes: List<ClassifierDescriptor>) : PackageViewDescriptor {
-        private val scope: JetScope
+        private val scope: KtScope
 
         init {
-            val writableScope = WritableScopeImpl(JetScope.Empty, this, RedeclarationHandler.THROW_EXCEPTION, "runtime descriptor loader test")
+            val writableScope = WritableScopeImpl(KtScope.Empty, this, RedeclarationHandler.THROW_EXCEPTION, "runtime descriptor loader test")
             classes.forEach { writableScope.addClassifierDescriptor(it) }
             writableScope.changeLockLevel(WritableScope.LockLevel.READING)
             scope = ChainedScope(this, "synthetic package view for test", writableScope, *packageScopes.toTypedArray())
@@ -195,7 +195,7 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
 
         override val fqName: FqName
             get() = LoadDescriptorUtil.TEST_PACKAGE_FQNAME
-        override val memberScope: JetScope
+        override val memberScope: KtScope
             get() = scope
         override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>, data: D): R =
                 visitor.visitPackageViewDescriptor(this, data)

compiler/tests/org/jetbrains/kotlin/parsing/AbstractJetParsingTest.java

@@ -28,7 +28,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.testFramework.ParsingTestCase;
 import com.intellij.util.PathUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.JetNodeTypes;
+import org.jetbrains.kotlin.KtNodeTypes;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
@@ -50,7 +50,7 @@ public abstract class AbstractJetParsingTest extends ParsingTestCase {
         super(".", "kt", new JetParserDefinition());
     }
 
-    private static void checkPsiGetters(JetElement elem) throws Throwable {
+    private static void checkPsiGetters(KtElement elem) throws Throwable {
         Method[] methods = elem.getClass().getDeclaredMethods();
         for (Method method : methods) {
             String methodName = method.getName();
@@ -83,24 +83,24 @@ public abstract class AbstractJetParsingTest extends ParsingTestCase {
     }
 
     protected void doParsingTest(@NotNull String filePath) throws Exception {
-        doBaseTest(filePath, JetNodeTypes.JET_FILE);
+        doBaseTest(filePath, KtNodeTypes.JET_FILE);
     }
 
     protected void doExpressionCodeFragmentParsingTest(@NotNull String filePath) throws Exception {
-        doBaseTest(filePath, JetNodeTypes.EXPRESSION_CODE_FRAGMENT);
+        doBaseTest(filePath, KtNodeTypes.EXPRESSION_CODE_FRAGMENT);
     }
 
     protected void doBlockCodeFragmentParsingTest(@NotNull String filePath) throws Exception {
-        doBaseTest(filePath, JetNodeTypes.BLOCK_CODE_FRAGMENT);
+        doBaseTest(filePath, KtNodeTypes.BLOCK_CODE_FRAGMENT);
     }
 
     private void doBaseTest(@NotNull String filePath, @NotNull IElementType fileType) throws Exception {
         myFileExt = FileUtilRt.getExtension(PathUtil.getFileName(filePath));
         myFile = createFile(filePath, fileType);
 
-        myFile.acceptChildren(new JetVisitorVoid() {
+        myFile.acceptChildren(new KtVisitorVoid() {
             @Override
-            public void visitJetElement(@NotNull JetElement element) {
+            public void visitJetElement(@NotNull KtElement element) {
                 element.acceptChildren(this);
                 try {
                     checkPsiGetters(element);
@@ -115,11 +115,11 @@ public abstract class AbstractJetParsingTest extends ParsingTestCase {
     }
 
     private PsiFile createFile(@NotNull String filePath, @NotNull IElementType fileType) throws Exception {
-        JetPsiFactory psiFactory = JetPsiFactoryKt.JetPsiFactory(myProject);
-        if (fileType == JetNodeTypes.EXPRESSION_CODE_FRAGMENT) {
+        KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(myProject);
+        if (fileType == KtNodeTypes.EXPRESSION_CODE_FRAGMENT) {
             return psiFactory.createExpressionCodeFragment(loadFile(filePath), null);
         }
-        else if (fileType == JetNodeTypes.BLOCK_CODE_FRAGMENT) {
+        else if (fileType == KtNodeTypes.BLOCK_CODE_FRAGMENT) {
             return psiFactory.createBlockCodeFragment(loadFile(filePath), null);
         }
         else {

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

@@ -35,19 +35,19 @@ import java.util.regex.Pattern;
 
 public class JetPsiUtilTest extends JetLiteFixture {
     public void testUnquotedIdentifier() {
-        Assert.assertEquals("", JetPsiUtil.unquoteIdentifier(""));
-        Assert.assertEquals("a2", JetPsiUtil.unquoteIdentifier("a2"));
-        Assert.assertEquals("", JetPsiUtil.unquoteIdentifier("``"));
-        Assert.assertEquals("a2", JetPsiUtil.unquoteIdentifier("`a2`"));
+        Assert.assertEquals("", KtPsiUtil.unquoteIdentifier(""));
+        Assert.assertEquals("a2", KtPsiUtil.unquoteIdentifier("a2"));
+        Assert.assertEquals("", KtPsiUtil.unquoteIdentifier("``"));
+        Assert.assertEquals("a2", KtPsiUtil.unquoteIdentifier("`a2`"));
     }
 
     public void testUnquotedIdentifierOrFieldReference() {
-        Assert.assertEquals("", JetPsiUtil.unquoteIdentifierOrFieldReference(""));
-        Assert.assertEquals("a2", JetPsiUtil.unquoteIdentifierOrFieldReference("a2"));
-        Assert.assertEquals("", JetPsiUtil.unquoteIdentifierOrFieldReference("``"));
-        Assert.assertEquals("a2", JetPsiUtil.unquoteIdentifierOrFieldReference("`a2`"));
-        Assert.assertEquals("$a2", JetPsiUtil.unquoteIdentifierOrFieldReference("$a2"));
-        Assert.assertEquals("$a2", JetPsiUtil.unquoteIdentifierOrFieldReference("$`a2`"));
+        Assert.assertEquals("", KtPsiUtil.unquoteIdentifierOrFieldReference(""));
+        Assert.assertEquals("a2", KtPsiUtil.unquoteIdentifierOrFieldReference("a2"));
+        Assert.assertEquals("", KtPsiUtil.unquoteIdentifierOrFieldReference("``"));
+        Assert.assertEquals("a2", KtPsiUtil.unquoteIdentifierOrFieldReference("`a2`"));
+        Assert.assertEquals("$a2", KtPsiUtil.unquoteIdentifierOrFieldReference("$a2"));
+        Assert.assertEquals("$a2", KtPsiUtil.unquoteIdentifierOrFieldReference("$`a2`"));
     }
 
     public void testConvertToImportPath() {
@@ -71,18 +71,18 @@ public class JetPsiUtilTest extends JetLiteFixture {
 
     public void testIsLocalClass() throws IOException {
         String text = FileUtil.loadFile(new File(getTestDataPath() + "/psiUtil/isLocalClass.kt"), true);
-        JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(text);
+        KtClass aClass = KtPsiFactoryKt.KtPsiFactory(getProject()).createClass(text);
 
         @SuppressWarnings("unchecked")
-        Collection<JetClassOrObject> classOrObjects = PsiTreeUtil.collectElementsOfType(aClass, JetClassOrObject.class);
+        Collection<KtClassOrObject> classOrObjects = PsiTreeUtil.collectElementsOfType(aClass, KtClassOrObject.class);
 
-        for (JetClassOrObject classOrObject : classOrObjects) {
+        for (KtClassOrObject classOrObject : classOrObjects) {
             String classOrObjectName = classOrObject.getName();
             if (classOrObjectName != null && classOrObjectName.contains("Local")) {
-                assertTrue("JetPsiUtil.isLocalClass should return true for " + classOrObjectName, JetPsiUtil.isLocal(classOrObject));
+                assertTrue("JetPsiUtil.isLocalClass should return true for " + classOrObjectName, KtPsiUtil.isLocal(classOrObject));
             }
             else {
-                assertFalse("JetPsiUtil.isLocalClass should return false for " + classOrObjectName, JetPsiUtil.isLocal(classOrObject));
+                assertFalse("JetPsiUtil.isLocalClass should return false for " + classOrObjectName, KtPsiUtil.isLocal(classOrObject));
             }
         }
     }
@@ -101,8 +101,8 @@ public class JetPsiUtilTest extends JetLiteFixture {
     }
 
     private ImportPath getImportPathFromParsed(String text) {
-        JetImportDirective importDirective =
-                PsiTreeUtil.findChildOfType(JetPsiFactoryKt.JetPsiFactory(getProject()).createFile(text), JetImportDirective.class);
+        KtImportDirective importDirective =
+                PsiTreeUtil.findChildOfType(KtPsiFactoryKt.KtPsiFactory(getProject()).createFile(text), KtImportDirective.class);
 
         assertNotNull("At least one import directive is expected", importDirective);
 
@@ -113,7 +113,7 @@ public class JetPsiUtilTest extends JetLiteFixture {
         String trueResultString = "/*true*/";
         String falseResultString = "/*false*/";
 
-        JetFile file = loadPsiFile(new File("psiUtil/" + getTestName(true) + ".kt").getPath());
+        KtFile file = loadPsiFile(new File("psiUtil/" + getTestName(true) + ".kt").getPath());
         String text = file.getText();
 
         // /*true*/|/*false*/
@@ -124,13 +124,13 @@ public class JetPsiUtilTest extends JetLiteFixture {
             boolean expected = trueResultString.equals(matcher.group());
             int offset = matcher.end();
 
-            JetSimpleNameExpression expression = PsiTreeUtil.findElementOfClassAtOffset(file, offset, JetSimpleNameExpression.class, true);
+            KtSimpleNameExpression expression = PsiTreeUtil.findElementOfClassAtOffset(file, offset, KtSimpleNameExpression.class, true);
 
             String modifiedWithOffset = new StringBuilder(text).insert(offset, "<======caret======>").toString();
 
             Assert.assertNotNull("Can't find expression in text:\n" + modifiedWithOffset, expression);
             Assert.assertSame(expected + " result was expected at\n" + modifiedWithOffset,
-                              expected, JetPsiUtil.isSelectorInQualified(expression));
+                              expected, KtPsiUtil.isSelectorInQualified(expression));
         }
     }
 }

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

@@ -32,7 +32,7 @@ public class JetSimpleNameExpressionTest : JetLiteFixture() {
         assertReceiver("1 to 2", "1")
     }
     private fun assertReceiver(exprString: String, expected: String) {
-        val expression = JetPsiFactory(getProject()).createExpression(exprString) as JetBinaryExpression
+        val expression = KtPsiFactory(getProject()).createExpression(exprString) as KtBinaryExpression
         Assert.assertEquals(expected, expression.getOperationReference().getReceiverExpression()!!.getText())
     }
     override fun createEnvironment(): KotlinCoreEnvironment {

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

@@ -43,7 +43,7 @@ import java.io.File
 import java.util.ArrayList
 
 public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
-    protected open fun getDescriptor(declaration: JetDeclaration, container: ComponentProvider): DeclarationDescriptor {
+    protected open fun getDescriptor(declaration: KtDeclaration, container: ComponentProvider): DeclarationDescriptor {
         return container.get<ResolveSession>().resolveToDescriptor(declaration)
     }
 
@@ -52,7 +52,7 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
 
     public fun doTest(path: String) {
         val fileText = FileUtil.loadFile(File(path), true)
-        val psiFile = JetPsiFactory(getProject()).createFile(fileText)
+        val psiFile = KtPsiFactory(getProject()).createFile(fileText)
 
         val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject(), environment.getModuleName())
 
@@ -71,8 +71,8 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
 
         val descriptors = ArrayList<DeclarationDescriptor>()
 
-        psiFile.accept(object : JetVisitorVoid() {
-            override fun visitJetFile(file: JetFile) {
+        psiFile.accept(object : KtVisitorVoid() {
+            override fun visitJetFile(file: KtFile) {
                 val fqName = file.getPackageFqName()
                 if (!fqName.isRoot()) {
                     val packageDescriptor = context.module.getPackage(fqName)
@@ -81,23 +81,23 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                 file.acceptChildren(this)
             }
 
-            override fun visitParameter(parameter: JetParameter) {
+            override fun visitParameter(parameter: KtParameter) {
                 val declaringElement = parameter.getParent().getParent()
                 when (declaringElement) {
-                    is JetFunctionType -> return
-                    is JetNamedFunction ->
+                    is KtFunctionType -> return
+                    is KtNamedFunction ->
                         addCorrespondingParameterDescriptor(getDescriptor(declaringElement, container) as FunctionDescriptor, parameter)
-                    is JetPrimaryConstructor -> {
-                        val jetClassOrObject: JetClassOrObject = declaringElement.getContainingClassOrObject()
-                        val classDescriptor = getDescriptor(jetClassOrObject, container) as ClassDescriptor
+                    is KtPrimaryConstructor -> {
+                        val ktClassOrObject: KtClassOrObject = declaringElement.getContainingClassOrObject()
+                        val classDescriptor = getDescriptor(ktClassOrObject, container) as ClassDescriptor
                         addCorrespondingParameterDescriptor(classDescriptor.getUnsubstitutedPrimaryConstructor()!!, parameter)
                     }
                     else -> super.visitParameter(parameter)
                 }
             }
 
-            override fun visitPropertyAccessor(accessor: JetPropertyAccessor) {
-                val parent = accessor.getParent() as JetProperty
+            override fun visitPropertyAccessor(accessor: KtPropertyAccessor) {
+                val parent = accessor.getParent() as KtProperty
                 val propertyDescriptor = getDescriptor(parent, container) as PropertyDescriptor
                 if (accessor.isGetter()) {
                     descriptors.add(propertyDescriptor.getGetter()!!)
@@ -108,16 +108,16 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                 accessor.acceptChildren(this)
             }
 
-            override fun visitAnonymousInitializer(initializer: JetClassInitializer) {
+            override fun visitAnonymousInitializer(initializer: KtClassInitializer) {
                 initializer.acceptChildren(this)
             }
 
-            override fun visitDeclaration(element: JetDeclaration) {
+            override fun visitDeclaration(element: KtDeclaration) {
                 val descriptor = getDescriptor(element, container)
                 descriptors.add(descriptor)
                 if (descriptor is ClassDescriptor) {
                     // if class has primary constructor then we visit it later, otherwise add it artificially
-                    if (element !is JetClassOrObject || !element.hasExplicitPrimaryConstructor()) {
+                    if (element !is KtClassOrObject || !element.hasExplicitPrimaryConstructor()) {
                         if (descriptor.getUnsubstitutedPrimaryConstructor() != null) {
                             descriptors.add(descriptor.getUnsubstitutedPrimaryConstructor()!!)
                         }
@@ -126,11 +126,11 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
                 element.acceptChildren(this)
             }
 
-            override fun visitJetElement(element: JetElement) {
+            override fun visitJetElement(element: KtElement) {
                 element.acceptChildren(this)
             }
 
-            private fun addCorrespondingParameterDescriptor(functionDescriptor: FunctionDescriptor, parameter: JetParameter) {
+            private fun addCorrespondingParameterDescriptor(functionDescriptor: FunctionDescriptor, parameter: KtParameter) {
                 for (valueParameterDescriptor in functionDescriptor.getValueParameters()) {
                     if (valueParameterDescriptor.getName() == parameter.getNameAsName()) {
                         descriptors.add(valueParameterDescriptor)

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

@@ -22,10 +22,10 @@ import com.intellij.testFramework.UsefulTestCase
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.impl.FunctionExpressionDescriptor
-import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression
-import org.jetbrains.kotlin.psi.JetNamedFunction
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetTreeVisitorVoid
+import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment
@@ -37,17 +37,17 @@ import java.io.File
 abstract public class AbstractFunctionDescriptorInExpressionRendererTest : KotlinTestWithEnvironment() {
     public fun doTest(path: String) {
         val fileText = FileUtil.loadFile(File(path), true)
-        val file = JetPsiFactory(getProject()).createFile(fileText)
+        val file = KtPsiFactory(getProject()).createFile(fileText)
         val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(file).bindingContext
 
         val descriptors = arrayListOf<DeclarationDescriptor>()
 
-        file.accept(object : JetTreeVisitorVoid() {
-            override fun visitNamedFunction(function: JetNamedFunction) {
+        file.accept(object : KtTreeVisitorVoid() {
+            override fun visitNamedFunction(function: KtNamedFunction) {
                 function.acceptChildren(this)
                 descriptors.addIfNotNull(bindingContext.get(BindingContext.FUNCTION, function) as? FunctionExpressionDescriptor)
             }
-            override fun visitFunctionLiteralExpression(expression: JetFunctionLiteralExpression) {
+            override fun visitFunctionLiteralExpression(expression: KtFunctionLiteralExpression) {
                 expression.acceptChildren(this)
                 descriptors.add(bindingContext.get(BindingContext.FUNCTION, expression.getFunctionLiteral())!!)
             }

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

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.resolve;
 
 import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 
 public abstract class AbstractResolveTest extends ExtensibleResolveTestCase {
 
@@ -30,7 +30,7 @@ public abstract class AbstractResolveTest extends ExtensibleResolveTestCase {
                 JetExpectedResolveDataUtil.prepareDefaultNameToDeclaration(project, getEnvironment())
         ) {
             @Override
-            protected JetFile createJetFile(String fileName, String text) {
+            protected KtFile createJetFile(String fileName, String text) {
                 return createCheckAndReturnPsiFile(fileName, null, text);
             }
         };

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

@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.types.ErrorUtils;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeConstructor;
 
 import java.util.List;
@@ -58,7 +58,7 @@ public abstract class ExpectedResolveData {
     private static class Position {
         private final PsiElement element;
 
-        private Position(JetFile file, int offset) {
+        private Position(KtFile file, int offset) {
             this.element = file.findElementAt(offset);
         }
 
@@ -84,7 +84,7 @@ public abstract class ExpectedResolveData {
         this.nameToPsiElement = nameToPsiElement;
     }
 
-    public final JetFile createFileFromMarkedUpText(String fileName, String text) {
+    public final KtFile createFileFromMarkedUpText(String fileName, String text) {
         Map<String, Integer> declarationToIntPosition = Maps.newHashMap();
         Map<Integer, String> intPositionToReference = Maps.newHashMap();
         Map<Integer, String> intPositionToType = Maps.newHashMap();
@@ -117,7 +117,7 @@ public abstract class ExpectedResolveData {
             text = text.substring(0, start) + text.substring(matcher.end());
         }
 
-        JetFile jetFile = createJetFile(fileName, text);
+        KtFile jetFile = createJetFile(fileName, text);
 
         for (Map.Entry<Integer, String> entry : intPositionToType.entrySet()) {
             positionToType.put(new Position(jetFile, entry.getKey()), entry.getValue());
@@ -131,9 +131,9 @@ public abstract class ExpectedResolveData {
         return jetFile;
     }
 
-    protected abstract JetFile createJetFile(String fileName, String text);
+    protected abstract KtFile createJetFile(String fileName, String text);
 
-    protected static BindingContext analyze(List<JetFile> files, KotlinCoreEnvironment environment) {
+    protected static BindingContext analyze(List<KtFile> files, KotlinCoreEnvironment environment) {
         if (files.isEmpty()) {
             System.err.println("Suspicious: no files");
             return BindingContext.EMPTY;
@@ -168,9 +168,9 @@ public abstract class ExpectedResolveData {
                 ancestorOfType = element.getContainingFile();
             }
             else {
-                ancestorOfType = getAncestorOfType(JetDeclaration.class, element);
+                ancestorOfType = getAncestorOfType(KtDeclaration.class, element);
                 if (ancestorOfType == null) {
-                    JetPackageDirective directive = getAncestorOfType(JetPackageDirective.class, element);
+                    KtPackageDirective directive = getAncestorOfType(KtPackageDirective.class, element);
                     assert directive != null : "Not a declaration: " + name;
                     ancestorOfType = element;
                 }
@@ -184,7 +184,7 @@ public abstract class ExpectedResolveData {
             String name = entry.getValue();
             PsiElement element = position.getElement();
 
-            JetReferenceExpression referenceExpression = PsiTreeUtil.getParentOfType(element, JetReferenceExpression.class);
+            KtReferenceExpression referenceExpression = PsiTreeUtil.getParentOfType(element, KtReferenceExpression.class);
             DeclarationDescriptor referenceTarget = bindingContext.get(REFERENCE_TARGET, referenceExpression);
             if ("!".equals(name)) {
                 assertTrue(
@@ -232,10 +232,10 @@ public abstract class ExpectedResolveData {
                 expected = nameToPsiElement.get(name);
             }
 
-            JetReferenceExpression reference = getAncestorOfType(JetReferenceExpression.class, element);
+            KtReferenceExpression reference = getAncestorOfType(KtReferenceExpression.class, element);
             if (expected == null && name.startsWith(STANDARD_PREFIX)) {
                 DeclarationDescriptor expectedDescriptor = nameToDescriptor.get(name);
-                JetTypeReference typeReference = getAncestorOfType(JetTypeReference.class, element);
+                KtTypeReference typeReference = getAncestorOfType(KtTypeReference.class, element);
                 if (expectedDescriptor != null) {
                     DeclarationDescriptor actual = bindingContext.get(REFERENCE_TARGET, reference);
                     assertSame("Expected: " + name, expectedDescriptor.getOriginal(), actual == null
@@ -244,7 +244,7 @@ public abstract class ExpectedResolveData {
                     continue;
                 }
 
-                JetType actualType = bindingContext.get(BindingContext.TYPE, typeReference);
+                KtType actualType = bindingContext.get(BindingContext.TYPE, typeReference);
                 assertNotNull("Type " + name + " not resolved for reference " + name, actualType);
                 ClassifierDescriptor expectedClass = builtIns.getBuiltInClassByName(Name.identifier(name.substring(STANDARD_PREFIX.length())));
                 assertNotNull("Expected class not found: " + name);
@@ -254,7 +254,7 @@ public abstract class ExpectedResolveData {
             assert expected != null : "No declaration for " + name;
 
             if (referenceTarget instanceof PackageViewDescriptor) {
-                JetPackageDirective expectedDirective = PsiTreeUtil.getParentOfType(expected, JetPackageDirective.class);
+                KtPackageDirective expectedDirective = PsiTreeUtil.getParentOfType(expected, KtPackageDirective.class);
                 FqName expectedFqName;
                 if (expectedDirective != null) {
                     expectedFqName = expectedDirective.getFqName();
@@ -274,8 +274,8 @@ public abstract class ExpectedResolveData {
             PsiElement actual = referenceTarget == null
                                 ? bindingContext.get(BindingContext.LABEL_TARGET, referenceExpression)
                                 : DescriptorToSourceUtils.descriptorToDeclaration(referenceTarget);
-            if (actual instanceof JetSimpleNameExpression) {
-                actual = ((JetSimpleNameExpression)actual).getIdentifier();
+            if (actual instanceof KtSimpleNameExpression) {
+                actual = ((KtSimpleNameExpression)actual).getIdentifier();
             }
 
             String actualName = null;
@@ -297,9 +297,9 @@ public abstract class ExpectedResolveData {
             String typeName = entry.getValue();
 
             PsiElement element = position.getElement();
-            JetExpression expression = getAncestorOfType(JetExpression.class, element);
+            KtExpression expression = getAncestorOfType(KtExpression.class, element);
 
-            JetType expressionType = bindingContext.getType(expression);
+            KtType expressionType = bindingContext.getType(expression);
             TypeConstructor expectedTypeConstructor;
             if (typeName.startsWith(STANDARD_PREFIX)) {
                 String name = typeName.substring(STANDARD_PREFIX.length());
@@ -313,14 +313,14 @@ public abstract class ExpectedResolveData {
                 assertNotNull("Undeclared: " + typeName, declarationPosition);
                 PsiElement declElement = declarationPosition.getElement();
                 assertNotNull(declarationPosition);
-                JetDeclaration declaration = getAncestorOfType(JetDeclaration.class, declElement);
+                KtDeclaration declaration = getAncestorOfType(KtDeclaration.class, declElement);
                 assertNotNull(declaration);
-                if (declaration instanceof JetClass) {
+                if (declaration instanceof KtClass) {
                     ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, declaration);
                     expectedTypeConstructor = classDescriptor.getTypeConstructor();
                 }
-                else if (declaration instanceof JetTypeParameter) {
-                    TypeParameterDescriptor typeParameterDescriptor = bindingContext.get(BindingContext.TYPE_PARAMETER, (JetTypeParameter) declaration);
+                else if (declaration instanceof KtTypeParameter) {
+                    TypeParameterDescriptor typeParameterDescriptor = bindingContext.get(BindingContext.TYPE_PARAMETER, (KtTypeParameter) declaration);
                     expectedTypeConstructor = typeParameterDescriptor.getTypeConstructor();
                 }
                 else {
@@ -334,15 +334,15 @@ public abstract class ExpectedResolveData {
         }
     }
 
-    private static String renderReferenceInContext(JetReferenceExpression referenceExpression) {
-        JetExpression statement = referenceExpression;
+    private static String renderReferenceInContext(KtReferenceExpression referenceExpression) {
+        KtExpression statement = referenceExpression;
         while (true) {
             PsiElement parent = statement.getParent();
-            if (!(parent instanceof JetExpression)) break;
-            if (parent instanceof JetBlockExpression) break;
-            statement = (JetExpression) parent;
+            if (!(parent instanceof KtExpression)) break;
+            if (parent instanceof KtBlockExpression) break;
+            statement = (KtExpression) parent;
         }
-        JetDeclaration declaration = PsiTreeUtil.getParentOfType(referenceExpression, JetDeclaration.class);
+        KtDeclaration declaration = PsiTreeUtil.getParentOfType(referenceExpression, KtDeclaration.class);
 
 
 

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

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
@@ -53,10 +53,10 @@ public abstract class ExtensibleResolveTestCase extends JetLiteFixture {
     protected void doTest(@NonNls String filePath) throws Exception {
         File file = new File(filePath);
         String text = JetTestUtils.doLoadFile(file);
-        List<JetFile> files = JetTestUtils.createTestFiles("file.kt", text, new JetTestUtils.TestFileFactoryNoModules<JetFile>() {
+        List<KtFile> files = JetTestUtils.createTestFiles("file.kt", text, new JetTestUtils.TestFileFactoryNoModules<KtFile>() {
             @NotNull
             @Override
-            public JetFile create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives) {
+            public KtFile create(@NotNull String fileName, @NotNull String text, @NotNull Map<String, String> directives) {
                 return expectedResolveData.createFileFromMarkedUpText(fileName, text);
             }
         });

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

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.tests.di.ContainerForTests;
 import org.jetbrains.kotlin.tests.di.InjectionKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
 
@@ -129,7 +129,7 @@ public class JetExpectedResolveDataUtil {
             ClassDescriptor classDescriptor,
             String name,
             Project project,
-            JetType... parameterTypes
+            KtType... parameterTypes
     ) {
         ModuleDescriptorImpl emptyModule = JetTestUtils.createEmptyModule();
         ContainerForTests container = InjectionKt.createContainerForTests(project, emptyModule);

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

@@ -130,7 +130,7 @@ class MutableDiagnosticsTest : KotlinTestWithEnvironment() {
     }
 
     private inner class DummyDiagnostic : Diagnostic {
-        val dummyElement = JetPsiFactory(getEnvironment().project).createType("Int")
+        val dummyElement = KtPsiFactory(getEnvironment().project).createType("Int")
 
         init {
             dummyElement.getContainingJetFile().doNotAnalyze = null

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

@@ -33,15 +33,15 @@ import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetAnnotationEntry;
-import org.jetbrains.kotlin.psi.JetAnnotationUseSiteTarget;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
+import org.jetbrains.kotlin.psi.KtAnnotationUseSiteTarget;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier;
 import org.jetbrains.kotlin.renderer.DescriptorRendererOptions;
 import org.jetbrains.kotlin.renderer.NameShortness;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.types.TypeProjection;
@@ -84,7 +84,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     }
 
     protected void checkAnnotationOnAllExceptLocalDeclarations(String content, String expectedAnnotation) {
-        JetFile testFile = getFile(content);
+        KtFile testFile = getFile(content);
         PackageFragmentDescriptor testPackage = getPackage(testFile);
 
         checkAnnotationsOnFile(expectedAnnotation, testFile);
@@ -121,14 +121,14 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
         checkDescriptor(expectedAnnotation, getConstructorParameterDescriptor(myClass, "param"));
     }
 
-    private void checkAnnotationsOnFile(String expectedAnnotation, JetFile file) {
-        String actualAnnotation = StringUtil.join(file.getAnnotationEntries(), new Function<JetAnnotationEntry, String>() {
+    private void checkAnnotationsOnFile(String expectedAnnotation, KtFile file) {
+        String actualAnnotation = StringUtil.join(file.getAnnotationEntries(), new Function<KtAnnotationEntry, String>() {
             @Override
-            public String fun(JetAnnotationEntry annotationEntry) {
+            public String fun(KtAnnotationEntry annotationEntry) {
                 AnnotationDescriptor annotationDescriptor = context.get(BindingContext.ANNOTATION, annotationEntry);
                 assertNotNull(annotationDescriptor);
 
-                JetAnnotationUseSiteTarget target = annotationEntry.getUseSiteTarget();
+                KtAnnotationUseSiteTarget target = annotationEntry.getUseSiteTarget();
 
                 if (target != null) {
                     return WITH_ANNOTATION_ARGUMENT_TYPES.renderAnnotation(
@@ -167,7 +167,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     @NotNull
     protected static FunctionDescriptor getFunctionDescriptor(@NotNull PackageFragmentDescriptor packageView, @NotNull String name) {
         Name functionName = Name.identifier(name);
-        JetScope memberScope = packageView.getMemberScope();
+        KtScope memberScope = packageView.getMemberScope();
         Collection<FunctionDescriptor> functions = memberScope.getFunctions(functionName, NoLookupLocation.FROM_TEST);
         assert functions.size() == 1 : "Failed to find function " + functionName + " in class" + "." + packageView.getName();
         return functions.iterator().next();
@@ -176,7 +176,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     @NotNull
     private static FunctionDescriptor getFunctionDescriptor(@NotNull ClassDescriptor classDescriptor, @NotNull String name) {
         Name functionName = Name.identifier(name);
-        JetScope memberScope = classDescriptor.getMemberScope(Collections.<TypeProjection>emptyList());
+        KtScope memberScope = classDescriptor.getMemberScope(Collections.<TypeProjection>emptyList());
         Collection<FunctionDescriptor> functions = memberScope.getFunctions(functionName, NoLookupLocation.FROM_TEST);
         assert functions.size() == 1 : "Failed to find function " + functionName + " in class" + "." + classDescriptor.getName();
         return functions.iterator().next();
@@ -185,7 +185,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     @Nullable
     protected static PropertyDescriptor getPropertyDescriptor(@NotNull PackageFragmentDescriptor packageView, @NotNull String name, boolean failOnMissing) {
         Name propertyName = Name.identifier(name);
-        JetScope memberScope = packageView.getMemberScope();
+        KtScope memberScope = packageView.getMemberScope();
         Collection<VariableDescriptor> properties = memberScope.getProperties(propertyName, NoLookupLocation.FROM_TEST);
         if (properties.isEmpty()) {
             for (DeclarationDescriptor descriptor : memberScope.getAllDescriptors()) {
@@ -212,7 +212,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     @NotNull
     private static PropertyDescriptor getPropertyDescriptor(@NotNull ClassDescriptor classDescriptor, @NotNull String name) {
         Name propertyName = Name.identifier(name);
-        JetScope memberScope = classDescriptor.getMemberScope(Collections.<TypeProjection>emptyList());
+        KtScope memberScope = classDescriptor.getMemberScope(Collections.<TypeProjection>emptyList());
         Collection<VariableDescriptor> properties = memberScope.getProperties(propertyName, NoLookupLocation.FROM_TEST);
         assert properties.size() == 1 : "Failed to find property " + propertyName + " in class " + classDescriptor.getName();
         return (PropertyDescriptor) properties.iterator().next();
@@ -230,7 +230,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     @NotNull
     private static ClassDescriptor getInnerClassDescriptor(@NotNull ClassDescriptor classDescriptor, @NotNull String name) {
         Name propertyName = Name.identifier(name);
-        JetScope memberScope = classDescriptor.getMemberScope(Collections.<TypeProjection>emptyList());
+        KtScope memberScope = classDescriptor.getMemberScope(Collections.<TypeProjection>emptyList());
         ClassifierDescriptor innerClass = memberScope.getClassifier(propertyName, NoLookupLocation.FROM_TEST);
         assert innerClass instanceof ClassDescriptor : "Failed to find inner class " +
                                                        propertyName +
@@ -336,8 +336,8 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     }
 
     @NotNull
-    protected JetFile getFile(@NotNull String content) {
-        JetFile ktFile = JetTestUtils.createFile("dummy.kt", content, getProject());
+    protected KtFile getFile(@NotNull String content) {
+        KtFile ktFile = JetTestUtils.createFile("dummy.kt", content, getProject());
         AnalysisResult analysisResult = JetTestUtils.analyzeFile(ktFile, getEnvironment());
         context = analysisResult.getBindingContext();
 
@@ -345,7 +345,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix
     }
 
     @NotNull
-    protected PackageFragmentDescriptor getPackage(@NotNull JetFile ktFile) {
+    protected PackageFragmentDescriptor getPackage(@NotNull KtFile ktFile) {
         PackageFragmentDescriptor packageFragment = context.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, ktFile);
         assertNotNull("Failed to find package: " + PACKAGE, packageFragment);
         return packageFragment;

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

@@ -30,8 +30,8 @@ import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.psi.ValueArgument
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
 import org.jetbrains.kotlin.resolve.calls.callUtil.getParentResolvedCall
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
@@ -41,7 +41,7 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ClassReceiver
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import com.intellij.psi.PsiElement
 
 public abstract class AbstractResolvedCallsTest : JetLiteFixture() {
@@ -50,7 +50,7 @@ public abstract class AbstractResolvedCallsTest : JetLiteFixture() {
     public fun doTest(filePath: String) {
         val text = JetTestUtils.doLoadFile(File(filePath))!!
 
-        val jetFile = JetPsiFactory(getProject()).createFile(text.replace("<caret>", ""))
+        val jetFile = KtPsiFactory(getProject()).createFile(text.replace("<caret>", ""))
         val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(jetFile, environment).bindingContext
 
         val (element, cachedCall) = buildCachedCall(bindingContext, jetFile, text)
@@ -64,10 +64,10 @@ public abstract class AbstractResolvedCallsTest : JetLiteFixture() {
     }
 
     open protected fun buildCachedCall(
-            bindingContext: BindingContext, jetFile: JetFile, text: String
+            bindingContext: BindingContext, jetFile: KtFile, text: String
     ): Pair<PsiElement?, ResolvedCall<out CallableDescriptor>?> {
         val element = jetFile.findElementAt(text.indexOf("<caret>"))!!
-        val expression = element.getStrictParentOfType<JetExpression>()
+        val expression = element.getStrictParentOfType<KtExpression>()
 
         val cachedCall = expression?.getParentResolvedCall(bindingContext, strict = false)
         return Pair(element, cachedCall)

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

@@ -17,22 +17,22 @@
 package org.jetbrains.kotlin.resolve.calls
 
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
-import org.jetbrains.kotlin.psi.JetSecondaryConstructor
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 import org.jetbrains.kotlin.psi.debugText.getDebugText
 import org.jetbrains.kotlin.resolve.calls.callUtil.getParentResolvedCall
 
 
 abstract public class AbstractResolvedConstructorDelegationCallsTests : AbstractResolvedCallsTest() {
     override fun buildCachedCall(
-            bindingContext: BindingContext, jetFile: JetFile, text: String
+            bindingContext: BindingContext, jetFile: KtFile, text: String
     ): Pair<PsiElement?, ResolvedCall<out CallableDescriptor>?> {
         val element = jetFile.findElementAt(text.indexOf("<caret>"))
-        val constructor = element?.getNonStrictParentOfType<JetSecondaryConstructor>()!!
+        val constructor = element?.getNonStrictParentOfType<KtSecondaryConstructor>()!!
         val delegationCall = constructor.getDelegationCall()
 
         val cachedCall = delegationCall.getParentResolvedCall(bindingContext, strict = false)

compiler/tests/org/jetbrains/kotlin/resolve/constants/evaluate/AbstractEvaluateExpressionTest.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.constants.evaluate
 
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
-import org.jetbrains.kotlin.psi.JetProperty
+import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -64,7 +64,7 @@ public abstract class AbstractEvaluateExpressionTest : AbstractAnnotationDescrip
     }
 
     private fun evaluateInitializer(context: BindingContext, property: VariableDescriptor): CompileTimeConstant<*>? {
-        val propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property) as JetProperty
+        val propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property) as KtProperty
         val compileTimeConstant = ConstantExpressionEvaluator(property.builtIns).evaluateExpression(
                 propertyDeclaration.getInitializer()!!,
                 DelegatingBindingTrace(context, "trace for evaluating compile time constant"),

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

@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.test.JetLiteFixture
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.tests.di.createContainerForTests
 import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.KtType
 import org.jetbrains.kotlin.types.Variance
 import java.io.File
 import java.util.ArrayList
@@ -86,7 +86,7 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
         constraintSystem.registerTypeVariables(typeParameterDescriptors, { Variance.INVARIANT })
 
         val constraints = parseConstraints(constraintsFileText)
-        fun JetType.assertNotError(): JetType {
+        fun KtType.assertNotError(): KtType {
             assert(!ErrorUtils.containsErrorType(this)) { "Type $this is resolved to or contains error type" }
             return this
         }

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

@@ -20,18 +20,18 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.psi.JetFunction
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtFunction
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.TypeResolver
 import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstructor
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.types.JetTypeImpl
+import org.jetbrains.kotlin.types.KtType
+import org.jetbrains.kotlin.types.KtTypeImpl
 import java.util.regex.Pattern
 
 public class ConstraintSystemTestData(
@@ -45,7 +45,7 @@ public class ConstraintSystemTestData(
     init {
         val functions = context.getSliceContents(BindingContext.FUNCTION)
         functionFoo = findFunctionByName(functions.values(), "foo")
-        val function = DescriptorToSourceUtils.descriptorToDeclaration(functionFoo) as JetFunction
+        val function = DescriptorToSourceUtils.descriptorToDeclaration(functionFoo) as KtFunction
         val fooBody = function.getBodyExpression()
         scopeToResolveTypeParameters = context.get(BindingContext.LEXICAL_SCOPE, fooBody)!!
     }
@@ -60,17 +60,17 @@ public class ConstraintSystemTestData(
                throw AssertionError("Unsupported type parameter name: $name. You may add it to constraintSystem/declarations.kt")
     }
 
-    fun getType(name: String): JetType {
+    fun getType(name: String): KtType {
         val matcher = INTEGER_VALUE_TYPE_PATTERN.matcher(name)
         if (matcher.find()) {
             val number = matcher.group(1)!!
-            return JetTypeImpl.create(
+            return KtTypeImpl.create(
                     Annotations.EMPTY, IntegerValueTypeConstructor(number.toLong(), functionFoo.builtIns), false, listOf(),
-                    JetScope.Empty
+                    KtScope.Empty
             )
         }
         return typeResolver.resolveType(
-            scopeToResolveTypeParameters, JetPsiFactory(project).createType(name),
+            scopeToResolveTypeParameters, KtPsiFactory(project).createType(name),
             JetTestUtils.DUMMY_TRACE, true)
     }
 }

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

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.PackagePartProvider;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
@@ -36,12 +36,12 @@ public class JvmResolveUtil {
 
     public static String TEST_MODULE_NAME = "java-integration-test";
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull KtFile file) {
         return analyzeOneFileWithJavaIntegrationAndCheckForErrors(file, PackagePartProvider.Companion.getEMPTY());
     }
 
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file, @NotNull PackagePartProvider provider) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull KtFile file, @NotNull PackagePartProvider provider) {
         AnalyzingUtils.checkForSyntacticErrors(file);
 
         AnalysisResult analysisResult = analyzeOneFileWithJavaIntegration(file, provider);
@@ -52,24 +52,24 @@ public class JvmResolveUtil {
     }
 
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull KotlinCoreEnvironment environment) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull KtFile file,  @NotNull KotlinCoreEnvironment environment) {
         return analyzeOneFileWithJavaIntegration(file, new JvmPackagePartProvider(environment));
     }
 
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull PackagePartProvider provider) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull KtFile file,  @NotNull PackagePartProvider provider) {
         return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), provider);
     }
 
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull KtFile file) {
         return analyzeOneFileWithJavaIntegration(file, PackagePartProvider.Companion.getEMPTY());
     }
 
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors(
             @NotNull Project project,
-            @NotNull Collection<JetFile> files
+            @NotNull Collection<KtFile> files
     ) {
         return analyzeFilesWithJavaIntegrationAndCheckForErrors(project, files, PackagePartProvider.Companion.getEMPTY());
     }
@@ -77,10 +77,10 @@ public class JvmResolveUtil {
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors(
             @NotNull Project project,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull PackagePartProvider packagePartProvider
     ) {
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             AnalyzingUtils.checkForSyntacticErrors(file);
         }
 
@@ -94,7 +94,7 @@ public class JvmResolveUtil {
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegration(
             @NotNull Project project,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull KotlinCoreEnvironment environment
     ) {
         return analyzeFilesWithJavaIntegration(project, files, new JvmPackagePartProvider(environment));
@@ -103,7 +103,7 @@ public class JvmResolveUtil {
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegration(
             @NotNull Project project,
-            @NotNull Collection<JetFile> files,
+            @NotNull Collection<KtFile> files,
             @NotNull PackagePartProvider packagePartProvider
     ) {
 

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

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
@@ -41,11 +41,11 @@ public class LazyResolveTestUtil {
 
     @NotNull
     public static ModuleDescriptor resolveProject(@NotNull Project project, @NotNull KotlinCoreEnvironment environment) {
-        return resolve(project, Collections.<JetFile>emptyList(), environment);
+        return resolve(project, Collections.<KtFile>emptyList(), environment);
     }
 
     @NotNull
-    public static ModuleDescriptor resolve(@NotNull Project project, @NotNull List<JetFile> sourceFiles, @NotNull KotlinCoreEnvironment environment) {
+    public static ModuleDescriptor resolve(@NotNull Project project, @NotNull List<KtFile> sourceFiles, @NotNull KotlinCoreEnvironment environment) {
         return resolve(project, new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), sourceFiles, environment);
     }
 
@@ -53,7 +53,7 @@ public class LazyResolveTestUtil {
     public static ModuleDescriptor resolve(
             @NotNull Project project,
             @NotNull BindingTrace trace,
-            @NotNull List<JetFile> sourceFiles,
+            @NotNull List<KtFile> sourceFiles,
             @NotNull KotlinCoreEnvironment environment
     ) {
         ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, JvmResolveUtil.TEST_MODULE_NAME);
@@ -68,25 +68,25 @@ public class LazyResolveTestUtil {
 
     @NotNull
     public static KotlinCodeAnalyzer resolveLazilyWithSession(
-            @NotNull List<JetFile> files,
+            @NotNull List<KtFile> files,
             @NotNull KotlinCoreEnvironment environment,
             boolean addBuiltIns
     ) {
         return LazyResolveTestUtilsKt.createResolveSessionForFiles(environment.getProject(), files, addBuiltIns);
     }
 
-    public static ModuleDescriptor resolveLazily(List<JetFile> files, KotlinCoreEnvironment environment) {
+    public static ModuleDescriptor resolveLazily(List<KtFile> files, KotlinCoreEnvironment environment) {
         return resolveLazily(files, environment, true);
     }
 
-    public static ModuleDescriptor resolveLazily(List<JetFile> files, KotlinCoreEnvironment environment, boolean addBuiltIns) {
+    public static ModuleDescriptor resolveLazily(List<KtFile> files, KotlinCoreEnvironment environment, boolean addBuiltIns) {
         return resolveLazilyWithSession(files, environment, addBuiltIns).getModuleDescriptor();
     }
 
     @NotNull
-    public static Set<Name> getTopLevelPackagesFromFileList(@NotNull List<JetFile> files) {
+    public static Set<Name> getTopLevelPackagesFromFileList(@NotNull List<KtFile> files) {
         Set<Name> shortNames = Sets.newLinkedHashSet();
-        for (JetFile file : files) {
+        for (KtFile file : files) {
             List<Name> packageFqNameSegments = file.getPackageFqName().pathSegments();
             Name name = packageFqNameSegments.isEmpty() ? SpecialNames.ROOT_PACKAGE : packageFqNameSegments.get(0);
             shortNames.add(name);

compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt

@@ -23,14 +23,14 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 
 public fun createResolveSessionForFiles(
         project: Project,
-        syntheticFiles: Collection<JetFile>,
+        syntheticFiles: Collection<KtFile>,
         addBuiltIns: Boolean
 ): ResolveSession {
     val projectContext = ProjectContext(project)

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

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.types.Variance.*
 import org.jetbrains.kotlin.types.typesApproximation.approximateCapturedTypes
 import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.psi.JetPsiFactory
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.resolve.calls.inference.createCapturedType
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.types.typesApproximation.approximateCapturedTypesIfNecessary
@@ -51,7 +51,7 @@ public class CapturedTypeApproximationTest() : JetLiteFixture() {
 
         fun analyzeTestFile(testType: String) = run {
             val test = declarationsText.replace("#TestType#", testType)
-            val testFile = JetPsiFactory(getProject()).createFile(test)
+            val testFile = KtPsiFactory(getProject()).createFile(test)
             val bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegration(testFile).bindingContext
             val functions = bindingContext.getSliceContents(BindingContext.FUNCTION)
             val functionFoo = functions.values().firstOrNull { it.getName().asString() == "foo" } ?:

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

@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier;
 import org.jetbrains.kotlin.renderer.DescriptorRendererOptions;
@@ -82,7 +82,7 @@ public class LoadBuiltinsTest extends KotlinTestWithEnvironment {
 
         PackageFragmentDescriptor deserialized = createBuiltInsPackageFragment();
 
-        List<JetFile> files = JetTestUtils.loadToJetFiles(getEnvironment(), ContainerUtil.concat(
+        List<KtFile> files = JetTestUtils.loadToJetFiles(getEnvironment(), ContainerUtil.concat(
                 allFilesUnder("core/builtins/native"),
                 allFilesUnder("core/builtins/src")
         ));

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

@@ -24,7 +24,7 @@ import com.intellij.testFramework.LightVirtualFile;
 import com.intellij.testFramework.TestDataFile;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
 import org.junit.Assert;
 
@@ -33,7 +33,7 @@ import java.io.IOException;
 public abstract class JetLiteFixture extends KotlinTestWithEnvironment {
     @NonNls
     protected final String myFullDataPath;
-    private JetFile myFile;
+    private KtFile myFile;
 
     public JetLiteFixture(@NonNls String dataPath) {
         myFullDataPath = getTestDataPath() + "/" + dataPath;
@@ -43,7 +43,7 @@ public abstract class JetLiteFixture extends KotlinTestWithEnvironment {
         myFullDataPath = getTestDataPath();
     }
 
-    protected JetFile getFile() {
+    protected KtFile getFile() {
         return myFile;
     }
 
@@ -66,7 +66,7 @@ public abstract class JetLiteFixture extends KotlinTestWithEnvironment {
         return JetTestUtils.doLoadFile(myFullDataPath, name);
     }
 
-    protected JetFile createPsiFile(@Nullable String testName, @Nullable String fileName, String text) {
+    protected KtFile createPsiFile(@Nullable String testName, @Nullable String fileName, String text) {
         if (fileName == null) {
             Assert.assertNotNull(testName);
             fileName = testName + ".kt";
@@ -74,7 +74,7 @@ public abstract class JetLiteFixture extends KotlinTestWithEnvironment {
         return JetTestUtils.createFile(fileName, text, getProject());
     }
 
-    protected JetFile loadPsiFile(String name) {
+    protected KtFile loadPsiFile(String name) {
         try {
             return createPsiFile(name, null, loadFile(name));
         } catch (IOException e) {
@@ -100,8 +100,8 @@ public abstract class JetLiteFixture extends KotlinTestWithEnvironment {
         myFile = createCheckAndReturnPsiFile(name, null, text);
     }
 
-    protected JetFile createCheckAndReturnPsiFile(String testName, String fileName, String text) {
-        JetFile myFile = createPsiFile(testName, fileName, text);
+    protected KtFile createCheckAndReturnPsiFile(String testName, String fileName, String text) {
+        KtFile myFile = createPsiFile(testName, fileName, text);
         ensureParsed(myFile);
         assertEquals("light virtual file text mismatch", text, ((LightVirtualFile) myFile.getVirtualFile()).getContent().toString());
         assertEquals("virtual file text mismatch", text, LoadTextUtil.loadText(myFile.getVirtualFile()));

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

@@ -60,11 +60,11 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.diagnostics.Severity;
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.idea.KotlinLanguage;
-import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.TargetPlatform;
@@ -74,7 +74,7 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.test.util.JetTestUtilsKt;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.types.KtType;
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo;
 import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice;
 import org.jetbrains.kotlin.util.slicedMap.SlicedMap;
@@ -148,7 +148,7 @@ public class JetTestUtils {
 
                 @Nullable
                 @Override
-                public JetType getType(@NotNull JetExpression expression) {
+                public KtType getType(@NotNull KtExpression expression) {
                     return DUMMY_TRACE.getType(expression);
                 }
 
@@ -183,13 +183,13 @@ public class JetTestUtils {
 
         @Nullable
         @Override
-        public JetType getType(@NotNull JetExpression expression) {
+        public KtType getType(@NotNull KtExpression expression) {
             JetTypeInfo typeInfo = get(BindingContext.EXPRESSION_TYPE_INFO, expression);
             return typeInfo != null ? typeInfo.getType() : null;
         }
 
         @Override
-        public void recordType(@NotNull JetExpression expression, @Nullable JetType type) {
+        public void recordType(@NotNull KtExpression expression, @Nullable KtType type) {
         }
 
         @Override
@@ -231,7 +231,7 @@ public class JetTestUtils {
 
                 @Nullable
                 @Override
-                public JetType getType(@NotNull JetExpression expression) {
+                public KtType getType(@NotNull KtExpression expression) {
                     return DUMMY_EXCEPTION_ON_ERROR_TRACE.getType(expression);
                 }
 
@@ -264,12 +264,12 @@ public class JetTestUtils {
 
         @Nullable
         @Override
-        public JetType getType(@NotNull JetExpression expression) {
+        public KtType getType(@NotNull KtExpression expression) {
             return null;
         }
 
         @Override
-        public void recordType(@NotNull JetExpression expression, @Nullable JetType type) {
+        public void recordType(@NotNull KtExpression expression, @Nullable KtType type) {
         }
 
         @Override
@@ -287,7 +287,7 @@ public class JetTestUtils {
     }
 
     @NotNull
-    public static AnalysisResult analyzeFile(@NotNull JetFile file, @NotNull KotlinCoreEnvironment environment) {
+    public static AnalysisResult analyzeFile(@NotNull KtFile file, @NotNull KotlinCoreEnvironment environment) {
         return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file, environment);
     }
 
@@ -384,7 +384,7 @@ public class JetTestUtils {
     }
 
     @NotNull
-    public static JetFile createFile(@NotNull @NonNls final String name, @NotNull String text, @NotNull Project project) {
+    public static KtFile createFile(@NotNull @NonNls final String name, @NotNull String text, @NotNull Project project) {
         String shortName = name.substring(name.lastIndexOf('/') + 1);
         shortName = shortName.substring(shortName.lastIndexOf('\\') + 1);
         LightVirtualFile virtualFile = new LightVirtualFile(shortName, KotlinLanguage.INSTANCE, text) {
@@ -399,7 +399,7 @@ public class JetTestUtils {
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
         PsiFileFactoryImpl factory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project);
         //noinspection ConstantConditions
-        return (JetFile) factory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false);
+        return (KtFile) factory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false);
     }
 
     public static String doLoadFile(String myFullDataPath, String name) throws IOException {
@@ -460,7 +460,7 @@ public class JetTestUtils {
     public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException {
         List<ContentRoot> paths = environment.getConfiguration().get(CommonConfigurationKeys.CONTENT_ROOTS);
         if (paths == null) return;
-        List<JetFile> jetFiles = Lists.newArrayList();
+        List<KtFile> jetFiles = Lists.newArrayList();
         for (ContentRoot root : paths) {
             if (!(root instanceof KotlinSourceRoot)) continue;
 
@@ -691,14 +691,14 @@ public class JetTestUtils {
     }
 
     @NotNull
-    public static String getLastCommentInFile(@NotNull JetFile file) {
+    public static String getLastCommentInFile(@NotNull KtFile file) {
         return CollectionsKt.first(getLastCommentsInFile(file, CommentType.ALL, true));
     }
 
     @NotNull
-    public static List<String> getLastCommentsInFile(@NotNull JetFile file, CommentType commentType, boolean assertMustExist) {
+    public static List<String> getLastCommentsInFile(@NotNull KtFile file, CommentType commentType, boolean assertMustExist) {
         PsiElement lastChild = file.getLastChild();
-        if (lastChild != null && lastChild.getNode().getElementType().equals(JetTokens.WHITE_SPACE)) {
+        if (lastChild != null && lastChild.getNode().getElementType().equals(KtTokens.WHITE_SPACE)) {
             lastChild = lastChild.getPrevSibling();
         }
         assert lastChild != null;
@@ -706,13 +706,13 @@ public class JetTestUtils {
         List<String> comments = ContainerUtil.newArrayList();
 
         while (true) {
-            if (lastChild.getNode().getElementType().equals(JetTokens.BLOCK_COMMENT)) {
+            if (lastChild.getNode().getElementType().equals(KtTokens.BLOCK_COMMENT)) {
                 if (commentType == CommentType.ALL || commentType == CommentType.BLOCK_COMMENT) {
                     String lastChildText = lastChild.getText();
                     comments.add(lastChildText.substring(2, lastChildText.length() - 2).trim());
                 }
             }
-            else if (lastChild.getNode().getElementType().equals(JetTokens.EOL_COMMENT)) {
+            else if (lastChild.getNode().getElementType().equals(KtTokens.EOL_COMMENT)) {
                 if (commentType == CommentType.ALL || commentType == CommentType.LINE_COMMENT) {
                     comments.add(lastChild.getText().substring(2).trim());
                 }
@@ -894,14 +894,14 @@ public class JetTestUtils {
     }
 
     @NotNull
-    public static JetFile loadJetFile(@NotNull Project project, @NotNull File ioFile) throws IOException {
+    public static KtFile loadJetFile(@NotNull Project project, @NotNull File ioFile) throws IOException {
         String text = FileUtil.loadFile(ioFile, true);
-        return JetPsiFactoryKt.JetPsiFactory(project).createPhysicalFile(ioFile.getName(), text);
+        return KtPsiFactoryKt.KtPsiFactory(project).createPhysicalFile(ioFile.getName(), text);
     }
 
     @NotNull
-    public static List<JetFile> loadToJetFiles(@NotNull KotlinCoreEnvironment environment, @NotNull List<File> files) throws IOException {
-        List<JetFile> jetFiles = Lists.newArrayList();
+    public static List<KtFile> loadToJetFiles(@NotNull KotlinCoreEnvironment environment, @NotNull List<File> files) throws IOException {
+        List<KtFile> jetFiles = Lists.newArrayList();
         for (File file : files) {
             jetFiles.add(loadJetFile(environment.getProject(), file));
         }

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

@@ -24,8 +24,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.types.JetType;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
+import org.jetbrains.kotlin.types.KtType;
 import org.junit.Assert;
 
 import java.io.PrintStream;
@@ -83,7 +83,7 @@ public class DescriptorValidator {
             return this;
         }
 
-        protected void validateScope(@NotNull JetScope scope, @NotNull DiagnosticCollector collector) {
+        protected void validateScope(@NotNull KtScope scope, @NotNull DiagnosticCollector collector) {
             for (DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
                 if (recursiveFilter.apply(descriptor)) {
                     descriptor.accept(new ScopeValidatorVisitor(collector), scope);
@@ -93,7 +93,7 @@ public class DescriptorValidator {
 
         private void validateType(
                 @NotNull DeclarationDescriptor descriptor,
-                @Nullable JetType type,
+                @Nullable KtType type,
                 @NotNull DiagnosticCollector collector
         ) {
             if (type == null) {
@@ -134,9 +134,9 @@ public class DescriptorValidator {
         private void validateTypes(
                 DeclarationDescriptor descriptor,
                 DiagnosticCollector collector,
-                Collection<JetType> types
+                Collection<KtType> types
         ) {
-            for (JetType type : types) {
+            for (KtType type : types) {
                 validateType(descriptor, type, collector);
             }
         }
@@ -163,8 +163,8 @@ public class DescriptorValidator {
                 DeclarationDescriptor descriptor,
                 DiagnosticCollector collector,
                 String name,
-                JetType expected,
-                JetType actual
+                KtType expected,
+                KtType actual
         ) {
             if (expected.isError() && actual.isError()) {
                 assertEquals(descriptor, collector, name, expected.toString(), actual.toString());
@@ -235,7 +235,7 @@ public class DescriptorValidator {
         ) {
             validateTypeParameters(collector, descriptor.getTypeConstructor().getParameters());
 
-            Collection<JetType> supertypes = descriptor.getTypeConstructor().getSupertypes();
+            Collection<KtType> supertypes = descriptor.getTypeConstructor().getSupertypes();
             if (supertypes.isEmpty() && descriptor.getKind() != ClassKind.INTERFACE
                 && !KotlinBuiltIns.isSpecialClassWithNoSupertypes(descriptor)) {
                 report(collector, descriptor, "No supertypes for non-trait");
@@ -357,7 +357,7 @@ public class DescriptorValidator {
 
     }
 
-    private static class ScopeValidatorVisitor implements DeclarationDescriptorVisitor<Void, JetScope> {
+    private static class ScopeValidatorVisitor implements DeclarationDescriptorVisitor<Void, KtScope> {
         private final DiagnosticCollector collector;
 
         public ScopeValidatorVisitor(DiagnosticCollector collector) {
@@ -369,7 +369,7 @@ public class DescriptorValidator {
         }
 
         private void assertFound(
-                @NotNull JetScope scope,
+                @NotNull KtScope scope,
                 @NotNull DeclarationDescriptor expected,
                 @Nullable DeclarationDescriptor found,
                 boolean shouldBeSame
@@ -383,7 +383,7 @@ public class DescriptorValidator {
         }
 
         private void assertFound(
-                @NotNull JetScope scope,
+                @NotNull KtScope scope,
                 @NotNull DeclarationDescriptor expected,
                 @NotNull Collection<? extends DeclarationDescriptor> found
         ) {
@@ -394,14 +394,14 @@ public class DescriptorValidator {
 
         @Override
         public Void visitPackageFragmentDescriptor(
-                PackageFragmentDescriptor descriptor, JetScope scope
+                PackageFragmentDescriptor descriptor, KtScope scope
         ) {
             return null;
         }
 
         @Override
         public Void visitPackageViewDescriptor(
-                PackageViewDescriptor descriptor, JetScope scope
+                PackageViewDescriptor descriptor, KtScope scope
         ) {
             assertFound(scope, descriptor, scope.getPackage(descriptor.getName()), false);
             return null;
@@ -409,7 +409,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitVariableDescriptor(
-                VariableDescriptor descriptor, JetScope scope
+                VariableDescriptor descriptor, KtScope scope
         ) {
             assertFound(scope, descriptor, scope.getProperties(descriptor.getName(), NoLookupLocation.FROM_TEST));
             return null;
@@ -417,7 +417,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitFunctionDescriptor(
-                FunctionDescriptor descriptor, JetScope scope
+                FunctionDescriptor descriptor, KtScope scope
         ) {
             assertFound(scope, descriptor, scope.getFunctions(descriptor.getName(), NoLookupLocation.FROM_TEST));
             return null;
@@ -425,7 +425,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitTypeParameterDescriptor(
-                TypeParameterDescriptor descriptor, JetScope scope
+                TypeParameterDescriptor descriptor, KtScope scope
         ) {
             assertFound(scope, descriptor, scope.getClassifier(descriptor.getName(), NoLookupLocation.FROM_TEST), true);
             return null;
@@ -433,7 +433,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitClassDescriptor(
-                ClassDescriptor descriptor, JetScope scope
+                ClassDescriptor descriptor, KtScope scope
         ) {
             assertFound(scope, descriptor, scope.getClassifier(descriptor.getName(), NoLookupLocation.FROM_TEST), true);
             return null;
@@ -441,7 +441,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitModuleDeclaration(
-                ModuleDescriptor descriptor, JetScope scope
+                ModuleDescriptor descriptor, KtScope scope
         ) {
             report(descriptor, "Module found in scope: " + scope);
             return null;
@@ -449,7 +449,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitConstructorDescriptor(
-                ConstructorDescriptor descriptor, JetScope scope
+                ConstructorDescriptor descriptor, KtScope scope
         ) {
             report(descriptor, "Constructor found in scope: " + scope);
             return null;
@@ -457,7 +457,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitScriptDescriptor(
-                ScriptDescriptor descriptor, JetScope scope
+                ScriptDescriptor descriptor, KtScope scope
         ) {
             report(descriptor, "Script found in scope: " + scope);
             return null;
@@ -465,21 +465,21 @@ public class DescriptorValidator {
 
         @Override
         public Void visitPropertyDescriptor(
-                PropertyDescriptor descriptor, JetScope scope
+                PropertyDescriptor descriptor, KtScope scope
         ) {
             return visitVariableDescriptor(descriptor, scope);
         }
 
         @Override
         public Void visitValueParameterDescriptor(
-                ValueParameterDescriptor descriptor, JetScope scope
+                ValueParameterDescriptor descriptor, KtScope scope
         ) {
             return visitVariableDescriptor(descriptor, scope);
         }
 
         @Override
         public Void visitPropertyGetterDescriptor(
-                PropertyGetterDescriptor descriptor, JetScope scope
+                PropertyGetterDescriptor descriptor, KtScope scope
         ) {
             report(descriptor, "Getter found in scope: " + scope);
             return null;
@@ -487,7 +487,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitPropertySetterDescriptor(
-                PropertySetterDescriptor descriptor, JetScope scope
+                PropertySetterDescriptor descriptor, KtScope scope
         ) {
             report(descriptor, "Setter found in scope: " + scope);
             return null;
@@ -495,7 +495,7 @@ public class DescriptorValidator {
 
         @Override
         public Void visitReceiverParameterDescriptor(
-                ReceiverParameterDescriptor descriptor, JetScope scope
+                ReceiverParameterDescriptor descriptor, KtScope scope
         ) {
             report(descriptor, "Receiver parameter found in scope: " + scope);
             return null;

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

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.renderer.*;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.MemberComparator;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.utils.Printer;
 import org.junit.Assert;
@@ -128,7 +128,7 @@ public class RecursiveDescriptorComparator {
                 ClassDescriptor klass = (ClassDescriptor) descriptor;
                 appendSubDescriptors(descriptor, module,
                                      klass.getDefaultType().getMemberScope(), klass.getConstructors(), printer);
-                JetScope staticScope = klass.getStaticScope();
+                KtScope staticScope = klass.getStaticScope();
                 if (!staticScope.getAllDescriptors().isEmpty()) {
                     printer.println();
                     printer.println("// Static members");
@@ -185,7 +185,7 @@ public class RecursiveDescriptorComparator {
     private void appendSubDescriptors(
             @NotNull DeclarationDescriptor descriptor,
             @NotNull ModuleDescriptor module,
-            @NotNull JetScope memberScope,
+            @NotNull KtScope memberScope,
             @NotNull Collection<? extends DeclarationDescriptor> extraSubDescriptors,
             @NotNull Printer printer
     ) {

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

@@ -23,7 +23,7 @@ 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;
-import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
 import org.jetbrains.kotlin.resolve.lazy.LazyEntity;
 import org.jetbrains.kotlin.test.JetTestUtils;
@@ -43,7 +43,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment
         File ktFile = new File("compiler/testData/recursiveProcessor/declarations.kt");
         File txtFile = new File("compiler/testData/recursiveProcessor/declarations.txt");
         String text = FileUtil.loadFile(ktFile, true);
-        JetFile jetFile = JetTestUtils.createFile("declarations.kt", text, getEnvironment().getProject());
+        KtFile jetFile = JetTestUtils.createFile("declarations.kt", text, getEnvironment().getProject());
         AnalysisResult result = JetTestUtils.analyzeFile(jetFile, getEnvironment());
         PackageViewDescriptor testPackage = result.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test")));
 

compiler/tests/org/jetbrains/kotlin/test/util/jetTestUtils.kt

@@ -53,17 +53,17 @@ public fun PsiFile.findElementByCommentPrefix(commentText: String): PsiElement?
 public fun PsiFile.findElementsByCommentPrefix(prefix: String): Map<PsiElement, String> {
     var result = SmartFMap.emptyMap<PsiElement, String>()
     accept(
-            object : JetTreeVisitorVoid() {
+            object : KtTreeVisitorVoid() {
                 override fun visitComment(comment: PsiComment) {
                     val commentText = comment.getText()
                     if (commentText.startsWith(prefix)) {
                         val parent = comment.getParent()
                         val elementToAdd = when (parent) {
-                            is JetDeclaration -> parent
+                            is KtDeclaration -> parent
                             is PsiMember -> parent
                             else -> PsiTreeUtil.skipSiblingsForward(
                                     comment,
-                                    javaClass<PsiWhiteSpace>(), javaClass<PsiComment>(), javaClass<JetPackageDirective>()
+                                    javaClass<PsiWhiteSpace>(), javaClass<PsiComment>(), javaClass<KtPackageDirective>()
                             )
                         } as? PsiElement ?: return
 

compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt

@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.resolve.typeBinding.*
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
-import org.jetbrains.kotlin.psi.JetCallableDeclaration
-import org.jetbrains.kotlin.psi.JetDeclaration
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.utils.Printer
-import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.JetTestUtils.*
 
 abstract class AbstractJetTypeBindingTest : JetLiteFixture() {
@@ -38,7 +38,7 @@ abstract class AbstractJetTypeBindingTest : JetLiteFixture() {
 
         val analyzeResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(getProject(), listOf(testKtFile), environment)
 
-        val testDeclaration = testKtFile.getDeclarations().last()!! as JetCallableDeclaration
+        val testDeclaration = testKtFile.getDeclarations().last()!! as KtCallableDeclaration
 
         val typeBinding = testDeclaration.createTypeBindingForReturnType(analyzeResult.bindingContext)
 
@@ -55,7 +55,7 @@ abstract class AbstractJetTypeBindingTest : JetLiteFixture() {
         )
     }
 
-    private fun removeLastComment(file: JetFile): String {
+    private fun removeLastComment(file: KtFile): String {
         val fileText = file.getText()
         val lastIndex = fileText.indexOf("/*")
         return if (lastIndex > 0) {
@@ -65,7 +65,7 @@ abstract class AbstractJetTypeBindingTest : JetLiteFixture() {
     }
 
     private class MyPrinter(out: StringBuilder) : Printer(out) {
-        private fun JetType.render() = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(this)
+        private fun KtType.render() = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(this)
         private fun TypeParameterDescriptor?.render() = if (this == null) "null" else DescriptorRenderer.SHORT_NAMES_IN_TYPES.render(this)
 
         fun print(argument: TypeArgumentBinding<*>?): MyPrinter {

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

@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
@@ -70,7 +70,7 @@ public class BoundsSubstitutorTest extends KotlinTestWithEnvironment {
     //}
 
     private void doTest(String text, String expected) {
-        JetFile jetFile = JetPsiFactoryKt.JetPsiFactory(getProject()).createFile("fun.kt", text);
+        KtFile jetFile = KtPsiFactoryKt.KtPsiFactory(getProject()).createFile("fun.kt", text);
         ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment());
         Collection<FunctionDescriptor> functions =
                 module.getPackage(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f"), NoLookupLocation.FROM_TEST);

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

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.kotlin.resolve.scopes.WritableScope;
 import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
@@ -69,7 +69,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
         private final ModuleDescriptorImpl root = JetTestUtils.createEmptyModule("<test_root>");
         private DescriptorResolver descriptorResolver;
         private FunctionDescriptorResolver functionDescriptorResolver;
-        private JetScope scope;
+        private KtScope scope;
 
         public void setUp() throws Exception {
             ContainerForTests containerForTests = InjectionKt.createContainerForTests(getProject(), root);
@@ -83,12 +83,12 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
             descriptorResolver = null;
         }
 
-        private JetScope createScope(JetScope libraryScope) {
-            JetFile file = JetPsiFactoryKt
-                    .JetPsiFactory(getProject()).createFile("abstract class C { abstract fun foo(); abstract val a: Int }");
-            List<JetDeclaration> declarations = file.getDeclarations();
-            JetDeclaration aClass = declarations.get(0);
-            assert aClass instanceof JetClass;
+        private KtScope createScope(KtScope libraryScope) {
+            KtFile file = KtPsiFactoryKt
+                    .KtPsiFactory(getProject()).createFile("abstract class C { abstract fun foo(); abstract val a: Int }");
+            List<KtDeclaration> declarations = file.getDeclarations();
+            KtDeclaration aClass = declarations.get(0);
+            assert aClass instanceof KtClass;
             AnalysisResult bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(file);
             DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass);
             WritableScopeImpl scope = new WritableScopeImpl(
@@ -99,7 +99,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
             return scope;
         }
 
-        private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
+        private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, KtClass aClass) {
             ModuleContext moduleContext = ContextKt.ModuleContext(root, getProject());
             ResolveSession resolveSession = createLazyResolveSession(
                     moduleContext,
@@ -113,7 +113,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
         }
 
         private void testClassModality(String classDeclaration, ClassKind kind, Modality expectedModality) {
-            JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(classDeclaration);
+            KtClass aClass = KtPsiFactoryKt.KtPsiFactory(getProject()).createClass(classDeclaration);
             ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
 
             assertEquals(expectedModality, classDescriptor.getModality());
@@ -121,11 +121,11 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
 
         private void testFunctionModality(String classWithFunction, ClassKind kind, Modality expectedFunctionModality) {
-            JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(classWithFunction);
+            KtClass aClass = KtPsiFactoryKt.KtPsiFactory(getProject()).createClass(classWithFunction);
             ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
 
-            List<JetDeclaration> declarations = aClass.getDeclarations();
-            JetNamedFunction function = (JetNamedFunction) declarations.get(0);
+            List<KtDeclaration> declarations = aClass.getDeclarations();
+            KtNamedFunction function = (KtNamedFunction) declarations.get(0);
             SimpleFunctionDescriptor functionDescriptor =
                     functionDescriptorResolver.resolveFunctionDescriptor(classDescriptor, ScopeUtilsKt.asLexicalScope(scope), function,
                                                                          JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
@@ -134,11 +134,11 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
         }
 
         private void testPropertyModality(String classWithProperty, ClassKind kind, Modality expectedPropertyModality) {
-            JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(classWithProperty);
+            KtClass aClass = KtPsiFactoryKt.KtPsiFactory(getProject()).createClass(classWithProperty);
             ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
 
-            List<JetDeclaration> declarations = aClass.getDeclarations();
-            JetProperty property = (JetProperty) declarations.get(0);
+            List<KtDeclaration> declarations = aClass.getDeclarations();
+            KtProperty property = (KtProperty) declarations.get(0);
             PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(
                     classDescriptor, ScopeUtilsKt.asLexicalScope(scope), property, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
 
@@ -147,11 +147,11 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
 
         private void testPropertyAccessorModality(String classWithPropertyWithAccessor, ClassKind kind, Modality expectedPropertyAccessorModality, boolean isGetter) {
-            JetClass aClass = JetPsiFactoryKt.JetPsiFactory(getProject()).createClass(classWithPropertyWithAccessor);
+            KtClass aClass = KtPsiFactoryKt.KtPsiFactory(getProject()).createClass(classWithPropertyWithAccessor);
             ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
 
-            List<JetDeclaration> declarations = aClass.getDeclarations();
-            JetProperty property = (JetProperty) declarations.get(0);
+            List<KtDeclaration> declarations = aClass.getDeclarations();
+            KtProperty property = (KtProperty) declarations.get(0);
             PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(
                     classDescriptor, ScopeUtilsKt.asLexicalScope(scope), property, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
             PropertyAccessorDescriptor propertyAccessor = isGetter

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

@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.types;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.resolve.OverloadUtil;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
@@ -172,7 +172,7 @@ public class JetOverloadTest extends JetLiteFixture {
     }
 
     private FunctionDescriptor makeFunction(String funDecl) {
-        JetNamedFunction function = JetPsiFactoryKt.JetPsiFactory(getProject()).createFunction(funDecl);
+        KtNamedFunction function = KtPsiFactoryKt.KtPsiFactory(getProject()).createFunction(funDecl);
         FileScope scope = ScopeUtilsKt.memberScopeAsFileScope(JvmPlatform.INSTANCE$.getBuiltIns().getBuiltInsPackageScope());
         return functionDescriptorResolver.resolveFunctionDescriptor(root, scope, function, JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);
     }

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

@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.types;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.psi.JetNamedFunction;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.resolve.OverridingUtil;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
@@ -162,7 +162,7 @@ public class JetOverridingTest extends JetLiteFixture {
     }
 
     private FunctionDescriptor makeFunction(String funDecl) {
-        JetNamedFunction function = JetPsiFactoryKt.JetPsiFactory(getProject()).createFunction(funDecl);
+        KtNamedFunction function = KtPsiFactoryKt.KtPsiFactory(getProject()).createFunction(funDecl);
         LexicalScope scope = ScopeUtilsKt.asLexicalScope(root.getBuiltIns().getBuiltInsPackageScope());
         return functionDescriptorResolver.resolveFunctionDescriptor(root, scope, function,
                                                                     JetTestUtils.DUMMY_TRACE, DataFlowInfo.EMPTY);

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

@@ -31,8 +31,8 @@ import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetExpression;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
 import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.ImportPath;
 import org.jetbrains.kotlin.resolve.TypeResolver;
@@ -46,7 +46,7 @@ import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.tests.di.ContainerForTests;
 import org.jetbrains.kotlin.tests.di.InjectionKt;
-import org.jetbrains.kotlin.types.checker.JetTypeChecker;
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 
 import java.io.File;
@@ -56,7 +56,7 @@ import java.util.*;
 public class JetTypeCheckerTest extends JetLiteFixture {
 
     private KotlinBuiltIns builtIns;
-    private JetScope scopeWithImports;
+    private KtScope scopeWithImports;
     private TypeResolver typeResolver;
     private ExpressionTypingServices expressionTypingServices;
 
@@ -498,10 +498,10 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     private void assertSupertypes(String typeStr, String... supertypeStrs) {
-        Set<JetType> allSupertypes = TypeUtils.getAllSupertypes(makeType(scopeWithImports, typeStr));
-        Set<JetType> expected = Sets.newHashSet();
+        Set<KtType> allSupertypes = TypeUtils.getAllSupertypes(makeType(scopeWithImports, typeStr));
+        Set<KtType> expected = Sets.newHashSet();
         for (String supertypeStr : supertypeStrs) {
-            JetType supertype = makeType(scopeWithImports, supertypeStr);
+            KtType supertype = makeType(scopeWithImports, supertypeStr);
             expected.add(supertype);
         }
         assertEquals(expected, allSupertypes);
@@ -516,54 +516,54 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     }
 
     private void assertIntersection(String expected, String... types) {
-        Set<JetType> typesToIntersect = new LinkedHashSet<JetType>();
+        Set<KtType> typesToIntersect = new LinkedHashSet<KtType>();
         for (String type : types) {
             typesToIntersect.add(makeType(type));
         }
-        JetType result = TypeIntersector.intersectTypes(JetTypeChecker.DEFAULT, typesToIntersect);
+        KtType result = TypeIntersector.intersectTypes(KotlinTypeChecker.DEFAULT, typesToIntersect);
 //        assertNotNull("Intersection is null for " + typesToIntersect, result);
         assertEquals(makeType(expected), result);
     }
 
     private void assertCommonSupertype(String expected, String... types) {
-        Collection<JetType> subtypes = new ArrayList<JetType>();
+        Collection<KtType> subtypes = new ArrayList<KtType>();
         for (String type : types) {
             subtypes.add(makeType(type));
         }
-        JetType result = CommonSupertypes.commonSupertype(subtypes);
+        KtType result = CommonSupertypes.commonSupertype(subtypes);
         assertTrue(result + " != " + expected, result.equals(makeType(expected)));
     }
 
     private void assertSubtypingRelation(String subtype, String supertype, boolean expected) {
-        JetType typeNode1 = makeType(subtype);
-        JetType typeNode2 = makeType(supertype);
-        boolean result = JetTypeChecker.DEFAULT.isSubtypeOf(
+        KtType typeNode1 = makeType(subtype);
+        KtType typeNode2 = makeType(supertype);
+        boolean result = KotlinTypeChecker.DEFAULT.isSubtypeOf(
                 typeNode1,
                 typeNode2);
         String modifier = expected ? "not " : "";
         assertTrue(typeNode1 + " is " + modifier + "a subtype of " + typeNode2, result == expected);
     }
 
-    private void assertType(String expression, JetType expectedType) {
+    private void assertType(String expression, KtType expectedType) {
         Project project = getProject();
-        JetExpression jetExpression = JetPsiFactoryKt.JetPsiFactory(project).createExpression(expression);
-        JetType type = expressionTypingServices.getType(ScopeUtilsKt.asLexicalScope(scopeWithImports), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE);
+        KtExpression ktExpression = KtPsiFactoryKt.KtPsiFactory(project).createExpression(expression);
+        KtType type = expressionTypingServices.getType(ScopeUtilsKt.asLexicalScope(scopeWithImports), ktExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE);
         assertTrue(type + " != " + expectedType, type.equals(expectedType));
     }
 
     private void assertErrorType(String expression) {
         Project project = getProject();
-        JetExpression jetExpression = JetPsiFactoryKt.JetPsiFactory(project).createExpression(expression);
-        JetType type = expressionTypingServices.safeGetType(ScopeUtilsKt.asLexicalScope(scopeWithImports), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE);
+        KtExpression ktExpression = KtPsiFactoryKt.KtPsiFactory(project).createExpression(expression);
+        KtType type = expressionTypingServices.safeGetType(ScopeUtilsKt.asLexicalScope(scopeWithImports), ktExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, JetTestUtils.DUMMY_TRACE);
         assertTrue("Error type expected but " + type + " returned", type.isError());
     }
 
     private void assertType(String contextType, final String expression, String expectedType) {
-        final JetType thisType = makeType(contextType);
-        JetScope scope = new AbstractScopeAdapter() {
+        final KtType thisType = makeType(contextType);
+        KtScope scope = new AbstractScopeAdapter() {
             @NotNull
             @Override
-            protected JetScope getWorkerScope() {
+            protected KtScope getWorkerScope() {
                 return scopeWithImports;
             }
 
@@ -572,7 +572,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
             public List<ReceiverParameterDescriptor> getImplicitReceiversHierarchy() {
                 return Lists.<ReceiverParameterDescriptor>newArrayList(new ReceiverParameterDescriptorImpl(
                         getContainingDeclaration(),
-                        new ExpressionReceiver(JetPsiFactoryKt.JetPsiFactory(getProject()).createExpression(expression), thisType)
+                        new ExpressionReceiver(KtPsiFactoryKt.KtPsiFactory(getProject()).createExpression(expression), thisType)
                 ));
             }
         };
@@ -583,16 +583,16 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         assertType(scopeWithImports, expression, expectedTypeStr);
     }
 
-    private void assertType(JetScope scope, String expression, String expectedTypeStr) {
+    private void assertType(KtScope scope, String expression, String expectedTypeStr) {
         Project project = getProject();
-        JetExpression jetExpression = JetPsiFactoryKt.JetPsiFactory(project).createExpression(expression);
-        JetType type = expressionTypingServices.getType(
-                ScopeUtilsKt.asLexicalScope(addImports(scope)), jetExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, new BindingTraceContext());
-        JetType expectedType = expectedTypeStr == null ? null : makeType(expectedTypeStr);
+        KtExpression ktExpression = KtPsiFactoryKt.KtPsiFactory(project).createExpression(expression);
+        KtType type = expressionTypingServices.getType(
+                ScopeUtilsKt.asLexicalScope(addImports(scope)), ktExpression, TypeUtils.NO_EXPECTED_TYPE, DataFlowInfo.EMPTY, new BindingTraceContext());
+        KtType expectedType = expectedTypeStr == null ? null : makeType(expectedTypeStr);
         assertEquals(expectedType, type);
     }
 
-    private JetScope getDeclarationsScope(String path) throws IOException {
+    private KtScope getDeclarationsScope(String path) throws IOException {
         ModuleDescriptor moduleDescriptor = LazyResolveTestUtil.resolve(
                 getProject(),
                 Collections.singletonList(JetTestUtils.loadJetFile(getProject(), new File(path))),
@@ -606,11 +606,11 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     }
 
     @SuppressWarnings("ConstantConditions")
-    private JetScope addImports(JetScope scope) {
+    private KtScope addImports(KtScope scope) {
         WritableScopeImpl writableScope = new WritableScopeImpl(
                 scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports"
         );
-        List<JetScope> scopeChain = new ArrayList<JetScope>();
+        List<KtScope> scopeChain = new ArrayList<KtScope>();
         scopeChain.add(writableScope);
 
         ModuleDescriptor module = LazyResolveTestUtil.resolveProject(getProject(), getEnvironment());
@@ -627,14 +627,14 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         }
         scopeChain.add(module.getPackage(FqName.ROOT).getMemberScope());
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
-        return new ChainedScope(scope.getContainingDeclaration(), "JetTypeCheckerTest.addImports scope with imports", scopeChain.toArray(new JetScope[scopeChain.size()]));
+        return new ChainedScope(scope.getContainingDeclaration(), "JetTypeCheckerTest.addImports scope with imports", scopeChain.toArray(new KtScope[scopeChain.size()]));
     }
 
-    private JetType makeType(String typeStr) {
+    private KtType makeType(String typeStr) {
         return makeType(scopeWithImports, typeStr);
     }
 
-    private JetType makeType(JetScope scope, String typeStr) {
-        return typeResolver.resolveType(ScopeUtilsKt.asLexicalScope(scope), JetPsiFactoryKt.JetPsiFactory(getProject()).createType(typeStr), JetTestUtils.DUMMY_TRACE, true);
+    private KtType makeType(KtScope scope, String typeStr) {
+        return typeResolver.resolveType(ScopeUtilsKt.asLexicalScope(scope), KtPsiFactoryKt.KtPsiFactory(getProject()).createType(typeStr), JetTestUtils.DUMMY_TRACE, true);
     }
 }

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

@@ -33,9 +33,9 @@ import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
-import org.jetbrains.kotlin.psi.JetTypeReference;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtTypeReference;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -56,7 +56,7 @@ import java.util.Map;
 
 @SuppressWarnings("unchecked")
 public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
-    private JetScope scope;
+    private KtScope scope;
     private ContainerForTests container;
 
     @Override
@@ -79,16 +79,16 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
         super.tearDown();
     }
 
-    private JetScope getContextScope() throws IOException {
+    private KtScope getContextScope() throws IOException {
         // todo comments
         String text = FileUtil.loadFile(new File("compiler/testData/type-substitutor.kt"), true);
-        JetFile jetFile = JetPsiFactoryKt.JetPsiFactory(getProject()).createFile(text);
+        KtFile jetFile = KtPsiFactoryKt.KtPsiFactory(getProject()).createFile(text);
         ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment());
-        JetScope topLevelDeclarations = module.getPackage(FqName.ROOT).getMemberScope();
+        KtScope topLevelDeclarations = module.getPackage(FqName.ROOT).getMemberScope();
         ClassifierDescriptor contextClass = topLevelDeclarations.getClassifier(Name.identifier("___Context"), NoLookupLocation.FROM_TEST);
         assert contextClass instanceof ClassDescriptor;
-        WritableScopeImpl typeParameters = new WritableScopeImpl(JetScope.Empty.INSTANCE$, module, RedeclarationHandler.THROW_EXCEPTION,
-                                      "Type parameter scope");
+        WritableScopeImpl typeParameters = new WritableScopeImpl(KtScope.Empty.INSTANCE$, module, RedeclarationHandler.THROW_EXCEPTION,
+                                                                 "Type parameter scope");
         for (TypeParameterDescriptor parameterDescriptor : contextClass.getTypeConstructor().getParameters()) {
             typeParameters.addClassifierDescriptor(parameterDescriptor);
         }
@@ -102,12 +102,12 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
     }
 
     private void doTest(@Nullable String expectedTypeStr, String initialTypeStr, Pair<String, String>... substitutionStrs) {
-        JetType initialType = resolveType(initialTypeStr);
+        KtType initialType = resolveType(initialTypeStr);
 
         Map<TypeConstructor, TypeProjection> map = stringsToSubstitutionMap(substitutionStrs);
         TypeSubstitutor substitutor = TypeSubstitutor.create(map);
 
-        JetType result = substitutor.substitute(initialType, Variance.INVARIANT);
+        KtType result = substitutor.substitute(initialType, Variance.INVARIANT);
 
         if (expectedTypeStr == null) {
             assertNull(result);
@@ -129,7 +129,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
             assertTrue(typeParameterName + " is not a type parameter: " + classifier, classifier instanceof TypeParameterDescriptor);
 
             String typeStr = "C<" + replacementProjectionString + ">";
-            JetType typeWithArgument = resolveType(typeStr);
+            KtType typeWithArgument = resolveType(typeStr);
             assert !typeWithArgument.getArguments().isEmpty() : "No arguments: " + typeWithArgument + " from " + typeStr;
 
             map.put(classifier.getTypeConstructor(), typeWithArgument.getArguments().get(0));
@@ -137,11 +137,11 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
         return map;
     }
 
-    private JetType resolveType(String typeStr) {
-        JetTypeReference jetTypeReference = JetPsiFactoryKt.JetPsiFactory(getProject()).createType(typeStr);
+    private KtType resolveType(String typeStr) {
+        KtTypeReference jetTypeReference = KtPsiFactoryKt.KtPsiFactory(getProject()).createType(typeStr);
         AnalyzingUtils.checkForSyntacticErrors(jetTypeReference);
         BindingTrace trace = new BindingTraceContext();
-        JetType type = container.getTypeResolver().resolveType(ScopeUtilsKt.asLexicalScope(scope), jetTypeReference, trace, true);
+        KtType type = container.getTypeResolver().resolveType(ScopeUtilsKt.asLexicalScope(scope), jetTypeReference, trace, true);
         if (!trace.getBindingContext().getDiagnostics().isEmpty()) {
             fail("Errors:\n" + StringUtil.join(
                     trace.getBindingContext().getDiagnostics(),

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

@@ -28,11 +28,11 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.JetPsiFactoryKt;
-import org.jetbrains.kotlin.psi.JetTypeProjection;
-import org.jetbrains.kotlin.psi.JetTypeReference;
+import org.jetbrains.kotlin.psi.KtPsiFactoryKt;
+import org.jetbrains.kotlin.psi.KtTypeProjection;
+import org.jetbrains.kotlin.psi.KtTypeReference;
 import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.scopes.JetScope;
+import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.kotlin.resolve.scopes.WritableScope;
 import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
@@ -201,24 +201,24 @@ public class TypeUnifierTest extends JetLiteFixture {
         return makeTypeProjection(builtIns.getBuiltInsPackageScope(), typeStr);
     }
 
-    private TypeProjection makeTypeProjection(JetScope scope, String typeStr) {
+    private TypeProjection makeTypeProjection(KtScope scope, String typeStr) {
         WritableScopeImpl withX =
                 new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "With X");
         withX.addClassifierDescriptor(x);
         withX.addClassifierDescriptor(y);
         withX.changeLockLevel(WritableScope.LockLevel.READING);
 
-        JetTypeProjection projection = JetPsiFactoryKt
-                .JetPsiFactory(getProject()).createTypeArguments("<" + typeStr + ">").getArguments().get(0);
+        KtTypeProjection projection = KtPsiFactoryKt
+                .KtPsiFactory(getProject()).createTypeArguments("<" + typeStr + ">").getArguments().get(0);
 
-        JetTypeReference typeReference = projection.getTypeReference();
+        KtTypeReference typeReference = projection.getTypeReference();
         assert typeReference != null;
-        JetType type = typeResolver.resolveType(ScopeUtilsKt.asLexicalScope(withX), typeReference, JetTestUtils.DUMMY_TRACE, true);
+        KtType type = typeResolver.resolveType(ScopeUtilsKt.asLexicalScope(withX), typeReference, JetTestUtils.DUMMY_TRACE, true);
 
         return new TypeProjectionImpl(getProjectionKind(typeStr, projection), type);
     }
 
-    private static Variance getProjectionKind(String typeStr, JetTypeProjection projection) {
+    private static Variance getProjectionKind(String typeStr, KtTypeProjection projection) {
         Variance variance;
         switch (projection.getProjectionKind()) {
             case IN: